@rnsk/toolkits 0.0.9 → 0.0.11

package/dist/toolkits/nasa/tools/tolnet.js

@@ -0,0 +1,254 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { nasaGet, nasaDownloadMeta, toNasaError, enc } from './client.js';
+export const nasaGetDataByFileName = tool({
+    description: "Get information about specific TOLNet (Tropospheric Ozone Lidar Network) data files by file name. This tool searches the TOLNet database for lidar data files and returns detailed metadata including temporal coverage, geographic location, instrument details, and access permissions. Supports exact match, prefix match (begins_with), or suffix match (ends_with) search strategies. Use this when you need to retrieve metadata about TOLNet lidar observation files, verify file existence, check data collection periods, or obtain download locations.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        fileName: z.string().describe("The name of the file you want to search for. Can be a full file name or partial name depending on the match_type parameter."),
+        matchType: z.enum(["exact_match", "begins_with", "ends_with"]).optional().describe("Match type for file name search."),
+    }),
+    execute: async ({ nasaApiKey, fileName, matchType }) => {
+        try {
+            const query = {};
+            if (fileName !== undefined)
+                query["file_name"] = fileName;
+            if (matchType !== undefined)
+                query["match_type"] = matchType;
+            return await nasaGet("https://tolnet.larc.nasa.gov/api", `/data/search_by_file_name`, { query });
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get data by file name");
+        }
+    },
+});
+export const nasaGetTolnetDataJson = tool({
+    description: "Tool to retrieve JSON versions of TOLNet (Tropospheric Ozone Lidar Network) data by ID. Use when you need to access hi-res TOLNet measurement data in JSON format.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        id: z.number().int().min(1).describe("Data ID associated with one hi-res TOLNet file. Must be a valid integer identifier for existing TOLNet data."),
+    }),
+    execute: async ({ nasaApiKey, id }) => {
+        try {
+            return await nasaGet("https://tolnet.larc.nasa.gov/api", `/data/json/${enc(id)}`);
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get tolnet data json");
+        }
+    },
+});
+export const nasaGetTolnetDataJsonForGraph = tool({
+    description: "Tool to retrieve JSON versions of TOLNet data including O3_Number_Density (ozone mixing ratio) and temporal boundaries. Use when you need TOLNet lidar ozone measurements with altitude profiles, start/stop dates, and instrument metadata for a specific data ID.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        id: z.number().int().min(1).describe("One data id associated with one hi-res TOLNet file"),
+    }),
+    execute: async ({ nasaApiKey, id }) => {
+        try {
+            return await nasaGet("https://tolnet.larc.nasa.gov/api", `/data/json_for_graph/${enc(id)}`);
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get tolnet data json for graph");
+        }
+    },
+});
+export const nasaGetDocument = tool({
+    description: "Tool to retrieve metadata for a single TOLNet (Tropospheric Ozone Lidar Network) document by ID. Use when you need information about a document such as its name, author, type, dates, and access visibility.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        id: z.number().int().min(1).describe("Document ID to retrieve. Must be a positive integer."),
+    }),
+    execute: async ({ nasaApiKey, id }) => {
+        try {
+            return await nasaGet("https://tolnet.larc.nasa.gov/api", `/document/${enc(id)}`);
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get document");
+        }
+    },
+});
+export const nasaGetDocumentDownload = tool({
+    description: "Download a single TOLNet (Tropospheric Ozone Lidar Network) document by ID. Returns the document as a PDF file. Use when you need to retrieve a specific TOLNet document for analysis or storage.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        id: z.number().int().min(1).describe("Document ID to download. Must be a positive integer."),
+    }),
+    execute: async ({ nasaApiKey, id }) => {
+        try {
+            const headers = {};
+            return await nasaDownloadMeta("https://tolnet.larc.nasa.gov/api", `/document/download/${enc(id)}`, headers);
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get document download");
+        }
+    },
+});
+export const nasaGetDocuments = tool({
+    description: "Tool to retrieve document information from NASA's TOLNet (Tropospheric Ozone Lidar Network) archive. Use when you need to search or browse TOLNet documents with filtering by type, keywords, or sorting options. Supports pagination for large result sets.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        q: z.string().optional().describe("Search phrase or keywords to filter documents. Searches across document fields like name, author, etc."),
+        page: z.number().int().min(1).optional().describe("Starting page number (n >= 1). Use this to paginate through document results."),
+        type: z.string().optional().describe("One or more comma-separated document type IDs to filter by. Example: '1,3' returns only documents of types 1 and 3."),
+        order: z.enum(["display_date", "document_name", "author", "document_type_name", "public"]).optional().describe("Order options for document results."),
+        orderDirection: z.enum(["asc", "desc"]).optional().describe("Sort direction options."),
+    }),
+    execute: async ({ nasaApiKey, q, page, type, order, orderDirection }) => {
+        try {
+            const query = {};
+            if (q !== undefined)
+                query["q"] = q;
+            if (type !== undefined)
+                query["type"] = type;
+            if (order !== undefined)
+                query["order"] = order;
+            if (orderDirection !== undefined)
+                query["order_direction"] = orderDirection;
+            return await nasaGet("https://tolnet.larc.nasa.gov/api", `/documents/${page ?? 1}`, { query });
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get documents");
+        }
+    },
+});
+export const nasaGetTolnetData = tool({
+    description: "Tool to retrieve information about TOLNet (Tropospheric Ozone Lidar Network) data files. Use when you need to search or browse available TOLNet atmospheric data with filtering by instrument, product type, date ranges, or geographic location. Returns metadata including file details, temporal coverage, spatial location, and access information. Data is paginated with 40 items per page.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        page: z.number().int().min(1).optional().describe("Page number for paginated results. This API returns data file info 40 items at a time. Each group of 40 is one page of data. Must be 1 or greater."),
+        order: z.enum(["data_date", "upload_date", "instrument_group_name", "product_type_name", "processing_type_name", "file_type_name", "file_name"]).optional().describe("Valid order fields for TOLNet data."),
+        radius: z.number().min(0).max(1000).optional().describe("How many kilometers away from the provided latitude and longitude should the API search? Only used if latitude and/or longitude is provided. Default is 100 km. Must be a real number between 0 and 1000 inclusive."),
+        latitude: z.number().min(-90).max(90).optional().describe("Search for data with the given latitude, within the provided radius parameter. Must be a real number between -90 and 90 inclusive. If you provide a latitude, you also need to provide a longitude."),
+        maxDate: z.string().optional().describe("Exclude all data after this date. Must be in YYYY-MM-DD format (e.g., '2024-05-01')."),
+        minDate: z.string().optional().describe("Exclude all data before this date. Must be in YYYY-MM-DD format (e.g., '2021-05-01')."),
+        fileType: z.string().optional().describe("One or more comma-separated file_type IDs to filter by (e.g., '1')."),
+        longitude: z.number().min(-180).max(180).optional().describe("Search for data with the given longitude, within the provided radius parameter. Must be a real number between -180 and 180 inclusive. If you provide a longitude, you also need to provide a latitude."),
+        maxLatitude: z.number().min(-90).max(90).optional().describe("One of the 4 parameters needed to perform a lat/long bounding box search. All 4 are needed: minLatitude, minLongitude, maxLatitude, and maxLongitude. Must be a real number between -90 and 90 inclusive."),
+        minLatitude: z.number().min(-90).max(90).optional().describe("One of the 4 parameters needed to perform a lat/long bounding box search. All 4 are needed: minLatitude, minLongitude, maxLatitude, and maxLongitude. Must be a real number between -90 and 90 inclusive."),
+        maxLongitude: z.number().min(-180).max(180).optional().describe("One of the 4 parameters needed to perform a lat/long bounding box search. All 4 are needed: minLatitude, minLongitude, maxLatitude, and maxLongitude. Must be a real number between -180 and 180 inclusive."),
+        minLongitude: z.number().min(-180).max(180).optional().describe("One of the 4 parameters needed to perform a lat/long bounding box search. All 4 are needed: minLatitude, minLongitude, maxLatitude, and maxLongitude. Must be a real number between -180 and 180 inclusive."),
+        productType: z.string().optional().describe("One or more comma-separated product_type IDs to filter by (e.g., '5')."),
+        nearRealTime: z.string().optional().describe("Filter by files that are near real time or not. Use 'true' to return only near real time files, 'false' to return only non-near real time files. If omitted, returns both."),
+        maxUploadDate: z.string().optional().describe("Exclude all data uploaded after this date. Must be in YYYY-MM-DD format (e.g., '2024-05-01')."),
+        minUploadDate: z.string().optional().describe("Exclude all data uploaded before this date. Must be in YYYY-MM-DD format (e.g., '2024-05-01')."),
+        orderDirection: z.enum(["asc", "desc"]).optional().describe("Order direction for sorting results."),
+        processingType: z.string().optional().describe("One or more comma-separated processing_type IDs to filter by (e.g., '2')."),
+        instrumentGroup: z.string().optional().describe("One or more comma-separated instrument_group IDs to filter by (e.g., '1,2,3,4')."),
+    }),
+    execute: async ({ nasaApiKey, page, order, radius, latitude, maxDate, minDate, fileType, longitude, maxLatitude, minLatitude, maxLongitude, minLongitude, productType, nearRealTime, maxUploadDate, minUploadDate, orderDirection, processingType, instrumentGroup }) => {
+        try {
+            const query = {};
+            if (instrumentGroup !== undefined)
+                query["instrument_group"] = instrumentGroup;
+            if (productType !== undefined)
+                query["product_type"] = productType;
+            if (processingType !== undefined)
+                query["processing_type"] = processingType;
+            if (fileType !== undefined)
+                query["file_type"] = fileType;
+            if (nearRealTime !== undefined)
+                query["near_real_time"] = nearRealTime;
+            if (minDate !== undefined)
+                query["min_date"] = minDate;
+            if (maxDate !== undefined)
+                query["max_date"] = maxDate;
+            if (minUploadDate !== undefined)
+                query["min_upload_date"] = minUploadDate;
+            if (maxUploadDate !== undefined)
+                query["max_upload_date"] = maxUploadDate;
+            if (latitude !== undefined)
+                query["latitude"] = latitude;
+            if (longitude !== undefined)
+                query["longitude"] = longitude;
+            if (radius !== undefined)
+                query["radius"] = radius;
+            if (minLatitude !== undefined)
+                query["minLatitude"] = minLatitude;
+            if (minLongitude !== undefined)
+                query["minLongitude"] = minLongitude;
+            if (maxLatitude !== undefined)
+                query["maxLatitude"] = maxLatitude;
+            if (maxLongitude !== undefined)
+                query["maxLongitude"] = maxLongitude;
+            if (order !== undefined)
+                query["order"] = order;
+            if (orderDirection !== undefined)
+                query["order_direction"] = orderDirection;
+            return await nasaGet("https://tolnet.larc.nasa.gov/api", `/data/${page ?? 1}`, { query });
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get tolnet data");
+        }
+    },
+});
+export const nasaGetTolnetDataCalendar = tool({
+    description: "Tool to retrieve a date-driven list of all available TOLNet (Tropospheric Ozone Lidar Network) data. Use when you need to query available TOLNet data files filtered by instrument group and file type, with optional filters for product type and processing type. Returns metadata including file names, locations, dates, geographical coordinates, and accessibility status.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        fileType: z.string().describe("One file_type id to filter TOLNet data. This identifies the specific file type to retrieve."),
+        productType: z.string().optional().describe("One product_type id to filter TOLNet data (optional). Use this to narrow results to a specific product type."),
+        processingType: z.string().optional().describe("One processing_type id to filter TOLNet data (optional). Use this to narrow results to a specific processing type."),
+        instrumentGroup: z.string().describe("One instrument_group id to filter TOLNet data. This identifies the specific instrument group for which to retrieve available data."),
+    }),
+    execute: async ({ nasaApiKey, instrumentGroup, fileType, productType, processingType }) => {
+        try {
+            const query = {};
+            if (instrumentGroup !== undefined)
+                query["instrument_group"] = instrumentGroup;
+            if (fileType !== undefined)
+                query["file_type"] = fileType;
+            if (productType !== undefined)
+                query["product_type"] = productType;
+            if (processingType !== undefined)
+                query["processing_type"] = processingType;
+            return await nasaGet("https://tolnet.larc.nasa.gov/api", `/data/calendar`, { query });
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get tolnet data calendar");
+        }
+    },
+});
+export const nasaGetFileTypes = tool({
+    description: "Tool to retrieve information on all data file types from NASA's TOLNET API. Use when you need to discover available file type identifiers, names, and descriptions.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+    }),
+    execute: async ({ nasaApiKey }) => {
+        try {
+            return await nasaGet("https://tolnet.larc.nasa.gov/api", `/data/file_types`);
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get file types");
+        }
+    },
+});
+export const nasaGetInstrumentGroups = tool({
+    description: "Tool to retrieve information on all instrument groups from NASA's TOLNET API. Use when you need to get instrument group details including IDs, names, descriptions, and Principal Investigators.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+    }),
+    execute: async ({ nasaApiKey }) => {
+        try {
+            return await nasaGet("https://tolnet.larc.nasa.gov/api", `/instruments/groups`);
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get instrument groups");
+        }
+    },
+});
+export const nasaGetProductTypes = tool({
+    description: "Tool to retrieve all data product types from NASA's TOLNET (TOLNet Ozone Lidar Network) API. Use when you need to discover available product types or get product type metadata including names, descriptions, and display ordering.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+    }),
+    execute: async ({ nasaApiKey }) => {
+        try {
+            return await nasaGet("https://tolnet.larc.nasa.gov/api", `/data/product_types`);
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get product types");
+        }
+    },
+});
+//# sourceMappingURL=tolnet.js.map

