@rnsk/toolkits 0.0.9 → 0.0.10

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

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

@@ -0,0 +1,198 @@
+import { neo4jCreateInstanceBeta, neo4jGetInstanceBeta, neo4jListInstancesBeta, neo4jUpdateInstance, neo4jUpdateInstanceBeta, neo4jPauseInstanceBeta } from './instances.js';
+import { neo4jCreateSnapshot, neo4jGetSnapshot, neo4jListSnapshots, neo4jRestoreSnapshot } from './snapshots.js';
+import { neo4jGetProject, neo4jGetProjectBeta, neo4jListProjects, neo4jListProjectUsers, neo4jGetOrganizationUser, neo4jListIpFilters, neo4jUpdateIpFilter, neo4jListAgents } from './projects.js';
+import { neo4jEstimateGdsSessionSize, neo4jListGdsSessions, neo4jAggregateDirectors } from './analytics.js';
+export { neo4jCreateInstanceBeta, neo4jGetInstanceBeta, neo4jListInstancesBeta, neo4jUpdateInstance, neo4jUpdateInstanceBeta, neo4jPauseInstanceBeta, neo4jCreateSnapshot, neo4jGetSnapshot, neo4jListSnapshots, neo4jRestoreSnapshot, neo4jGetProject, neo4jGetProjectBeta, neo4jListProjects, neo4jListProjectUsers, neo4jGetOrganizationUser, neo4jListIpFilters, neo4jUpdateIpFilter, neo4jListAgents, neo4jEstimateGdsSessionSize, neo4jListGdsSessions, neo4jAggregateDirectors, };
+export declare const neo4jTools: ({
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        type: "enterprise-db" | "enterprise-ds" | "business-critical" | "professional-db" | "professional-ds" | "free-db";
+        version: string;
+        name: string;
+        region: string;
+        memory: string;
+        tenantId: string;
+        cloudProvider: "aws" | "gcp" | "azure";
+        neo4jCredentials?: string | undefined;
+        storage?: string | undefined;
+        vectorOptimized?: boolean | undefined;
+        graphAnalyticsPlugin?: boolean | undefined;
+        sourceInstanceId?: string | undefined;
+        sourceSnapshotId?: string | undefined;
+        customerManagedKeyId?: string | undefined;
+    }, any>;
+    requiredAuth: "neo4jCredentials";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        instanceId: string;
+        neo4jCredentials?: string | undefined;
+    }, any>;
+    requiredAuth: "neo4jCredentials";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        neo4jCredentials?: string | undefined;
+        tenantId?: string | undefined;
+    }, any>;
+    requiredAuth: "neo4jCredentials";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        instanceId: string;
+        name?: string | undefined;
+        neo4jCredentials?: string | undefined;
+        memory?: string | undefined;
+        storage?: string | undefined;
+        vectorOptimized?: boolean | undefined;
+        graphAnalyticsPlugin?: boolean | undefined;
+    }, any>;
+    requiredAuth: "neo4jCredentials";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        instanceId: string;
+        neo4jCredentials?: string | undefined;
+    }, any>;
+    requiredAuth: "neo4jCredentials";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        instanceId: string;
+        snapshotId: string;
+        neo4jCredentials?: string | undefined;
+    }, any>;
+    requiredAuth: "neo4jCredentials";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        instanceId: string;
+        date?: string | undefined;
+        neo4jCredentials?: string | undefined;
+    }, any>;
+    requiredAuth: "neo4jCredentials";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        instanceId: string;
+        snapshotId: string;
+        neo4jCredentials?: string | undefined;
+    }, any>;
+    requiredAuth: "neo4jCredentials";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        tenantId: string;
+        neo4jCredentials?: string | undefined;
+    }, any>;
+    requiredAuth: "neo4jCredentials";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        neo4jCredentials?: string | undefined;
+    }, any>;
+    requiredAuth: "neo4jCredentials";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        projectId: string;
+        organizationId: string;
+        neo4jCredentials?: string | undefined;
+    }, any>;
+    requiredAuth: "neo4jCredentials";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        userId: string;
+        organizationId: string;
+        neo4jCredentials?: string | undefined;
+    }, any>;
+    requiredAuth: "neo4jCredentials";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        organizationId: string;
+        neo4jCredentials?: string | undefined;
+    }, any>;
+    requiredAuth: "neo4jCredentials";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        organizationId: string;
+        ipFilterId: string;
+        description?: string | undefined;
+        name?: string | undefined;
+        neo4jCredentials?: string | undefined;
+        allowList?: {
+            address: string;
+            prefixLen: number;
+            description?: string | undefined;
+        }[] | undefined;
+        filteringDisabled?: boolean | undefined;
+    }, any>;
+    requiredAuth: "neo4jCredentials";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        nodeCount: number;
+        relationshipCount: number;
+        neo4jCredentials?: string | undefined;
+        nodeLabelCount?: number | undefined;
+        nodePropertyCount?: number | undefined;
+        relationshipPropertyCount?: number | undefined;
+        algorithmCategories?: string[] | undefined;
+    }, any>;
+    requiredAuth: "neo4jCredentials";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        instanceId?: string | undefined;
+        neo4jCredentials?: string | undefined;
+        tenantId?: string | undefined;
+        organizationId?: string | undefined;
+    }, any>;
+    requiredAuth: "neo4jCredentials";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        instanceId: string;
+        graphQlEndpoint: string;
+        neo4jCredentials?: string | undefined;
+    }, any>;
+    requiredAuth: "neo4jCredentials";
+    scope: "read";
+})[];
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,30 @@
+// @ts-nocheck
+import { neo4jCreateInstanceBeta, neo4jGetInstanceBeta, neo4jListInstancesBeta, neo4jUpdateInstance, neo4jUpdateInstanceBeta, neo4jPauseInstanceBeta, } from './instances.js';
+import { neo4jCreateSnapshot, neo4jGetSnapshot, neo4jListSnapshots, neo4jRestoreSnapshot } from './snapshots.js';
+import { neo4jGetProject, neo4jGetProjectBeta, neo4jListProjects, neo4jListProjectUsers, neo4jGetOrganizationUser, neo4jListIpFilters, neo4jUpdateIpFilter, neo4jListAgents, } from './projects.js';
+import { neo4jEstimateGdsSessionSize, neo4jListGdsSessions, neo4jAggregateDirectors } from './analytics.js';
+export { neo4jCreateInstanceBeta, neo4jGetInstanceBeta, neo4jListInstancesBeta, neo4jUpdateInstance, neo4jUpdateInstanceBeta, neo4jPauseInstanceBeta, neo4jCreateSnapshot, neo4jGetSnapshot, neo4jListSnapshots, neo4jRestoreSnapshot, neo4jGetProject, neo4jGetProjectBeta, neo4jListProjects, neo4jListProjectUsers, neo4jGetOrganizationUser, neo4jListIpFilters, neo4jUpdateIpFilter, neo4jListAgents, neo4jEstimateGdsSessionSize, neo4jListGdsSessions, neo4jAggregateDirectors, };
+export const neo4jTools = [
+    { name: 'Neo4jCreateInstanceBeta', description: neo4jCreateInstanceBeta.description, tool: neo4jCreateInstanceBeta, requiredAuth: 'neo4jCredentials', scope: 'write' },
+    { name: 'Neo4jGetInstanceBeta', description: neo4jGetInstanceBeta.description, tool: neo4jGetInstanceBeta, requiredAuth: 'neo4jCredentials', scope: 'read' },
+    { name: 'Neo4jListInstancesBeta', description: neo4jListInstancesBeta.description, tool: neo4jListInstancesBeta, requiredAuth: 'neo4jCredentials', scope: 'read' },
+    { name: 'Neo4jUpdateInstance', description: neo4jUpdateInstance.description, tool: neo4jUpdateInstance, requiredAuth: 'neo4jCredentials', scope: 'write' },
+    { name: 'Neo4jUpdateInstanceBeta', description: neo4jUpdateInstanceBeta.description, tool: neo4jUpdateInstanceBeta, requiredAuth: 'neo4jCredentials', scope: 'write' },
+    { name: 'Neo4jPauseInstanceBeta', description: neo4jPauseInstanceBeta.description, tool: neo4jPauseInstanceBeta, requiredAuth: 'neo4jCredentials', scope: 'write' },
+    { name: 'Neo4jCreateSnapshot', description: neo4jCreateSnapshot.description, tool: neo4jCreateSnapshot, requiredAuth: 'neo4jCredentials', scope: 'write' },
+    { name: 'Neo4jGetSnapshot', description: neo4jGetSnapshot.description, tool: neo4jGetSnapshot, requiredAuth: 'neo4jCredentials', scope: 'read' },
+    { name: 'Neo4jListSnapshots', description: neo4jListSnapshots.description, tool: neo4jListSnapshots, requiredAuth: 'neo4jCredentials', scope: 'read' },
+    { name: 'Neo4jRestoreSnapshot', description: neo4jRestoreSnapshot.description, tool: neo4jRestoreSnapshot, requiredAuth: 'neo4jCredentials', scope: 'write' },
+    { name: 'Neo4jGetProject', description: neo4jGetProject.description, tool: neo4jGetProject, requiredAuth: 'neo4jCredentials', scope: 'read' },
+    { name: 'Neo4jGetProjectBeta', description: neo4jGetProjectBeta.description, tool: neo4jGetProjectBeta, requiredAuth: 'neo4jCredentials', scope: 'read' },
+    { name: 'Neo4jListProjects', description: neo4jListProjects.description, tool: neo4jListProjects, requiredAuth: 'neo4jCredentials', scope: 'read' },
+    { name: 'Neo4jListProjectUsers', description: neo4jListProjectUsers.description, tool: neo4jListProjectUsers, requiredAuth: 'neo4jCredentials', scope: 'read' },
+    { name: 'Neo4jGetOrganizationUser', description: neo4jGetOrganizationUser.description, tool: neo4jGetOrganizationUser, requiredAuth: 'neo4jCredentials', scope: 'read' },
+    { name: 'Neo4jListIpFilters', description: neo4jListIpFilters.description, tool: neo4jListIpFilters, requiredAuth: 'neo4jCredentials', scope: 'read' },
+    { name: 'Neo4jUpdateIpFilter', description: neo4jUpdateIpFilter.description, tool: neo4jUpdateIpFilter, requiredAuth: 'neo4jCredentials', scope: 'write' },
+    { name: 'Neo4jListAgents', description: neo4jListAgents.description, tool: neo4jListAgents, requiredAuth: 'neo4jCredentials', scope: 'read' },
+    { name: 'Neo4jEstimateGdsSessionSize', description: neo4jEstimateGdsSessionSize.description, tool: neo4jEstimateGdsSessionSize, requiredAuth: 'neo4jCredentials', scope: 'read' },
+    { name: 'Neo4jListGdsSessions', description: neo4jListGdsSessions.description, tool: neo4jListGdsSessions, requiredAuth: 'neo4jCredentials', scope: 'read' },
+    { name: 'Neo4jAggregateDirectors', description: neo4jAggregateDirectors.description, tool: neo4jAggregateDirectors, requiredAuth: 'neo4jCredentials', scope: 'read' },
+];
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,47 @@
+export declare const neo4jCreateInstanceBeta: import("ai").Tool<{
+    type: "enterprise-db" | "enterprise-ds" | "business-critical" | "professional-db" | "professional-ds" | "free-db";
+    version: string;
+    name: string;
+    region: string;
+    memory: string;
+    tenantId: string;
+    cloudProvider: "aws" | "gcp" | "azure";
+    neo4jCredentials?: string | undefined;
+    storage?: string | undefined;
+    vectorOptimized?: boolean | undefined;
+    graphAnalyticsPlugin?: boolean | undefined;
+    sourceInstanceId?: string | undefined;
+    sourceSnapshotId?: string | undefined;
+    customerManagedKeyId?: string | undefined;
+}, any>;
+export declare const neo4jGetInstanceBeta: import("ai").Tool<{
+    instanceId: string;
+    neo4jCredentials?: string | undefined;
+}, any>;
+export declare const neo4jListInstancesBeta: import("ai").Tool<{
+    neo4jCredentials?: string | undefined;
+    tenantId?: string | undefined;
+}, any>;
+export declare const neo4jUpdateInstance: import("ai").Tool<{
+    instanceId: string;
+    name?: string | undefined;
+    neo4jCredentials?: string | undefined;
+    memory?: string | undefined;
+    storage?: string | undefined;
+    vectorOptimized?: boolean | undefined;
+    graphAnalyticsPlugin?: boolean | undefined;
+}, any>;
+export declare const neo4jUpdateInstanceBeta: import("ai").Tool<{
+    instanceId: string;
+    name?: string | undefined;
+    neo4jCredentials?: string | undefined;
+    memory?: string | undefined;
+    storage?: string | undefined;
+    vectorOptimized?: boolean | undefined;
+    graphAnalyticsPlugin?: boolean | undefined;
+}, any>;
+export declare const neo4jPauseInstanceBeta: import("ai").Tool<{
+    instanceId: string;
+    neo4jCredentials?: string | undefined;
+}, any>;
+//# sourceMappingURL=instances.d.ts.map

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

