@rnsk/toolkits 0.0.8 → 0.0.10

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

@@ -0,0 +1,55 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { GMAPS_ICON } from './icon.js';
+import { googleMapsTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'google-maps',
+    displayName: 'Google Maps',
+    shortDescription: 'Search places, geocode addresses, compute routes, and render map tiles.',
+    category: 'Developer Tools & DevOps',
+    icon: GMAPS_ICON,
+    auth: {
+        type: 'oauth2',
+        tokenField: 'googleMapsToken',
+        provider: {
+            slug: 'google-maps',
+            env: { clientId: 'GOOGLE_MAPS_CLIENT_ID', clientSecret: 'GOOGLE_MAPS_CLIENT_SECRET' },
+            authorizeUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
+            tokenUrl: 'https://oauth2.googleapis.com/token',
+            scopes: [
+                'https://www.googleapis.com/auth/cloud-platform',
+                'https://www.googleapis.com/auth/maps-platform.geocode',
+                'https://www.googleapis.com/auth/maps-platform.geocode.address',
+                'https://www.googleapis.com/auth/maps-platform.geocode.location',
+                'https://www.googleapis.com/auth/maps-platform.geocode.place',
+            ],
+            exchangeStyle: 'form',
+            extraAuthParams: { access_type: 'offline', prompt: 'consent' },
+            connectDescription: 'Connect Google Maps for places, geocoding, routes, and tiles.',
+            callbackPath: '/api/auth/google-maps/callback',
+            stateCookie: 'google_maps_oauth_state',
+        },
+    },
+    allowedHosts: [
+        'places.googleapis.com',
+        'routes.googleapis.com',
+        'geocode.googleapis.com',
+        'tile.googleapis.com',
+        'aerialview.googleapis.com',
+        'www.googleapis.com',
+        'maps.googleapis.com',
+    ],
+    tools: googleMapsTools.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://maps.google.com',
+        docsUrl: 'https://developers.google.com/maps/documentation',
+    },
+});
+//# sourceMappingURL=manifest.js.map

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

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export declare const PLACES_API_BASE = "https://places.googleapis.com/v1";
+export declare const ROUTES_API_BASE = "https://routes.googleapis.com";
+export declare const GEOCODE_API_BASE = "https://geocode.googleapis.com/v4beta";
+export declare const TILE_API_BASE = "https://tile.googleapis.com/v1";
+export declare const AERIAL_API_BASE = "https://aerialview.googleapis.com/v1";
+export declare const googleMapsTokenField: z.ZodString;
+export declare function buildQuery(params: Record<string, string | number | boolean | undefined>): string;
+export interface MapsRequestOptions {
+    method?: string;
+    query?: Record<string, string | number | boolean | undefined>;
+    body?: unknown;
+    headers?: Record<string, string>;
+    responseType?: 'json' | 'bytes';
+}
+export declare function mapsRequest(googleMapsToken: string, base: string, path: string, options?: MapsRequestOptions): Promise<{
+    ok: false;
+    error: any;
+    data?: undefined;
+} | {
+    ok: true;
+    data: any;
+    error?: undefined;
+}>;
+export declare function toFieldMask(mask: string | undefined, prefix: string, fallback: string): string;
+export declare function normalizePlaceName(name: string): string;
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1,72 @@
+// @ts-nocheck
+import { z } from 'zod';
+export const PLACES_API_BASE = 'https://places.googleapis.com/v1';
+export const ROUTES_API_BASE = 'https://routes.googleapis.com';
+export const GEOCODE_API_BASE = 'https://geocode.googleapis.com/v4beta';
+export const TILE_API_BASE = 'https://tile.googleapis.com/v1';
+export const AERIAL_API_BASE = 'https://aerialview.googleapis.com/v1';
+export const googleMapsTokenField = z.string().describe('Google Maps OAuth access token (Bearer)');
+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 mapsRequest(googleMapsToken, base, path, options) {
+    const url = `${base}${path}${buildQuery(options?.query ?? {})}`;
+    const headers = { Authorization: `Bearer ${googleMapsToken}` };
+    if (options?.body !== undefined)
+        headers['Content-Type'] = 'application/json';
+    if (options?.headers)
+        Object.assign(headers, options.headers);
+    const response = await fetch(url, {
+        method: options?.method ?? 'GET',
+        headers,
+        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 === 'bytes') {
+        const bytes = Buffer.from(await response.arrayBuffer());
+        return {
+            ok: true,
+            data: { contentBase64: bytes.toString('base64'), byteSize: bytes.length, mimetype: response.headers.get('content-type') ?? 'application/octet-stream' },
+        };
+    }
+    const data = await response.json().catch(() => ({}));
+    return { ok: true, data };
+}
+export function toFieldMask(mask, prefix, fallback) {
+    if (!mask || mask.trim() === '' || mask.trim() === '*')
+        return fallback;
+    return mask
+        .split(',')
+        .map((f) => f.trim())
+        .filter(Boolean)
+        .map((f) => {
+        if (f.startsWith(`${prefix}.`) || f === prefix)
+            return f;
+        const aliases = {
+            name: 'displayName',
+            address: 'formattedAddress',
+            url: 'websiteUri',
+            website: 'websiteUri',
+            type: 'types',
+            phone: 'nationalPhoneNumber',
+        };
+        return `${prefix}.${aliases[f] ?? f}`;
+    })
+        .join(',');
+}
+export function normalizePlaceName(name) {
+    return name.startsWith('places/') ? name : `places/${name}`;
+}
+//# sourceMappingURL=client.js.map

package/dist/toolkits/google-maps/tools/geocode.d.ts

@@ -0,0 +1,49 @@
+export declare const geocodeAddressWithQuery: import("ai").Tool<{
+    googleMapsToken: string;
+    addressQuery: string;
+    languageCode?: string | undefined;
+    regionCode?: string | undefined;
+}, any>;
+export declare const geocodeDestinations: import("ai").Tool<{
+    googleMapsToken: string;
+    languageCode?: string | undefined;
+    regionCode?: string | undefined;
+    addressQuery?: string | Record<string, any> | undefined;
+    place?: string | undefined;
+    locationQuery?: {
+        location: {
+            latitude: number;
+            longitude: number;
+        };
+    } | undefined;
+    travelModes?: ("DRIVE" | "WALK")[] | undefined;
+}, any>;
+export declare const reverseGeocodeLocation: import("ai").Tool<{
+    googleMapsToken: string;
+    latitude: number;
+    longitude: number;
+    types?: string[] | undefined;
+    languageCode?: string | undefined;
+    regionCode?: string | undefined;
+}, any>;
+export declare const geocodePlace: import("ai").Tool<{
+    googleMapsToken: string;
+    placeId: string;
+    languageCode?: string | undefined;
+    regionCode?: string | undefined;
+}, any>;
+export declare const geocodingApi: import("ai").Tool<{
+    googleMapsToken: string;
+    language?: string | undefined;
+    key?: string | undefined;
+    placeId?: string | undefined;
+    address?: string | undefined;
+    latlng?: string | undefined;
+    bounds?: string | undefined;
+    region?: string | undefined;
+    components?: string | undefined;
+    resultType?: string | undefined;
+    locationType?: string | undefined;
+    extraComputations?: ("ADDRESS_DESCRIPTORS" | "BUILDING_AND_ENTRANCES")[] | undefined;
+}, any>;
+//# sourceMappingURL=geocode.d.ts.map

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

@@ -0,0 +1,168 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { GEOCODE_API_BASE, googleMapsTokenField, mapsRequest } from './client.js';
+export const geocodeAddressWithQuery = tool({
+    description: 'Converts a full address string to coordinates (v4beta). Include city/state/country — vague strings return zero or wrong results. Verify formattedAddress before use.',
+    inputSchema: z.object({
+        googleMapsToken: googleMapsTokenField,
+        addressQuery: z.string().min(1).describe("Full address, e.g. '1600 Amphitheatre Parkway Mountain View CA'"),
+        regionCode: z.string().optional().describe("ccTLD region, e.g. 'US'"),
+        languageCode: z.string().optional().describe("Language, e.g. 'en'"),
+    }),
+    execute: async ({ googleMapsToken, addressQuery, regionCode, languageCode }) => {
+        try {
+            const result = await mapsRequest(googleMapsToken, GEOCODE_API_BASE, '/geocode/address', {
+                query: { address: addressQuery, regionCode, languageCode },
+            });
+            if (!result.ok)
+                return { error: 'Failed to geocode address', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error geocoding address', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const geocodeDestinations = tool({
+    description: 'Returns rich destination data (primary place, containing places, sub-destinations, landmarks, entrances, DRIVE/WALK navigation points) for an address, place ID, or coordinates. Provide exactly one lookup.',
+    inputSchema: z.object({
+        googleMapsToken: googleMapsTokenField,
+        place: z.string().optional().describe("Place resource 'places/{placeId}'"),
+        addressQuery: z.union([z.string(), z.record(z.any())]).optional().describe('Unstructured address string or structured postal address'),
+        locationQuery: z.object({
+            location: z.object({ latitude: z.number().min(-90).max(90), longitude: z.number().min(-180).max(180) }),
+        }).optional().describe('Coordinates lookup'),
+        regionCode: z.string().optional().describe("ccTLD region, e.g. 'US'"),
+        languageCode: z.string().optional().describe("Language, e.g. 'en'"),
+        travelModes: z.array(z.enum(['DRIVE', 'WALK'])).optional().describe('Filter navigation points'),
+    }),
+    execute: async ({ googleMapsToken, place, addressQuery, locationQuery, regionCode, languageCode, travelModes }) => {
+        try {
+            const lookups = [place, addressQuery, locationQuery].filter((v) => v !== undefined);
+            if (lookups.length !== 1)
+                return { error: 'Provide exactly one of place, addressQuery, or locationQuery' };
+            const body = {};
+            if (place)
+                body.place = place;
+            if (addressQuery !== undefined) {
+                body.addressQuery = typeof addressQuery === 'string' ? { addressQuery } : { address: addressQuery };
+            }
+            if (locationQuery)
+                body.locationQuery = locationQuery;
+            if (regionCode)
+                body.regionCode = regionCode;
+            if (languageCode)
+                body.languageCode = languageCode;
+            if (travelModes)
+                body.travelModes = travelModes;
+            const result = await mapsRequest(googleMapsToken, GEOCODE_API_BASE, '/geocode/destinations', {
+                method: 'POST',
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to geocode destinations', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error geocoding destinations', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const reverseGeocodeLocation = tool({
+    description: 'Converts coordinates to addresses. One coordinate pair can return many results — verify formattedAddress and components before committing.',
+    inputSchema: z.object({
+        googleMapsToken: googleMapsTokenField,
+        latitude: z.number().min(-90).max(90),
+        longitude: z.number().min(-180).max(180),
+        regionCode: z.string().optional().describe("ccTLD region, e.g. 'US'"),
+        languageCode: z.string().optional().describe("BCP-47 language, e.g. 'en'"),
+        types: z.array(z.string()).optional().describe('Type tags to keep; others are removed'),
+    }),
+    execute: async ({ googleMapsToken, latitude, longitude, regionCode, languageCode, types }) => {
+        try {
+            const result = await mapsRequest(googleMapsToken, GEOCODE_API_BASE, '/geocode/location', {
+                query: { location: `${latitude},${longitude}`, regionCode, languageCode, types: types?.join(',') },
+            });
+            if (!result.ok)
+                return { error: 'Failed to reverse geocode', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error reverse geocoding', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const geocodePlace = tool({
+    description: 'Looks up address and coordinates for a place ID (places/{id} or bare ID).',
+    inputSchema: z.object({
+        googleMapsToken: googleMapsTokenField,
+        placeId: z.string().describe("Place ID, e.g. 'ChIJj61dQgK6j4AR4GeTYWZsKWw' or 'places/...'"),
+        regionCode: z.string().optional().describe("ccTLD region, e.g. 'US'"),
+        languageCode: z.string().optional().describe("Language, e.g. 'en' (default en)"),
+    }),
+    execute: async ({ googleMapsToken, placeId, regionCode, languageCode }) => {
+        try {
+            const place = placeId.startsWith('places/') ? placeId : `places/${placeId}`;
+            const result = await mapsRequest(googleMapsToken, GEOCODE_API_BASE, '/geocode/place', {
+                query: { place, regionCode, languageCode },
+            });
+            if (!result.ok)
+                return { error: 'Failed to geocode place', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error geocoding place', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const geocodingApi = tool({
+    description: 'Unified v4beta geocoder: forward (address), reverse (latlng), or place-ID lookup. Provide exactly one of address, latlng, or placeId.',
+    inputSchema: z.object({
+        googleMapsToken: googleMapsTokenField,
+        address: z.string().optional().describe("Street address to geocode, e.g. '1600 Amphitheatre Parkway, Mountain View, CA'"),
+        latlng: z.string().optional().describe("Coordinates for reverse geocoding, e.g. '40.714224,-73.961452'"),
+        placeId: z.string().optional().describe('Place ID for place geocoding'),
+        key: z.string().optional().describe('API key override (uses OAuth by default)'),
+        bounds: z.string().optional().describe('Bias viewport sw_lat,sw_lng|ne_lat,ne_lng'),
+        region: z.string().optional().describe("Bias ccTLD region, e.g. 'US'"),
+        language: z.string().optional().describe("Result language, e.g. 'en'"),
+        components: z.string().optional().describe("Restrictive filters, e.g. 'postal_code:94043|country:US'"),
+        resultType: z.string().optional().describe("Filter types for reverse/place, e.g. 'street_address|locality'"),
+        locationType: z.string().optional().describe("Filter location types, e.g. 'ROOFTOP|RANGE_INTERPOLATED'"),
+        extraComputations: z.array(z.enum(['ADDRESS_DESCRIPTORS', 'BUILDING_AND_ENTRANCES'])).optional(),
+    }),
+    execute: async ({ googleMapsToken, address, latlng, placeId, key, ...rest }) => {
+        try {
+            const modes = [address, latlng, placeId].filter((v) => v !== undefined);
+            if (modes.length !== 1)
+                return { error: 'Provide exactly one of address, latlng, or placeId' };
+            const query = { key };
+            for (const [k, v] of Object.entries(rest))
+                if (v !== undefined)
+                    query[k] = String(v);
+            let path;
+            if (address) {
+                path = '/geocode/address';
+                query.address = address;
+            }
+            else if (latlng) {
+                path = '/geocode/location';
+                const [latitude, longitude] = latlng.split(',').map((s) => s.trim());
+                query.location = `${latitude},${longitude}`;
+            }
+            else {
+                path = '/geocode/place';
+                query.place = placeId.startsWith('places/') ? placeId : `places/${placeId}`;
+            }
+            const result = await mapsRequest(googleMapsToken, GEOCODE_API_BASE, path, { query });
+            if (!result.ok)
+                return { error: 'Failed to geocode', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error geocoding', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=geocode.js.map