package/dist/toolkits/neo4j/icon.d.ts

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

package/dist/toolkits/neo4j/icon.js

@@ -0,0 +1,6 @@
+const SVG = `<svg viewBox="0 0 128 128" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M63.333 32.567c-5.2.866-9.566 3-12.833 6.266-3.867 3.867-5.833 8.5-6.5 15.367-.3 3.133-.467 15.467-.2 15.467.067 0 .7-.234 1.4-.534 1.633-.7 5.167-.7 7-.033l1.4.5.167-8.033c.166-8.567.366-9.867 1.966-13.067 1.1-2.133 3.767-4.633 6.034-5.667 2.6-1.2 6.4-1.666 9.333-1.2 6.267 1.034 10 4.434 11.567 10.5.633 2.434.666 3.7.666 17.1v14.434H93.4L93.233 67.9c-.1-14.9-.166-15.9-.866-18.567-1.9-7.4-6.5-12.766-12.934-15.2-3.433-1.3-6.7-1.8-11.2-1.766-2.233.033-4.433.133-4.9.2z" fill="#000"/><path d="M22.733 57.2c-2.866 1.433-4.4 4-4.4 7.467 0 1.1.2 2.5.467 3.133.633 1.567 2.433 3.467 4 4.3 1.9 1 5.5 1 7.367.033l1.366-.7 4.267 2.9 4.267 2.934V81.7L35.8 84.633l-4.3 2.934-1.1-.667c-1.6-.933-4.7-1.133-6.6-.4-2 .767-4.067 2.6-4.833 4.333-.834 1.767-.834 5.234 0 7 .7 1.567 2.333 3.3 3.8 4.067.6.3 2.033.6 3.233.7 2.8.2 5.167-.733 6.867-2.733 1.366-1.6 2.266-4.4 2.033-6.334l-.167-1.366 4.3-2.9 4.3-2.9 1.534.7c2.333 1 5.8.766 8-.567 2.4-1.5 3.6-3.633 3.733-6.633.1-2.1 0-2.567-.833-4.2-2.167-4.134-7-5.7-11.134-3.634l-1.233.6-4.233-2.9-4.234-2.9-.1-2.333c-.066-2.8-.866-4.6-2.833-6.233-2.5-2.134-6.233-2.567-9.267-1.067z" fill="#018BFF"/></svg>`;
+export const NEO4J_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

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