@@ -0,0 +1,127 @@
+// @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');
+const instanceIdField = z.string().describe('Aura instance ID');
+const instanceTypeEnum = z.enum(['enterprise-db', 'enterprise-ds', 'business-critical', 'professional-db', 'professional-ds', 'free-db']);
+const cloudProviderEnum = z.enum(['gcp', 'aws', 'azure']);
+export const neo4jCreateInstanceBeta = tool({
+    description: 'Create a new Neo4j Aura instance (v1beta5). Provisioning is asynchronous (202 Accepted). Save the returned username and password securely; they cannot be retrieved again.',
+    inputSchema: z.object({
+        neo4jCredentials: tokenField,
+        name: z.string().min(1).max(30).describe('Instance name, max 30 chars'),
+        type: instanceTypeEnum.describe('Instance type'),
+        memory: z.string().describe("Memory size, e.g. '1GB'"),
+        region: z.string().describe("Region, e.g. 'europe-west1'"),
+        tenantId: z.string().describe('Project/tenant ID to create the instance in'),
+        version: z.string().describe("Neo4j version, e.g. '5'"),
+        cloudProvider: cloudProviderEnum.describe('Cloud provider'),
+        storage: z.string().optional().describe("Storage size, e.g. '10GB'"),
+        vectorOptimized: z.boolean().optional().describe('Enable vector optimization'),
+        graphAnalyticsPlugin: z.boolean().optional().describe('Enable graph analytics plugin'),
+        sourceInstanceId: z.string().optional().describe('Source instance ID when cloning'),
+        sourceSnapshotId: z.string().optional().describe('Snapshot ID to create from (requires sourceInstanceId)'),
+        customerManagedKeyId: z.string().optional().describe('Customer managed key ID'),
+    }),
+    execute: async ({ neo4jCredentials, name, type, memory, region, tenantId, version, cloudProvider, storage, vectorOptimized, graphAnalyticsPlugin, sourceInstanceId, sourceSnapshotId, customerManagedKeyId }) => {
+        return auraRequest(neo4jCredentials, '/v1beta5/instances', {
+            method: 'POST',
+            body: {
+                name,
+                type,
+                memory,
+                region,
+                tenant_id: tenantId,
+                version,
+                cloud_provider: cloudProvider,
+                storage,
+                vector_optimized: vectorOptimized,
+                graph_analytics_plugin: graphAnalyticsPlugin,
+                source_instance_id: sourceInstanceId,
+                source_snapshot_id: sourceSnapshotId,
+                customer_managed_key_id: customerManagedKeyId,
+            },
+        });
+    },
+});
+export const neo4jGetInstanceBeta = tool({
+    description: 'Get details of a Neo4j Aura instance by ID (v1beta5): status, configuration, connection URL. Read-only.',
+    inputSchema: z.object({
+        neo4jCredentials: tokenField,
+        instanceId: instanceIdField,
+    }),
+    execute: async ({ neo4jCredentials, instanceId }) => {
+        return auraRequest(neo4jCredentials, `/v1beta5/instances/${encodeURIComponent(instanceId)}`);
+    },
+});
+export const neo4jListInstancesBeta = tool({
+    description: 'List Neo4j Aura instances, optionally filtered by tenant. Use to discover available instances.',
+    inputSchema: z.object({
+        neo4jCredentials: tokenField,
+        tenantId: z.string().optional().describe('Filter instances by tenant/project ID'),
+    }),
+    execute: async ({ neo4jCredentials, tenantId }) => {
+        return auraRequest(neo4jCredentials, '/v1beta5/instances', { query: { tenantId } });
+    },
+});
+const updateShape = {
+    name: z.string().min(1).max(30).optional().describe('New instance name'),
+    memory: z.string().optional().describe("New memory size, e.g. '8GB'"),
+    storage: z.string().optional().describe("New storage size, e.g. '50GB'"),
+    vectorOptimized: z.boolean().optional().describe('Toggle vector optimization'),
+    graphAnalyticsPlugin: z.boolean().optional().describe('Toggle graph analytics plugin'),
+};
+export const neo4jUpdateInstance = tool({
+    description: 'Update a Neo4j Aura instance (v1): rename, resize memory/storage, toggle vector optimization or analytics plugin. Resizes may process asynchronously.',
+    inputSchema: z.object({
+        neo4jCredentials: tokenField,
+        instanceId: instanceIdField,
+        ...updateShape,
+    }),
+    execute: async ({ neo4jCredentials, instanceId, name, memory, storage, vectorOptimized, graphAnalyticsPlugin }) => {
+        return auraRequest(neo4jCredentials, `/v1/instances/${encodeURIComponent(instanceId)}`, {
+            method: 'PATCH',
+            body: {
+                name,
+                memory,
+                storage,
+                vector_optimized: vectorOptimized,
+                graph_analytics_plugin: graphAnalyticsPlugin,
+            },
+        });
+    },
+});
+export const neo4jUpdateInstanceBeta = tool({
+    description: 'Update a Neo4j Aura instance (v1beta5): rename, resize memory/storage, toggle plugins. May return 202 Accepted for async processing.',
+    inputSchema: z.object({
+        neo4jCredentials: tokenField,
+        instanceId: instanceIdField,
+        ...updateShape,
+    }),
+    execute: async ({ neo4jCredentials, instanceId, name, memory, storage, vectorOptimized, graphAnalyticsPlugin }) => {
+        return auraRequest(neo4jCredentials, `/v1beta5/instances/${encodeURIComponent(instanceId)}`, {
+            method: 'PATCH',
+            body: {
+                name,
+                memory,
+                storage,
+                vector_optimized: vectorOptimized,
+                graph_analytics_plugin: graphAnalyticsPlugin,
+            },
+        });
+    },
+});
+export const neo4jPauseInstanceBeta = tool({
+    description: 'Pause a Neo4j Aura instance to save costs or for maintenance. Asynchronous; resume it later. Fails if another operation (e.g. cloning) is in progress.',
+    inputSchema: z.object({
+        neo4jCredentials: tokenField,
+        instanceId: instanceIdField,
+    }),
+    execute: async ({ neo4jCredentials, instanceId }) => {
+        return auraRequest(neo4jCredentials, `/v1beta5/instances/${encodeURIComponent(instanceId)}/pause`, {
+            method: 'POST',
+        });
+    },
+});
+//# sourceMappingURL=instances.js.map

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

