@rnsk/toolkits 0.0.8 → 0.0.9

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

@@ -0,0 +1,158 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { AERIAL_API_BASE, googleMapsTokenField, mapsRequest } from './client.js';
+export const geolocateDevice = tool({
+    description: 'Estimates device location from cell towers and WiFi (2+ APs recommended). Falls back to IP unless considerIp=false.',
+    inputSchema: z.object({
+        googleMapsToken: googleMapsTokenField,
+        key: z.string().optional().describe('API key (Geolocation prefers key auth)'),
+        homeMobileCountryCode: z.number().min(0).max(999).optional(),
+        homeMobileNetworkCode: z.number().min(0).max(32767).optional(),
+        radioType: z.enum(['gsm', 'cdma', 'wcdma', 'lte', 'nr']).optional().describe("Radio type (default 'gsm')"),
+        carrier: z.string().optional(),
+        considerIp: z.boolean().optional().describe('IP fallback (default true)'),
+        cellTowers: z.array(z.record(z.any())).optional().describe('Cell towers with cellId/MCC/MNC/LAC'),
+        wifiAccessPoints: z.array(z.object({
+            macAddress: z.string().describe('Colon-separated MAC'),
+            signalStrength: z.number().min(-128).max(-10).optional().describe('dBm (-128 to -10)'),
+            age: z.number().min(0).optional(),
+            channel: z.number().min(1).optional(),
+            signalToNoiseRatio: z.number().optional(),
+        })).optional(),
+    }),
+    execute: async ({ googleMapsToken, key, ...body }) => {
+        try {
+            const result = await mapsRequest(googleMapsToken, 'https://www.googleapis.com', '/geolocation/v1/geolocate', {
+                method: 'POST',
+                query: { key },
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to geolocate device', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error geolocating device', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getTimeZone = tool({
+    description: 'Gets time zone ID, UTC/DST offsets, and localized name for coordinates at a Unix timestamp (DST-aware).',
+    inputSchema: z.object({
+        googleMapsToken: googleMapsTokenField,
+        location: z.string().describe("Coordinates 'lat,lng', e.g. '39.6034810,-119.6822510'"),
+        timestamp: z.number().describe('Unix epoch seconds for DST evaluation'),
+        language: z.string().optional().describe("Language for the zone name, e.g. 'en'"),
+        key: z.string().optional().describe('API key alternative to Bearer auth'),
+    }),
+    execute: async ({ googleMapsToken, location, timestamp, language, key }) => {
+        try {
+            const result = await mapsRequest(googleMapsToken, 'https://maps.googleapis.com', '/maps/api/timezone/json', {
+                query: { location, timestamp, language, key },
+            });
+            if (!result.ok)
+                return { error: 'Failed to get time zone', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting time zone', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+const embedParams = z.record(z.any()).optional().describe('Mode params: zoom, center, region, maptype, language plus mode-specific fields');
+export const embedGoogleMap = tool({
+    description: 'Builds a public Maps Embed URL + iframe for place/view/directions/streetview/search. API-key only (no OAuth) — pass apiKey. No API call is made.',
+    inputSchema: z.object({
+        mode: z.enum(['place', 'view', 'directions', 'streetview', 'search']).describe('Embed mode'),
+        apiKey: z.string().describe('Maps API key (Embed requires key auth)'),
+        placeParams: z.object({ q: z.string().describe('Place name, address, plus code, or place_id:...') }).catchall(z.unknown()).optional().describe("Place mode (q required)"),
+        viewParams: z.object({ center: z.string().describe("Center 'lat,lng' (required)") }).catchall(z.unknown()).optional().describe('View mode'),
+        directionsParams: z.object({ origin: z.string(), destination: z.string() }).catchall(z.unknown()).optional().describe('Directions mode (origin + destination required)'),
+        streetviewParams: z.object({}).catchall(z.unknown()).optional().describe("Streetview mode (location or pano required)"),
+        searchParams: z.object({ q: z.string().describe('Search term (required)') }).catchall(z.unknown()).optional().describe('Search mode'),
+    }),
+    execute: async ({ mode, apiKey, placeParams, viewParams, directionsParams, streetviewParams, searchParams }) => {
+        try {
+            const modeParams = { place: placeParams, view: viewParams, directions: directionsParams, streetview: streetviewParams, search: searchParams }[mode];
+            if (!modeParams)
+                return { error: `Parameters for mode '${mode}' are required` };
+            const required = {
+                place: ['q'],
+                view: ['center'],
+                directions: ['origin', 'destination'],
+                streetview: [],
+                search: ['q'],
+            };
+            for (const field of required[mode]) {
+                if (modeParams[field] === undefined) {
+                    return { error: `Mode '${mode}' requires '${field}'` };
+                }
+            }
+            if (mode === 'streetview' && modeParams.location === undefined && modeParams.pano === undefined) {
+                return { error: "Streetview mode requires 'location' or 'pano'" };
+            }
+            const search = new URLSearchParams({ key: apiKey });
+            for (const [k, v] of Object.entries(modeParams)) {
+                if (v !== undefined)
+                    search.set(k, String(v));
+            }
+            const iframeUrl = `https://www.google.com/maps/embed/v1/${mode}?${search.toString()}`;
+            return {
+                iframeUrl,
+                htmlEmbedCode: `<iframe width="600" height="450" style="border:0" loading="lazy" allowfullscreen referrerpolicy="no-referrer-when-downgrade" src="${iframeUrl}"></iframe>`,
+            };
+        }
+        catch (error) {
+            return { error: 'Error building embed URL', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const lookupAerialVideo = tool({
+    description: 'Looks up an aerial video by US address or video ID. Receiving a video is billable; poll state until ACTIVE for URIs.',
+    inputSchema: z.object({
+        googleMapsToken: googleMapsTokenField,
+        address: z.string().optional().describe('US postal address (exclusive with videoId)'),
+        videoId: z.string().optional().describe('ID from renderVideo (exclusive with address)'),
+        key: z.string().optional().describe('API key alternative to Bearer auth'),
+    }),
+    execute: async ({ googleMapsToken, address, videoId, key }) => {
+        try {
+            if (!!address === !!videoId)
+                return { error: 'Provide exactly one of address or videoId' };
+            const result = await mapsRequest(googleMapsToken, AERIAL_API_BASE, '/videos:lookupVideo', {
+                query: { address, videoId, key },
+            });
+            if (!result.ok)
+                return { error: 'Failed to look up aerial video', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error looking up aerial video', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const renderAerialVideo = tool({
+    description: 'Starts an aerial video render for a US address. Returns a videoId — poll lookupVideo until ACTIVE (takes up to hours).',
+    inputSchema: z.object({
+        googleMapsToken: googleMapsTokenField,
+        address: z.string().describe('US postal address with street, city, state, postal code'),
+        key: z.string().optional().describe('API key alternative to Bearer auth'),
+    }),
+    execute: async ({ googleMapsToken, address, key }) => {
+        try {
+            const result = await mapsRequest(googleMapsToken, AERIAL_API_BASE, '/videos:renderVideo', {
+                method: 'POST',
+                query: { key },
+                body: { address },
+            });
+            if (!result.ok)
+                return { error: 'Failed to render aerial video', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error rendering aerial video', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=misc.js.map

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

@@ -0,0 +1,112 @@
+export declare const autocompletePlaces: import("ai").Tool<{
+    input: string;
+    googleMapsToken: string;
+    origin?: {
+        latitude: number;
+        longitude: number;
+    } | undefined;
+    languageCode?: string | undefined;
+    regionCode?: string | undefined;
+    sessionToken?: string | undefined;
+    inputOffset?: number | undefined;
+    locationBias?: {
+        circle?: {
+            center: {
+                latitude: number;
+                longitude: number;
+            };
+            radius: number;
+        } | undefined;
+        rectangle?: {
+            low: {
+                latitude: number;
+                longitude: number;
+            };
+            high: {
+                latitude: number;
+                longitude: number;
+            };
+        } | undefined;
+    } | undefined;
+    locationRestriction?: {
+        circle?: {
+            center: {
+                latitude: number;
+                longitude: number;
+            };
+            radius: number;
+        } | undefined;
+        rectangle?: {
+            low: {
+                latitude: number;
+                longitude: number;
+            };
+            high: {
+                latitude: number;
+                longitude: number;
+            };
+        } | undefined;
+    } | undefined;
+    includedRegionCodes?: string[] | undefined;
+    includedPrimaryTypes?: string[] | undefined;
+    includeQueryPredictions?: boolean | undefined;
+    includePureServiceAreaBusinesses?: boolean | undefined;
+}, any>;
+export declare const getPlaceDetails: import("ai").Tool<{
+    name: string;
+    googleMapsToken: string;
+    languageCode?: string | undefined;
+    regionCode?: string | undefined;
+    sessionToken?: string | undefined;
+    fieldMask?: string | undefined;
+}, any>;
+export declare const textSearchPlaces: import("ai").Tool<{
+    googleMapsToken: string;
+    textQuery: string;
+    fieldMask?: string | undefined;
+    maxResultCount?: number | undefined;
+}, any>;
+export declare const nearbySearchPlaces: import("ai").Tool<{
+    googleMapsToken: string;
+    latitude: number;
+    longitude: number;
+    radius: number;
+    fieldMask?: string | undefined;
+    maxResultCount?: number | undefined;
+    includedTypes?: string[] | undefined;
+    excludedTypes?: string[] | undefined;
+}, any>;
+export declare const getPlacePhoto: import("ai").Tool<{
+    googleMapsToken: string;
+    photoReference: string;
+    apiKey?: string | undefined;
+    maxWidthPx?: number | undefined;
+    maxHeightPx?: number | undefined;
+    skipHttpRedirect?: boolean | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    photo?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    photo?: undefined;
+    message?: undefined;
+} | {
+    photo: {
+        name: string;
+        mimetype: string;
+        contentBase64: string | undefined;
+        byteSize: number | undefined;
+    };
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    photo?: undefined;
+}>;
+//# sourceMappingURL=places.d.ts.map

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

@@ -0,0 +1,185 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { PLACES_API_BASE, googleMapsTokenField, mapsRequest, normalizePlaceName, toFieldMask, } from './client.js';
+const latlng = z.object({
+    latitude: z.number().min(-90).max(90),
+    longitude: z.number().min(-180).max(180),
+});
+const circleArea = z.object({
+    center: latlng.describe('Center point'),
+    radius: z.number().min(0).max(50000).describe('Radius in meters (0-50000)'),
+});
+const rectangleArea = z.object({
+    low: latlng.describe('Southwest corner'),
+    high: latlng.describe('Northeast corner'),
+});
+const areaSchema = z.object({ circle: circleArea.optional(), rectangle: rectangleArea.optional() });
+export const autocompletePlaces = tool({
+    description: 'Returns up to 5 place/query predictions for as-you-type input, ordered by relevance. Use a sessionToken to group calls for billing.',
+    inputSchema: z.object({
+        googleMapsToken: googleMapsTokenField,
+        input: z.string().min(1).describe('Text to predict: names, addresses, plus codes'),
+        languageCode: z.string().optional().describe("BCP-47 language, e.g. 'en-US'"),
+        regionCode: z.string().optional().describe("ccTLD region for formatting, e.g. 'us'"),
+        sessionToken: z.string().optional().describe('Session string for billing grouping'),
+        origin: latlng.optional().describe('Point for distance calculations'),
+        inputOffset: z.number().min(0).optional().describe('Cursor offset in input'),
+        locationBias: areaSchema.optional().describe('Area to prefer'),
+        locationRestriction: areaSchema.optional().describe('Area to restrict to'),
+        includedRegionCodes: z.array(z.string()).max(15).optional().describe('ISO country codes to restrict to (disables query predictions)'),
+        includedPrimaryTypes: z.array(z.string()).max(5).optional().describe("Place types, e.g. ['restaurant']"),
+        includeQueryPredictions: z.boolean().optional(),
+        includePureServiceAreaBusinesses: z.boolean().optional(),
+    }),
+    execute: async ({ googleMapsToken, ...body }) => {
+        try {
+            const result = await mapsRequest(googleMapsToken, PLACES_API_BASE, '/places:autocomplete', {
+                method: 'POST',
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to autocomplete places', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error autocompleting places', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getPlaceDetails = tool({
+    description: 'Gets full details for a place ID (find IDs via text/nearby search first — never pass names or addresses). Select fields via fieldMask for cost/performance.',
+    inputSchema: z.object({
+        googleMapsToken: googleMapsTokenField,
+        name: z.string().describe("Place ID as 'places/{id}' or bare ID"),
+        fieldMask: z.string().optional().describe("Fields, e.g. 'id,displayName,formattedAddress' (default those three)"),
+        languageCode: z.string().optional().describe("BCP-47 language, e.g. 'en'"),
+        regionCode: z.string().optional().describe("CLDR region, e.g. 'US'"),
+        sessionToken: z.string().optional().describe('Autocomplete session token for billing'),
+    }),
+    execute: async ({ googleMapsToken, name, fieldMask, languageCode, regionCode, sessionToken }) => {
+        try {
+            const result = await mapsRequest(googleMapsToken, PLACES_API_BASE, `/${normalizePlaceName(name)}`, {
+                query: { languageCode, regionCode, sessionToken },
+                headers: { 'X-Goog-FieldMask': toFieldMask(fieldMask, '', 'id,displayName,formattedAddress') },
+            });
+            if (!result.ok)
+                return { error: 'Failed to get place details', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting place details', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const textSearchPlaces = tool({
+    description: 'Searches places by text query ("restaurants in London"). Include city/region/type for precision; filter CLOSED places by businessStatus; dedupe by id; throttle ~1 req/s.',
+    inputSchema: z.object({
+        googleMapsToken: googleMapsTokenField,
+        textQuery: z.string().min(1).describe('Query matched against name, address, category'),
+        fieldMask: z.string().optional().describe("Fields (default 'places.displayName,places.formattedAddress,places.priceLevel')"),
+        maxResultCount: z.number().min(1).max(20).optional().describe('Results to return (1-20, default 10)'),
+    }),
+    execute: async ({ googleMapsToken, textQuery, fieldMask, maxResultCount }) => {
+        try {
+            const result = await mapsRequest(googleMapsToken, PLACES_API_BASE, '/places:searchText', {
+                method: 'POST',
+                headers: { 'X-Goog-FieldMask': toFieldMask(fieldMask, 'places', 'places.displayName,places.formattedAddress,places.priceLevel') },
+                body: { textQuery, maxResultCount },
+            });
+            if (!result.ok)
+                return { error: 'Failed to text search places', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error text searching places', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const nearbySearchPlaces = tool({
+    description: 'Finds places in a circle (radius ≤50000m, max 20 results). Use Table-A types (restaurant, not food); locality/city/town/sublocality/landmark are invalid filters.',
+    inputSchema: z.object({
+        googleMapsToken: googleMapsTokenField,
+        latitude: z.number().min(-90).max(90).describe('Search center latitude'),
+        longitude: z.number().min(-180).max(180).describe('Search center longitude'),
+        radius: z.number().min(0).max(50000).describe('Radius in meters'),
+        includedTypes: z.array(z.string()).max(50).optional().describe("Table-A types to include, e.g. ['restaurant']"),
+        excludedTypes: z.array(z.string()).max(50).optional().describe('Table-A types to exclude'),
+        maxResultCount: z.number().min(1).max(20).optional().describe('Results (1-20, default 10)'),
+        fieldMask: z.string().optional().describe("Fields (default 'places.displayName')"),
+    }),
+    execute: async ({ googleMapsToken, latitude, longitude, radius, includedTypes, excludedTypes, maxResultCount, fieldMask }) => {
+        try {
+            const body = {
+                locationRestriction: { circle: { center: { latitude, longitude }, radius } },
+            };
+            if (includedTypes)
+                body.includedTypes = includedTypes;
+            if (excludedTypes)
+                body.excludedTypes = excludedTypes;
+            if (maxResultCount !== undefined)
+                body.maxResultCount = maxResultCount;
+            const result = await mapsRequest(googleMapsToken, PLACES_API_BASE, '/places:searchNearby', {
+                method: 'POST',
+                headers: { 'X-Goog-FieldMask': toFieldMask(fieldMask, 'places', 'places.displayName') },
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to nearby search places', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error nearby searching places', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getPlacePhoto = tool({
+    description: 'Downloads a place photo by resource name (places/{id}/photos/{ref}) as base64 bytes. Needs maxWidthPx and/or maxHeightPx (1-4800). Show attribution from the search/details response.',
+    inputSchema: z.object({
+        googleMapsToken: googleMapsTokenField,
+        photoReference: z.string().describe("Photo name 'places/{id}/photos/{ref}' (legacy bare refs need apiKey)"),
+        maxWidthPx: z.number().min(1).max(4800).optional().describe('Max width (1-4800)'),
+        maxHeightPx: z.number().min(1).max(4800).optional().describe('Max height (1-4800)'),
+        apiKey: z.string().optional().describe('API key for legacy bare photo references'),
+        skipHttpRedirect: z.boolean().optional(),
+    }),
+    execute: async ({ googleMapsToken, photoReference, maxWidthPx, maxHeightPx, apiKey, skipHttpRedirect }) => {
+        try {
+            if (photoReference.startsWith('places/')) {
+                if (maxWidthPx === undefined && maxHeightPx === undefined) {
+                    return { error: 'Provide maxWidthPx and/or maxHeightPx' };
+                }
+                const result = await mapsRequest(googleMapsToken, PLACES_API_BASE, `/${photoReference}/media`, {
+                    query: { maxWidthPx, maxHeightPx, skipHttpRedirect },
+                    responseType: 'bytes',
+                });
+                if (!result.ok)
+                    return { error: 'Failed to get place photo', details: result.error };
+                const data = result.data;
+                return { photo: { name: `photo-${Date.now()}.jpg`, mimetype: data.mimetype ?? 'image/jpeg', contentBase64: data.contentBase64, byteSize: data.byteSize } };
+            }
+            if (!apiKey)
+                return { error: 'Legacy photo references require apiKey' };
+            const url = `https://maps.googleapis.com/maps/api/place/photo?photoreference=${encodeURIComponent(photoReference)}` +
+                `&key=${encodeURIComponent(apiKey)}` +
+                (maxWidthPx !== undefined ? `&maxwidth=${maxWidthPx}` : '') +
+                (maxHeightPx !== undefined ? `&maxheight=${maxHeightPx}` : '');
+            const response = await fetch(url);
+            if (!response.ok)
+                return { error: `Photo download failed (HTTP ${response.status})` };
+            const bytes = Buffer.from(await response.arrayBuffer());
+            return {
+                photo: {
+                    name: `photo-${Date.now()}.jpg`,
+                    mimetype: response.headers.get('content-type') ?? 'image/jpeg',
+                    contentBase64: bytes.toString('base64'),
+                    byteSize: bytes.length,
+                },
+            };
+        }
+        catch (error) {
+            return { error: 'Error getting place photo', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=places.js.map

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

@@ -0,0 +1,48 @@
+export declare const computeRouteMatrix: import("ai").Tool<{
+    googleMapsToken: string;
+    origins: {
+        latitude?: number | undefined;
+        longitude?: number | undefined;
+        address?: string | undefined;
+    }[];
+    destinations: {
+        latitude?: number | undefined;
+        longitude?: number | undefined;
+        address?: string | undefined;
+    }[];
+    languageCode?: string | undefined;
+    fieldMask?: string | undefined;
+    travelMode?: "DRIVE" | "WALK" | "BICYCLE" | "TWO_WHEELER" | "TRANSIT" | undefined;
+    routingPreference?: "ROUTING_PREFERENCE_UNSPECIFIED" | "TRAFFIC_UNAWARE" | "TRAFFIC_AWARE" | "TRAFFIC_AWARE_OPTIMAL" | undefined;
+    units?: "METRIC" | "IMPERIAL" | undefined;
+}, any>;
+export declare const getRoute: import("ai").Tool<{
+    googleMapsToken: string;
+    originAddress: string;
+    destinationAddress: string;
+    languageCode?: string | undefined;
+    fieldMask?: string | undefined;
+    travelMode?: "DRIVE" | "WALK" | "BICYCLE" | "TWO_WHEELER" | "TRANSIT" | undefined;
+    routingPreference?: "ROUTING_PREFERENCE_UNSPECIFIED" | "TRAFFIC_UNAWARE" | "TRAFFIC_AWARE" | "TRAFFIC_AWARE_OPTIMAL" | undefined;
+    units?: "METRIC" | "IMPERIAL" | undefined;
+    avoidTolls?: boolean | undefined;
+    avoidHighways?: boolean | undefined;
+    avoidFerries?: boolean | undefined;
+    computeAlternativeRoutes?: boolean | undefined;
+}, {
+    error: string;
+    details: any;
+    responseData?: undefined;
+    message?: undefined;
+} | {
+    responseData: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    responseData?: undefined;
+}>;
+//# sourceMappingURL=routes.d.ts.map

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

@@ -0,0 +1,97 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { ROUTES_API_BASE, googleMapsTokenField, mapsRequest } from './client.js';
+const waypoint = z.object({
+    address: z.string().optional().describe('Address string'),
+    latitude: z.number().optional(),
+    longitude: z.number().optional(),
+});
+function toRouteWaypoint(w) {
+    if (w.address)
+        return { address: w.address };
+    return { location: { latLng: { latitude: w.latitude, longitude: w.longitude } } };
+}
+export const computeRouteMatrix = tool({
+    description: 'Computes distance/duration for every origin×destination pair (cap 625 elements — chunk larger sets). Map results via originIndex/destinationIndex; only trust condition ROUTE_EXISTS.',
+    inputSchema: z.object({
+        googleMapsToken: googleMapsTokenField,
+        origins: z.array(waypoint).min(1).describe('Origins as addresses or lat/lng'),
+        destinations: z.array(waypoint).min(1).describe('Destinations as addresses or lat/lng'),
+        travelMode: z.enum(['DRIVE', 'BICYCLE', 'WALK', 'TWO_WHEELER', 'TRANSIT']).optional().describe('Default DRIVE'),
+        routingPreference: z.enum(['ROUTING_PREFERENCE_UNSPECIFIED', 'TRAFFIC_UNAWARE', 'TRAFFIC_AWARE', 'TRAFFIC_AWARE_OPTIMAL']).optional().describe('Default TRAFFIC_AWARE'),
+        languageCode: z.string().optional().describe("BCP-47 language (default 'en-US')"),
+        units: z.enum(['METRIC', 'IMPERIAL']).optional().describe('Display units only; distanceMeters stays metric (default IMPERIAL)'),
+        fieldMask: z.string().optional().describe("Response fields (default 'originIndex,destinationIndex,duration,distanceMeters,status,condition')"),
+    }),
+    execute: async ({ googleMapsToken, origins, destinations, travelMode, routingPreference, languageCode, units, fieldMask }) => {
+        try {
+            if (origins.length * destinations.length > 625) {
+                return { error: `Matrix of ${origins.length * destinations.length} exceeds the 625-element cap — chunk into smaller sets` };
+            }
+            const body = {
+                origins: origins.map(toRouteWaypoint),
+                destinations: destinations.map(toRouteWaypoint),
+            };
+            if (travelMode)
+                body.travelMode = travelMode;
+            if (routingPreference)
+                body.routingPreference = routingPreference;
+            if (languageCode)
+                body.languageCode = languageCode;
+            if (units)
+                body.units = units;
+            const result = await mapsRequest(googleMapsToken, ROUTES_API_BASE, '/distanceMatrix/v2:computeRouteMatrix', {
+                method: 'POST',
+                headers: { 'X-Goog-FieldMask': fieldMask ?? 'originIndex,destinationIndex,duration,distanceMeters,status,condition' },
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to compute route matrix', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error computing route matrix', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getRoute = tool({
+    description: 'Computes routes between two addresses/coordinates with waypoints and travel preferences. Duration strings end in "s" (e.g. "4557s") — parse before display.',
+    inputSchema: z.object({
+        googleMapsToken: googleMapsTokenField,
+        originAddress: z.string().describe("Origin address or 'lat,lng'"),
+        destinationAddress: z.string().describe("Destination address or 'lat,lng'"),
+        travelMode: z.enum(['DRIVE', 'BICYCLE', 'WALK', 'TWO_WHEELER', 'TRANSIT']).optional().describe('Default DRIVE'),
+        routingPreference: z.enum(['ROUTING_PREFERENCE_UNSPECIFIED', 'TRAFFIC_UNAWARE', 'TRAFFIC_AWARE', 'TRAFFIC_AWARE_OPTIMAL']).optional(),
+        languageCode: z.string().optional().describe("BCP-47 language (default 'en-US')"),
+        units: z.enum(['METRIC', 'IMPERIAL']).optional().describe('Display units only (default IMPERIAL)'),
+        avoidTolls: z.boolean().optional(),
+        avoidHighways: z.boolean().optional(),
+        avoidFerries: z.boolean().optional(),
+        computeAlternativeRoutes: z.boolean().optional(),
+        fieldMask: z.string().optional().describe("Response fields (default 'routes.distanceMeters,routes.duration')"),
+    }),
+    execute: async ({ googleMapsToken, originAddress, destinationAddress, fieldMask, ...opts }) => {
+        try {
+            const body = {
+                origin: { address: originAddress },
+                destination: { address: destinationAddress },
+            };
+            for (const [k, v] of Object.entries(opts))
+                if (v !== undefined)
+                    body[k] = v;
+            const result = await mapsRequest(googleMapsToken, ROUTES_API_BASE, '/directions/v2:computeRoutes', {
+                method: 'POST',
+                headers: { 'X-Goog-FieldMask': fieldMask ?? 'routes.distanceMeters,routes.duration' },
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to get route', details: result.error };
+            return { responseData: result.data };
+        }
+        catch (error) {
+            return { error: 'Error getting route', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=routes.js.map

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

@@ -0,0 +1,51 @@
+export declare const createTilesSession: import("ai").Tool<{
+    language: string;
+    googleMapsToken: string;
+    region: string;
+    mapType: "roadmap" | "satellite" | "terrain" | "streetview";
+    scale?: "scaleFactor1x" | "scaleFactor2x" | "scaleFactor4x" | undefined;
+    highDpi?: boolean | undefined;
+    overlay?: boolean | undefined;
+    layerTypes?: ("layerRoadmap" | "layerStreetview" | "layerTraffic")[] | undefined;
+    styles?: Record<string, any>[] | undefined;
+    imageFormat?: "png" | "jpeg" | undefined;
+}, any>;
+export declare const get2dTile: import("ai").Tool<{
+    z: number;
+    googleMapsToken: string;
+    x: number;
+    y: number;
+    session: string;
+    key?: string | undefined;
+    orientation?: number | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    tile?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    tile?: undefined;
+    message?: undefined;
+} | {
+    tile: {
+        name: string;
+        mimetype: string;
+        contentBase64: string | undefined;
+        byteSize: number | undefined;
+    };
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    tile?: undefined;
+}>;
+export declare const get3dTilesRoot: import("ai").Tool<{
+    googleMapsToken: string;
+    key?: string | undefined;
+}, any>;
+//# sourceMappingURL=tiles.d.ts.map