@@ -0,0 +1,33 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { NEO4J_ICON } from './icon.js';
+import { neo4jTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'neo4j',
+    displayName: 'Neo4j',
+    shortDescription: 'Aura instances, snapshots, projects, users, IP filters, agents, and GDS sessions.',
+    category: 'Data & Analytics',
+    icon: NEO4J_ICON,
+    auth: {
+        type: 'basic_auth',
+        tokenField: 'neo4jCredentials',
+        provider: {
+            connectDescription: 'Connect Neo4j with Aura API client credentials. Create them in the Aura Console under Account Settings > Client credentials (Aura API). Paste as "clientId:clientSecret". Tools exchange them for a short-lived bearer token automatically.',
+        },
+    },
+    allowedHosts: ['api.neo4j.io'],
+    tools: neo4jTools.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.9',
+        homepage: 'https://neo4j.com',
+        docsUrl: 'https://neo4j.com/docs/aura/api/authentication/',
+        apiDocsUrl: 'https://neo4j.com/docs/aura/platform/api/specification/',
+    },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/neo4j/tools/analytics.d.ts

@@ -0,0 +1,21 @@
+export declare const neo4jEstimateGdsSessionSize: import("ai").Tool<{
+    nodeCount: number;
+    relationshipCount: number;
+    neo4jCredentials?: string | undefined;
+    nodeLabelCount?: number | undefined;
+    nodePropertyCount?: number | undefined;
+    relationshipPropertyCount?: number | undefined;
+    algorithmCategories?: string[] | undefined;
+}, any>;
+export declare const neo4jListGdsSessions: import("ai").Tool<{
+    instanceId?: string | undefined;
+    tenantId?: string | undefined;
+    neo4jCredentials?: string | undefined;
+    organizationId?: string | undefined;
+}, any>;
+export declare const neo4jAggregateDirectors: import("ai").Tool<{
+    instanceId: string;
+    graphQlEndpoint: string;
+    neo4jCredentials?: string | undefined;
+}, any>;
+//# sourceMappingURL=analytics.d.ts.map