@@ -0,0 +1,44 @@
+export declare const neo4jGetProject: import("ai").Tool<{
+    tenantId: string;
+    neo4jCredentials?: string | undefined;
+}, any>;
+export declare const neo4jGetProjectBeta: import("ai").Tool<{
+    tenantId: string;
+    neo4jCredentials?: string | undefined;
+}, any>;
+export declare const neo4jListProjects: import("ai").Tool<{
+    neo4jCredentials?: string | undefined;
+}, any>;
+export declare const neo4jListProjectUsers: import("ai").Tool<{
+    projectId: string;
+    organizationId: string;
+    neo4jCredentials?: string | undefined;
+}, any>;
+export declare const neo4jGetOrganizationUser: import("ai").Tool<{
+    userId: string;
+    organizationId: string;
+    neo4jCredentials?: string | undefined;
+}, any>;
+export declare const neo4jListIpFilters: import("ai").Tool<{
+    organizationId: string;
+    neo4jCredentials?: string | undefined;
+}, any>;
+export declare const neo4jUpdateIpFilter: import("ai").Tool<{
+    organizationId: string;
+    ipFilterId: string;
+    description?: string | undefined;
+    name?: string | undefined;
+    neo4jCredentials?: string | undefined;
+    allowList?: {
+        address: string;
+        prefixLen: number;
+        description?: string | undefined;
+    }[] | undefined;
+    filteringDisabled?: boolean | undefined;
+}, any>;
+export declare const neo4jListAgents: import("ai").Tool<{
+    projectId: string;
+    organizationId: string;
+    neo4jCredentials?: string | undefined;
+}, any>;
+//# sourceMappingURL=projects.d.ts.map