@rnsk/toolkits 0.0.8 → 0.0.10

package/dist/toolkits/google-maps/tools/tiles.js

@@ -0,0 +1,84 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { TILE_API_BASE, googleMapsTokenField, mapsRequest } from './client.js';
+export const createTilesSession = tool({
+    description: 'Creates a ~2-week session token for 2D tiles and Street View. Each call costs quota — cache and reuse the token.',
+    inputSchema: z.object({
+        googleMapsToken: googleMapsTokenField,
+        mapType: z.enum(['roadmap', 'satellite', 'terrain', 'streetview']).describe('Base map type'),
+        language: z.string().describe("IETF language, e.g. 'en-US'"),
+        region: z.string().describe("CLDR region, e.g. 'US'"),
+        scale: z.enum(['scaleFactor1x', 'scaleFactor2x', 'scaleFactor4x']).optional(),
+        highDpi: z.boolean().optional().describe('High-res tiles (needs 2x/4x scale)'),
+        overlay: z.boolean().optional().describe('Separate layers vs combined image'),
+        layerTypes: z.array(z.enum(['layerRoadmap', 'layerStreetview', 'layerTraffic'])).optional(),
+        styles: z.array(z.record(z.any())).optional().describe('Roadmap JSON styles'),
+        imageFormat: z.enum(['jpeg', 'png']).optional(),
+    }),
+    execute: async ({ googleMapsToken, ...body }) => {
+        try {
+            const result = await mapsRequest(googleMapsToken, TILE_API_BASE, '/createSession', {
+                method: 'POST',
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to create tiles session', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error creating tiles session', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const get2dTile = tool({
+    description: 'Downloads one 2D tile image (PNG/JPEG, ~256px) as base64. Needs a session from createTilesSession; x/y ranges depend on zoom.',
+    inputSchema: z.object({
+        googleMapsToken: googleMapsTokenField,
+        z: z.number().min(0).max(22).describe('Zoom 0 (world) to 22 (detailed)'),
+        x: z.number().min(0).describe('Column in [0, 2^zoom - 1]'),
+        y: z.number().min(0).describe('Row in [0, 2^zoom - 1]'),
+        session: z.string().describe('Session token from createTilesSession'),
+        key: z.string().optional().describe('API key alternative to Bearer auth'),
+        orientation: z.number().optional().describe('Counter-clockwise rotation: 0, 90, 180, or 270'),
+    }),
+    execute: async ({ googleMapsToken, z, x, y, session, key, orientation }) => {
+        try {
+            const max = 2 ** z - 1;
+            if (x > max || y > max)
+                return { error: `x and y must be within [0, ${max}] for zoom ${z}` };
+            const result = await mapsRequest(googleMapsToken, TILE_API_BASE, `/2dtiles/${z}/${x}/${y}`, {
+                query: { session, key, orientation },
+                responseType: 'bytes',
+            });
+            if (!result.ok)
+                return { error: 'Failed to get 2D tile', details: result.error };
+            const data = result.data;
+            return { tile: { name: `tile-${z}-${x}-${y}`, mimetype: data.mimetype ?? 'image/png', contentBase64: data.contentBase64, byteSize: data.byteSize } };
+        }
+        catch (error) {
+            return { error: 'Error getting 2D tile', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const get3dTilesRoot = tool({
+    description: 'Gets the photorealistic 3D tileset root (OGC 3D Tiles) to bootstrap a renderer. Billable per call — cache the response.',
+    inputSchema: z.object({
+        googleMapsToken: googleMapsTokenField,
+        key: z.string().optional().describe('API key alternative to Bearer auth'),
+    }),
+    execute: async ({ googleMapsToken, key }) => {
+        try {
+            const result = await mapsRequest(googleMapsToken, TILE_API_BASE, '/3dtiles/root.json', {
+                query: { key },
+            });
+            if (!result.ok)
+                return { error: 'Failed to get 3D tiles root', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting 3D tiles root', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=tiles.js.map

package/dist/toolkits/google-photos/icon.d.ts

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

package/dist/toolkits/google-photos/icon.js

@@ -0,0 +1,6 @@
+const SVG = `<svg data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 350 350"><defs><radialGradient id="prefix__a" cx="173.161" cy="178.716" fx="239.836" fy="36.176" r="170.886" gradientTransform="matrix(1 0 0 1.041 0 -7.272)" gradientUnits="userSpaceOnUse"><stop offset=".469" stop-color="#7acaff"/><stop offset=".828" stop-color="#00b054"/></radialGradient><radialGradient id="prefix__b" cx="173.161" cy="178.716" fx="239.836" fy="36.176" r="170.886" gradientTransform="matrix(0 1 -1.041 0 357.272 0)" gradientUnits="userSpaceOnUse"><stop offset=".545" stop-color="#fded1c"/><stop offset=".828" stop-color="#feca01"/></radialGradient><radialGradient id="prefix__c" cx="173.161" cy="178.716" fx="239.836" fy="36.176" r="170.886" gradientTransform="matrix(-1 0 0 -1.041 350 357.272)" gradientUnits="userSpaceOnUse"><stop offset=".469" stop-color="#ff81d0"/><stop offset=".828" stop-color="#ff4041"/></radialGradient><radialGradient id="prefix__d" cx="173.161" cy="178.716" fx="239.836" fy="36.176" r="170.886" gradientTransform="matrix(0 -1 1.041 0 -7.272 350)" gradientUnits="userSpaceOnUse"><stop offset=".469" stop-color="#aaa7ff"/><stop offset=".828" stop-color="#2f89ff"/></radialGradient></defs><path d="M79.6 262.5c0-48.3 39.2-87.5 87.5-87.5h7.9v167.1c0 4.4-3.6 7.9-7.9 7.9-48.3 0-87.5-39.2-87.5-87.5z" fill="url(#prefix__a)"/><path d="M87.5 79.6c48.3 0 87.5 39.2 87.5 87.5v7.9H7.9c-4.4 0-7.9-3.6-7.9-7.9 0-48.3 39.2-87.5 87.5-87.5z" fill="url(#prefix__b)"/><path d="M270.4 87.5c0 48.3-39.2 87.5-87.5 87.5H175V7.9c0-4.4 3.6-7.9 7.9-7.9 48.3 0 87.5 39.2 87.5 87.5z" fill="url(#prefix__c)"/><path d="M262.5 270.4c-48.3 0-87.5-39.2-87.5-87.5V175h167.1c4.4 0 7.9 3.6 7.9 7.9 0 48.3-39.2 87.5-87.5 87.5z" fill="url(#prefix__d)"/></svg>`;
+export const GPHOTOS_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

package/dist/toolkits/google-photos/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/google-photos/manifest.js

@@ -0,0 +1,47 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { GPHOTOS_ICON } from './icon.js';
+import { googlePhotosTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'google-photos',
+    displayName: 'Google Photos',
+    shortDescription: 'Manage Google Photos albums, media items, uploads, and enrichment.',
+    category: 'Entertainment & Media',
+    icon: GPHOTOS_ICON,
+    auth: {
+        type: 'oauth2',
+        tokenField: 'googlePhotosToken',
+        provider: {
+            slug: 'google-photos',
+            env: { clientId: 'GOOGLE_PHOTOS_CLIENT_ID', clientSecret: 'GOOGLE_PHOTOS_CLIENT_SECRET' },
+            authorizeUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
+            tokenUrl: 'https://oauth2.googleapis.com/token',
+            scopes: [
+                'https://www.googleapis.com/auth/photoslibrary',
+                'https://www.googleapis.com/auth/photoslibrary.readonly',
+                'https://www.googleapis.com/auth/photoslibrary.appendonly',
+                'https://www.googleapis.com/auth/photoslibrary.edit.appcreateddata',
+                'https://www.googleapis.com/auth/photoslibrary.readonly.appcreateddata',
+            ],
+            exchangeStyle: 'form',
+            extraAuthParams: { access_type: 'offline', prompt: 'consent' },
+            connectDescription: 'Connect Google Photos to manage albums, uploads, and app-created media.',
+            callbackPath: '/api/auth/google-photos/callback',
+            stateCookie: 'google_photos_oauth_state',
+        },
+    },
+    allowedHosts: ['photoslibrary.googleapis.com'],
+    tools: googlePhotosTools.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://photos.google.com',
+        docsUrl: 'https://developers.google.com/photos',
+    },
+});
+//# sourceMappingURL=manifest.js.map

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

@@ -0,0 +1,83 @@
+export declare const createAlbum: import("ai").Tool<{
+    title: string;
+    googlePhotosToken: string;
+}, any>;
+export declare const getAlbum: import("ai").Tool<{
+    googlePhotosToken: string;
+    albumId: string;
+}, any>;
+export declare const listAlbums: import("ai").Tool<{
+    googlePhotosToken: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+    excludeNonAppCreatedData?: boolean | undefined;
+}, any>;
+export declare const updateAlbum: import("ai").Tool<{
+    googlePhotosToken: string;
+    albumId: string;
+    title?: string | undefined;
+    coverPhotoMediaItemId?: string | undefined;
+}, any>;
+export declare const addEnrichment: 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>;
+export declare const batchAddMediaItems: 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;
+}>;
+//# sourceMappingURL=albums.d.ts.map

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

@@ -0,0 +1,180 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { googlePhotosTokenField, photosRequest } from './client.js';
+const albumPosition = z.object({
+    position: z.enum(['POSITION_TYPE_UNSPECIFIED', 'FIRST_IN_ALBUM', 'LAST_IN_ALBUM', 'AFTER_MEDIA_ITEM', 'AFTER_ENRICHMENT_ITEM']),
+    relativeMediaItemId: z.string().optional().describe('Required for AFTER_MEDIA_ITEM'),
+    relativeEnrichmentItemId: z.string().optional().describe('Required for AFTER_ENRICHMENT_ITEM'),
+});
+export const createAlbum = tool({
+    description: 'Creates an album with a title (max 500 chars). Add items afterwards with batchAddMediaItems.',
+    inputSchema: z.object({
+        googlePhotosToken: googlePhotosTokenField,
+        title: z.string().min(1).max(500).describe('Album title'),
+    }),
+    execute: async ({ googlePhotosToken, title }) => {
+        try {
+            const result = await photosRequest(googlePhotosToken, '/albums', {
+                method: 'POST',
+                body: { album: { title } },
+            });
+            if (!result.ok)
+                return { error: 'Failed to create album', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error creating album', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getAlbum = tool({
+    description: 'Gets an album by ID.',
+    inputSchema: z.object({
+        googlePhotosToken: googlePhotosTokenField,
+        albumId: z.string().describe('Album ID'),
+    }),
+    execute: async ({ googlePhotosToken, albumId }) => {
+        try {
+            const result = await photosRequest(googlePhotosToken, `/albums/${albumId}`);
+            if (!result.ok)
+                return { error: 'Failed to get album', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting album', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listAlbums = tool({
+    description: 'Lists albums in the Albums tab with pagination.',
+    inputSchema: z.object({
+        googlePhotosToken: googlePhotosTokenField,
+        pageSize: z.number().min(1).max(50).optional().describe('Albums per page (default 20, max 50)'),
+        pageToken: z.string().optional(),
+        excludeNonAppCreatedData: z.boolean().optional().describe('Only app-created media counts'),
+    }),
+    execute: async ({ googlePhotosToken, pageSize, pageToken, excludeNonAppCreatedData }) => {
+        try {
+            const result = await photosRequest(googlePhotosToken, '/albums', {
+                query: { pageSize, pageToken, excludeNonAppCreatedData },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list albums', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing albums', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const updateAlbum = tool({
+    description: 'Updates an app-created album title and/or cover photo. Provide at least one of title or coverPhotoMediaItemId.',
+    inputSchema: z.object({
+        googlePhotosToken: googlePhotosTokenField,
+        albumId: z.string().describe('Album ID to update'),
+        title: z.string().max(500).optional().describe('New title'),
+        coverPhotoMediaItemId: z.string().optional().describe('Media item ID for the cover'),
+    }),
+    execute: async ({ googlePhotosToken, albumId, title, coverPhotoMediaItemId }) => {
+        try {
+            if (title === undefined && coverPhotoMediaItemId === undefined) {
+                return { error: 'Provide title and/or coverPhotoMediaItemId' };
+            }
+            const mask = [];
+            const body = {};
+            if (title !== undefined) {
+                mask.push('title');
+                body.title = title;
+            }
+            if (coverPhotoMediaItemId !== undefined) {
+                mask.push('coverPhotoMediaItemId');
+                body.coverPhotoMediaItemId = coverPhotoMediaItemId;
+            }
+            const result = await photosRequest(googlePhotosToken, `/albums/${albumId}`, {
+                method: 'PATCH',
+                query: { updateMask: mask.join(',') },
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to update album', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error updating album', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const addEnrichment = tool({
+    description: 'Adds a text, location, or map enrichment at a position in an album. AFTER_* positions need the relative item ID.',
+    inputSchema: z.object({
+        googlePhotosToken: googlePhotosTokenField,
+        albumId: z.string().describe('Album ID'),
+        newEnrichmentItem: z.object({
+            textEnrichment: z.object({ text: z.string() }).optional(),
+            locationEnrichment: z.object({
+                location: z.object({
+                    locationName: z.string(),
+                    latlng: z.object({ latitude: z.number().min(-90).max(90), longitude: z.number().min(-180).max(180) }),
+                }),
+            }).optional(),
+            mapEnrichment: z.object({
+                origin: z.object({
+                    locationName: z.string(),
+                    latlng: z.object({ latitude: z.number().min(-90).max(90), longitude: z.number().min(-180).max(180) }),
+                }),
+                destination: z.object({
+                    locationName: z.string(),
+                    latlng: z.object({ latitude: z.number().min(-90).max(90), longitude: z.number().min(-180).max(180) }),
+                }),
+            }).optional(),
+        }).describe('Exactly one of text/location/map enrichment'),
+        albumPosition: albumPosition.describe('Insert position'),
+    }),
+    execute: async ({ googlePhotosToken, albumId, newEnrichmentItem, albumPosition }) => {
+        try {
+            const kinds = ['textEnrichment', 'locationEnrichment', 'mapEnrichment'].filter((k) => newEnrichmentItem[k] !== undefined);
+            if (kinds.length !== 1)
+                return { error: 'newEnrichmentItem must contain exactly one of textEnrichment, locationEnrichment, mapEnrichment' };
+            if (albumPosition.position === 'AFTER_MEDIA_ITEM' && !albumPosition.relativeMediaItemId) {
+                return { error: 'AFTER_MEDIA_ITEM requires relativeMediaItemId' };
+            }
+            if (albumPosition.position === 'AFTER_ENRICHMENT_ITEM' && !albumPosition.relativeEnrichmentItemId) {
+                return { error: 'AFTER_ENRICHMENT_ITEM requires relativeEnrichmentItemId' };
+            }
+            const result = await photosRequest(googlePhotosToken, `/albums/${albumId}:addEnrichment`, {
+                method: 'POST',
+                body: { newEnrichmentItem, albumPosition },
+            });
+            if (!result.ok)
+                return { error: 'Failed to add enrichment', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error adding enrichment', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const batchAddMediaItems = tool({
+    description: 'Adds up to 50 app-created media items to an app-created album.',
+    inputSchema: z.object({
+        googlePhotosToken: googlePhotosTokenField,
+        albumId: z.string().min(1).describe('App-created album ID'),
+        mediaItemIds: z.array(z.string()).min(1).max(50).describe('App-created media item IDs'),
+    }),
+    execute: async ({ googlePhotosToken, albumId, mediaItemIds }) => {
+        try {
+            const result = await photosRequest(googlePhotosToken, `/albums/${albumId}:batchAddMediaItems`, {
+                method: 'POST',
+                body: { mediaItemIds },
+            });
+            if (!result.ok)
+                return { error: 'Failed to add media items to album', details: result.error };
+            return { albumId, mediaItemsAdded: mediaItemIds.length, message: 'Successfully added media items to album' };
+        }
+        catch (error) {
+            return { error: 'Error adding media items to album', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=albums.js.map

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

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export declare const PHOTOS_API_BASE = "https://photoslibrary.googleapis.com/v1";
+export declare const googlePhotosTokenField: z.ZodString;
+export declare function buildQuery(params: Record<string, string | number | boolean | string[] | undefined>): string;
+export declare function photosRequest(googlePhotosToken: string, path: string, options?: {
+    method?: string;
+    query?: Record<string, string | number | boolean | string[] | undefined>;
+    body?: unknown;
+}): Promise<{
+    ok: false;
+    error: any;
+    data?: undefined;
+} | {
+    ok: true;
+    data: any;
+    error?: undefined;
+}>;
+export declare function uploadBytes(googlePhotosToken: string, fileName: string, bytes: Buffer, contentType: string): Promise<string>;
+export declare function fetchUrlBytes(url: string): Promise<{
+    bytes: Buffer;
+    contentType: string;
+}>;
+export declare function fileNameFromUrl(url: string, fallback: string): string;
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1,77 @@
+// @ts-nocheck
+import { z } from 'zod';
+export const PHOTOS_API_BASE = 'https://photoslibrary.googleapis.com/v1';
+export const googlePhotosTokenField = z.string().describe('Google Photos OAuth access token (Bearer)');
+export function buildQuery(params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value === undefined)
+            continue;
+        if (Array.isArray(value)) {
+            for (const v of value)
+                search.append(key, String(v));
+        }
+        else {
+            search.set(key, String(value));
+        }
+    }
+    const qs = search.toString();
+    return qs ? `?${qs}` : '';
+}
+export async function photosRequest(googlePhotosToken, path, options) {
+    const url = `${PHOTOS_API_BASE}${path}${buildQuery(options?.query ?? {})}`;
+    const response = await fetch(url, {
+        method: options?.method ?? 'GET',
+        headers: {
+            Authorization: `Bearer ${googlePhotosToken}`,
+            ...(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 } };
+    }
+    const data = await response.json().catch(() => ({}));
+    return { ok: true, data };
+}
+export async function uploadBytes(googlePhotosToken, fileName, bytes, contentType) {
+    const response = await fetch(`${PHOTOS_API_BASE}/uploads`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${googlePhotosToken}`,
+            'Content-Type': 'application/octet-stream',
+            'X-Goog-Upload-Content-Type': contentType,
+            'X-Goog-Upload-Protocol': 'raw',
+            'X-Goog-Upload-File-Name': fileName,
+        },
+        body: bytes,
+    });
+    if (!response.ok) {
+        const details = await response.json().catch(() => ({}));
+        throw new Error(`Upload failed: ${JSON.stringify(details)}`);
+    }
+    return response.text();
+}
+export async function fetchUrlBytes(url) {
+    const response = await fetch(url);
+    if (!response.ok)
+        throw new Error(`Failed to fetch file (HTTP ${response.status})`);
+    return {
+        bytes: Buffer.from(await response.arrayBuffer()),
+        contentType: response.headers.get('content-type') ?? 'application/octet-stream',
+    };
+}
+export function fileNameFromUrl(url, fallback) {
+    try {
+        const name = new URL(url).pathname.split('/').filter(Boolean).pop();
+        return name && name.includes('.') ? decodeURIComponent(name) : fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+//# sourceMappingURL=client.js.map