package/dist/toolkits/neo4j/tools/analytics.js

@@ -0,0 +1,91 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { auraRequest } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const neo4jEstimateGdsSessionSize = tool({
+    description: 'Estimate GDS session memory and size tier from node/relationship counts and algorithm categories. Use before creating a graph analytics session.',
+    inputSchema: z.object({
+        neo4jCredentials: tokenField,
+        nodeCount: z.number().int().min(0).describe('Number of nodes'),
+        relationshipCount: z.number().int().min(0).describe('Number of relationships'),
+        nodeLabelCount: z.number().int().min(0).optional().describe('Labels per node'),
+        nodePropertyCount: z.number().int().min(0).optional().describe('Properties per node'),
+        relationshipPropertyCount: z.number().int().min(0).optional().describe('Properties per relationship'),
+        algorithmCategories: z
+            .array(z.string())
+            .optional()
+            .describe("Algorithm categories, e.g. ['pathfinding', 'community_detection', 'centrality', 'similarity', 'link_prediction']"),
+    }),
+    execute: async ({ neo4jCredentials, nodeCount, relationshipCount, nodeLabelCount, nodePropertyCount, relationshipPropertyCount, algorithmCategories }) => {
+        return auraRequest(neo4jCredentials, '/v1/graph-analytics/sessions/sizing', {
+            method: 'POST',
+            body: {
+                node_count: nodeCount,
+                relationship_count: relationshipCount,
+                node_label_count: nodeLabelCount,
+                node_property_count: nodePropertyCount,
+                relationship_property_count: relationshipPropertyCount,
+                algorithm_categories: algorithmCategories,
+            },
+        });
+    },
+});
+export const neo4jListGdsSessions = tool({
+    description: 'List GDS sessions with status, memory, host, and expiry. Optionally filter by instance, tenant, or organization. Read-only.',
+    inputSchema: z.object({
+        neo4jCredentials: tokenField,
+        instanceId: z.string().optional().describe('Filter by instance ID'),
+        tenantId: z.string().optional().describe('Filter by project/tenant ID'),
+        organizationId: z.string().optional().describe('Filter by organization ID'),
+    }),
+    execute: async ({ neo4jCredentials, instanceId, tenantId, organizationId }) => {
+        return auraRequest(neo4jCredentials, '/v1/graph-analytics/sessions', {
+            query: { instance_id: instanceId, tenant_id: tenantId, organization_id: organizationId },
+        });
+    },
+});
+export const neo4jAggregateDirectors = tool({
+    description: 'Count directors via a directorsAggregate GraphQL query. Only use when a GraphQL movies API with a Director type is available; pass the instance ID the data belongs to.',
+    inputSchema: z.object({
+        neo4jCredentials: tokenField,
+        instanceId: z.string().describe('Aura instance ID the request relates to'),
+        graphQlEndpoint: z
+            .string()
+            .describe('GraphQL HTTP endpoint exposing a directorsAggregate query, e.g. "https://example.com/graphql"'),
+    }),
+    execute: async ({ neo4jCredentials, instanceId, graphQlEndpoint }) => {
+        if (!neo4jCredentials) {
+            return { error: 'Neo4j Aura API credentials are required. Connect Neo4j first.' };
+        }
+        let endpoint;
+        try {
+            endpoint = new URL(graphQlEndpoint);
+        }
+        catch {
+            return { error: 'Invalid graphQlEndpoint. Provide a full HTTP(S) URL.' };
+        }
+        if (endpoint.protocol !== 'https:' && endpoint.protocol !== 'http:') {
+            return { error: 'Invalid graphQlEndpoint. Provide a full HTTP(S) URL.' };
+        }
+        try {
+            const response = await fetch(endpoint.toString(), {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+                body: JSON.stringify({ query: '{ directorsAggregate { count } }', variables: { instanceId } }),
+            });
+            if (!response.ok) {
+                const details = await response.json().catch(() => ({}));
+                return { error: `GraphQL request failed with status ${response.status}`, details };
+            }
+            return await response.json();
+        }
+        catch (error) {
+            return {
+                error: 'Error executing directorsAggregate query',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=analytics.js.map

package/dist/toolkits/neo4j/tools/client.d.ts

@@ -0,0 +1,6 @@
+export declare function auraRequest(neo4jCredentials: string | undefined, path: string, options?: {
+    method?: string;
+    query?: Record<string, string | number | boolean | undefined>;
+    body?: unknown;
+}): Promise<any>;
+//# sourceMappingURL=client.d.ts.map

package/dist/toolkits/neo4j/tools/client.js

@@ -0,0 +1,105 @@
+// @ts-nocheck
+const AURA_API = 'https://api.neo4j.io';
+const TOKEN_URL = `${AURA_API}/oauth/token`;
+const tokenCache = new Map();
+function credentialsOf(neo4jCredentials) {
+    const idx = (neo4jCredentials ?? '').indexOf(':');
+    if (idx <= 0)
+        return null;
+    return {
+        clientId: neo4jCredentials.slice(0, idx),
+        clientSecret: neo4jCredentials.slice(idx + 1),
+    };
+}
+async function getAccessToken(neo4jCredentials) {
+    const cached = tokenCache.get(neo4jCredentials);
+    if (cached && cached.expiresAt > Date.now() + 60_000)
+        return cached.token;
+    const creds = credentialsOf(neo4jCredentials);
+    if (!creds)
+        return null;
+    const basic = Buffer.from(`${creds.clientId}:${creds.clientSecret}`).toString('base64');
+    const response = await fetch(TOKEN_URL, {
+        method: 'POST',
+        headers: {
+            Authorization: `Basic ${basic}`,
+            'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        body: 'grant_type=client_credentials',
+    });
+    if (!response.ok)
+        return null;
+    const data = await response.json().catch(() => null);
+    if (!data?.access_token)
+        return null;
+    tokenCache.set(neo4jCredentials, {
+        token: data.access_token,
+        expiresAt: Date.now() + (data.expires_in ?? 3600) * 1000,
+    });
+    return data.access_token;
+}
+export async function auraRequest(neo4jCredentials, path, options = {}) {
+    if (!neo4jCredentials) {
+        return { error: 'Neo4j Aura API credentials are required. Connect Neo4j first.' };
+    }
+    if (!credentialsOf(neo4jCredentials)) {
+        return { error: 'Invalid Neo4j credentials. Expected "clientId:clientSecret". Reconnect Neo4j.' };
+    }
+    const params = new URLSearchParams();
+    if (options.query) {
+        for (const [key, value] of Object.entries(options.query)) {
+            if (value !== undefined && value !== null && value !== '') {
+                params.append(key, String(value));
+            }
+        }
+    }
+    const qs = params.toString();
+    const url = `${AURA_API}${path}${qs ? `?${qs}` : ''}`;
+    try {
+        const doFetch = async (token) => fetch(url, {
+            method: options.method ?? 'GET',
+            headers: {
+                Authorization: `Bearer ${token}`,
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+            },
+            body: options.body !== undefined ? JSON.stringify(options.body) : undefined,
+        });
+        let token = await getAccessToken(neo4jCredentials);
+        if (!token) {
+            return { error: 'Failed to authenticate with Neo4j Aura API. Check your client ID and secret.' };
+        }
+        let response = await doFetch(token);
+        if (response.status === 401 || response.status === 403) {
+            tokenCache.delete(neo4jCredentials);
+            token = await getAccessToken(neo4jCredentials);
+            if (!token) {
+                return { error: 'Failed to authenticate with Neo4j Aura API. Check your client ID and secret.' };
+            }
+            response = await doFetch(token);
+        }
+        if (!response.ok) {
+            const details = await response.json().catch(() => ({}));
+            return { error: `Neo4j Aura API request failed with status ${response.status}`, details };
+        }
+        if (response.status === 204 || response.status === 202) {
+            const text = await response.text();
+            if (!text)
+                return { success: true, status: response.status };
+            try {
+                return JSON.parse(text);
+            }
+            catch {
+                return { success: true, status: response.status };
+            }
+        }
+        return await response.json();
+    }
+    catch (error) {
+        return {
+            error: 'Error calling Neo4j Aura API',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+//# sourceMappingURL=client.js.map