@neon/tools 0.7.0 → 1.0.0

package/README.md

@@ -24,7 +24,9 @@ const tools = createNeonTools({
 	tools: [
 		"projects.list",
 		"projects.createAndConnect",
-		"branches.createWithCompute",
+		"branches.createAndConnect",
+		"branches.resetFromParent",
+		"branches.compareSchema",
 	],
 });
 
@@ -33,6 +35,16 @@ const created = await tools["projects.createAndConnect"].execute({
 	name: "agent-project",
 	region_id: "aws-us-east-1",
 });
+await tools["branches.resetFromParent"].execute({
+	project_id: "project-id",
+	branch_id: "br-feature",
+	preserve_under_name: "feature-before-reset",
+});
+const compared = await tools["branches.compareSchema"].execute({
+	project_id: "project-id",
+	branch_id: "br-feature",
+	database_name: "neondb",
+});
 ```
 
 `limit` on a list tool caps how many items come back.
@@ -58,7 +70,7 @@ Each tool includes its Zod 4 `inputSchema`, published `id`, title, description,
 Paginated lists call `.all()` and return the item array. Do not pass a cursor; those fields are omitted from the input schema.
 
 ```ts
-const createBranch = createNeonTool("branches.createWithCompute", { apiKey });
+const createBranch = createNeonTool("branches.createAndConnect", { apiKey });
 ```
 
 ## Writes and waiting
@@ -71,7 +83,7 @@ An abort `signal` on `execute` or a wait timeout stops the poll, not the create:
 
 `metadata.method` and `metadata.path` name the first request; extra readiness GETs are not listed there.
 
-These public client methods are not tools: `projects.create`, `branches.create`, `operations.waitFor`, `postgres.roles.password`, and `storage.objects.get`. Use `projects.createAndConnect` and `branches.createWithCompute` for creates that attach compute and return a connection string. Waiting is what the write tools already do.
+These public client methods are not tools: `operations.waitFor`, `postgres.roles.password`, and `storage.objects.get`. Waiting is what the write tools already do. `projects.create` and `branches.create` return the created resource without a connection string; `createAndConnect` returns a URI.
 
 ## Optional host add-ons
 
@@ -115,17 +127,17 @@ This package does not send analytics. Mutating `event.input` does not change a g
 ```ts
 const tools = createNeonTools({
 	apiKey,
-	tools: ["branches.createWithCompute", "projects.list"] as const,
-	names: { "branches.createWithCompute": "create_branch" },
+	tools: ["branches.createAndConnect", "projects.list"] as const,
+	names: { "branches.createAndConnect": "create_branch" },
 	name: (id) => `neon_${id}`,
 });
 ```
 
-Those tools publish as `neon_create_branch` and `neon_list_projects`. The record is still keyed by SDK path (`tools["branches.createWithCompute"]`). MCP and Mastra publish `tool.id`. Eve uses the filename as the model-facing name, so name the file after the published `id`. Duplicate or non-snake-case ids throw, and a `names` key that matches no selected tool throws.
+Those tools publish as `neon_create_branch` and `neon_list_projects`. The record is still keyed by SDK path (`tools["branches.createAndConnect"]`). MCP and Mastra publish `tool.id`. Eve uses the filename as the model-facing name, so name the file after the published `id`. Duplicate or non-snake-case ids throw, and a `names` key that matches no selected tool throws.
 
 ### Project and branch injection
 
-Tools take path parameters as `project_id` and `branch_id`. A host that already knows those values can inject them, including on `branches.createWithCompute`. Without `omitFromSchema`, the published field becomes optional and a caller-supplied value wins. With `omitFromSchema: true`, the field is removed from the published schema and the injector is the only source:
+Tools take path parameters as `project_id` and `branch_id`. A host that already knows those values can inject them, including on `branches.createAndConnect`. Without `omitFromSchema`, the published field becomes optional and a caller-supplied value wins. With `omitFromSchema: true`, the field is removed from the published schema and the injector is the only source:
 
 ```ts
 const tools = createNeonTools({

package/dist/lib/ergonomic/catalog.d.ts

@@ -173,6 +173,137 @@ export declare const toolFactories: {
         hipaa_enabled_at?: string | null | undefined;
         effective_project_permission?: (import("@neon/sdk").ProjectPermissionLevel | null) | undefined;
     }>;
+    "projects.create": (options: ToolClientOptions) => import("../operation.js").NeonTool<z.ZodObject<{
+        settings: z.ZodOptional<z.ZodObject<{
+            quota: z.ZodOptional<z.ZodObject<{
+                active_time_seconds: z.ZodOptional<z.ZodInt>;
+                compute_time_seconds: z.ZodOptional<z.ZodInt>;
+                written_data_bytes: z.ZodOptional<z.ZodInt>;
+                data_transfer_bytes: z.ZodOptional<z.ZodInt>;
+                logical_size_bytes: z.ZodOptional<z.ZodInt>;
+            }, z.core.$strict>>;
+            allowed_ips: z.ZodOptional<z.ZodObject<{
+                ips: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                protected_branches_only: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>;
+            enable_logical_replication: z.ZodOptional<z.ZodBoolean>;
+            maintenance_window: z.ZodOptional<z.ZodObject<{
+                weekdays: z.ZodArray<z.ZodInt>;
+                start_time: z.ZodString;
+                end_time: z.ZodString;
+            }, z.core.$strict>>;
+            block_public_connections: z.ZodOptional<z.ZodBoolean>;
+            block_vpc_connections: z.ZodOptional<z.ZodBoolean>;
+            audit_log_level: z.ZodOptional<z.ZodEnum<{
+                base: "base";
+                extended: "extended";
+                full: "full";
+            }>>;
+            hipaa: z.ZodOptional<z.ZodBoolean>;
+            preload_libraries: z.ZodOptional<z.ZodObject<{
+                use_defaults: z.ZodOptional<z.ZodBoolean>;
+                enabled_libraries: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        name: z.ZodOptional<z.ZodString>;
+        branch: z.ZodOptional<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            role_name: z.ZodOptional<z.ZodString>;
+            database_name: z.ZodOptional<z.ZodString>;
+            annotations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strict>>;
+        autoscaling_limit_min_cu: z.ZodOptional<z.ZodNumber>;
+        autoscaling_limit_max_cu: z.ZodOptional<z.ZodNumber>;
+        provisioner: z.ZodOptional<z.ZodString>;
+        region_id: z.ZodOptional<z.ZodString>;
+        default_endpoint_settings: z.ZodOptional<z.ZodObject<{
+            pg_settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            pgbouncer_settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            autoscaling_limit_min_cu: z.ZodOptional<z.ZodNumber>;
+            autoscaling_limit_max_cu: z.ZodOptional<z.ZodNumber>;
+            suspend_timeout_seconds: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strict>>;
+        pg_version: z.ZodOptional<z.ZodInt>;
+        store_passwords: z.ZodOptional<z.ZodBoolean>;
+        history_retention_seconds: z.ZodOptional<z.ZodInt>;
+        org_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, "create_projects", {
+        data_storage_bytes_hour: number;
+        data_transfer_bytes: number;
+        written_data_bytes: number;
+        compute_time_seconds: number;
+        active_time_seconds: number;
+        cpu_used_sec: number;
+        id: string;
+        platform_id: string;
+        region_id: string;
+        name: string;
+        provisioner: import("@neon/sdk").Provisioner;
+        default_endpoint_settings?: {
+            pg_settings?: {
+                [x: string]: string;
+            } | null | undefined;
+            pgbouncer_settings?: {
+                [x: string]: string;
+            } | null | undefined;
+            autoscaling_limit_min_cu?: number | null | undefined;
+            autoscaling_limit_max_cu?: number | null | undefined;
+            suspend_timeout_seconds?: number | null | undefined;
+        } | null | undefined;
+        settings?: {
+            quota?: {
+                active_time_seconds?: number | null | undefined;
+                compute_time_seconds?: number | null | undefined;
+                written_data_bytes?: number | null | undefined;
+                data_transfer_bytes?: number | null | undefined;
+                logical_size_bytes?: number | null | undefined;
+            } | null | undefined;
+            allowed_ips?: {
+                ips?: string[] | null | undefined;
+                protected_branches_only?: boolean | null | undefined;
+            } | null | undefined;
+            enable_logical_replication?: boolean | null | undefined;
+            maintenance_window?: {
+                weekdays: number[];
+                start_time: string;
+                end_time: string;
+            } | null | undefined;
+            block_public_connections?: boolean | null | undefined;
+            block_vpc_connections?: boolean | null | undefined;
+            audit_log_level?: import("@neon/sdk").ProjectAuditLogLevel | null | undefined;
+            hipaa?: boolean | null | undefined;
+            preload_libraries?: {
+                use_defaults?: boolean | null | undefined;
+                enabled_libraries?: string[] | null | undefined;
+            } | null | undefined;
+        } | null | undefined;
+        pg_version: import("@neon/sdk").PgVersion;
+        proxy_host: string;
+        branch_logical_size_limit: number;
+        branch_logical_size_limit_bytes: number;
+        store_passwords: boolean;
+        maintenance_starts_at?: string | null | undefined;
+        creation_source: string;
+        history_retention_seconds: number;
+        created_at: string;
+        updated_at: string;
+        synthetic_storage_size?: number | null | undefined;
+        consumption_period_start: string;
+        consumption_period_end: string;
+        quota_reset_at?: string | null | undefined;
+        owner_id: string;
+        owner?: {
+            email: string;
+            name: string;
+            branches_limit: number;
+            subscription_type: import("@neon/sdk").BillingSubscriptionType;
+        } | null | undefined;
+        compute_last_active_at?: string | null | undefined;
+        org_id?: string | null | undefined;
+        maintenance_scheduled_for?: string | null | undefined;
+        hipaa_enabled_at?: string | null | undefined;
+        effective_project_permission?: (import("@neon/sdk").ProjectPermissionLevel | null) | undefined;
+    }>;
     "projects.createAndConnect": (options: ToolClientOptions) => import("../operation.js").NeonTool<z.ZodObject<{
         pooled: z.ZodOptional<z.ZodBoolean>;
         settings: z.ZodOptional<z.ZodObject<{
@@ -802,7 +933,60 @@ export declare const toolFactories: {
             deletion_method: "user" | "ttl";
         } | null | undefined;
     }>;
-    "branches.createWithCompute": (options: ToolClientOptions) => import("../operation.js").NeonTool<z.ZodObject<{
+    "branches.create": (options: ToolClientOptions) => import("../operation.js").NeonTool<z.ZodObject<{
+        project_id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        parent_id: z.ZodOptional<z.ZodString>;
+        compute: z.ZodOptional<z.ZodObject<{
+            min_cu: z.ZodOptional<z.ZodNumber>;
+            max_cu: z.ZodOptional<z.ZodNumber>;
+            suspend_timeout_seconds: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strict>>;
+        no_compute: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>, "create_branches", {
+        id: string;
+        project_id: string;
+        parent_id?: string | null | undefined;
+        parent_lsn?: string | null | undefined;
+        parent_timestamp?: string | null | undefined;
+        name: string;
+        current_state: import("@neon/sdk").BranchState;
+        pending_state?: string | null | undefined;
+        state_changed_at: string;
+        logical_size?: number | null | undefined;
+        creation_source: string;
+        primary?: boolean | null | undefined;
+        default: boolean;
+        protected: boolean;
+        cpu_used_sec: number;
+        compute_time_seconds: number;
+        active_time_seconds: number;
+        written_data_bytes: number;
+        data_transfer_bytes: number;
+        created_at: string;
+        updated_at: string;
+        ttl_interval_seconds?: number | null | undefined;
+        expires_at?: string | null | undefined;
+        last_reset_at?: string | null | undefined;
+        created_by?: {
+            name?: string | null | undefined;
+            image?: string | null | undefined;
+        } | null | undefined;
+        init_source?: string | null | undefined;
+        restore_status?: string | null | undefined;
+        restored_from?: string | null | undefined;
+        restored_as?: string | null | undefined;
+        restricted_actions?: {
+            name: string;
+            reason: string;
+        }[] | null | undefined;
+        recovery?: {
+            deleted_at: string;
+            recoverable_until: string;
+            deletion_method: "user" | "ttl";
+        } | null | undefined;
+    }>;
+    "branches.createAndConnect": (options: ToolClientOptions) => import("../operation.js").NeonTool<z.ZodObject<{
         project_id: z.ZodString;
         name: z.ZodOptional<z.ZodString>;
         parent_id: z.ZodOptional<z.ZodString>;
@@ -812,7 +996,7 @@ export declare const toolFactories: {
             suspend_timeout_seconds: z.ZodOptional<z.ZodInt>;
         }, z.core.$strict>>;
         pooled: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strict>, "create_with_compute_branches", {
+    }, z.core.$strict>, "create_and_connect_branches", {
         branch: {
             id: string;
             project_id: string;
@@ -1050,6 +1234,65 @@ export declare const toolFactories: {
             deletion_method: "user" | "ttl";
         } | null | undefined;
     }>;
+    "branches.resetFromParent": (options: ToolClientOptions) => import("../operation.js").NeonTool<z.ZodObject<{
+        project_id: z.ZodString;
+        branch_id: z.ZodString;
+        preserve_under_name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, "reset_from_parent_branches", {
+        id: string;
+        project_id: string;
+        parent_id?: string | null | undefined;
+        parent_lsn?: string | null | undefined;
+        parent_timestamp?: string | null | undefined;
+        name: string;
+        current_state: import("@neon/sdk").BranchState;
+        pending_state?: string | null | undefined;
+        state_changed_at: string;
+        logical_size?: number | null | undefined;
+        creation_source: string;
+        primary?: boolean | null | undefined;
+        default: boolean;
+        protected: boolean;
+        cpu_used_sec: number;
+        compute_time_seconds: number;
+        active_time_seconds: number;
+        written_data_bytes: number;
+        data_transfer_bytes: number;
+        created_at: string;
+        updated_at: string;
+        ttl_interval_seconds?: number | null | undefined;
+        expires_at?: string | null | undefined;
+        last_reset_at?: string | null | undefined;
+        created_by?: {
+            name?: string | null | undefined;
+            image?: string | null | undefined;
+        } | null | undefined;
+        init_source?: string | null | undefined;
+        restore_status?: string | null | undefined;
+        restored_from?: string | null | undefined;
+        restored_as?: string | null | undefined;
+        restricted_actions?: {
+            name: string;
+            reason: string;
+        }[] | null | undefined;
+        recovery?: {
+            deleted_at: string;
+            recoverable_until: string;
+            deletion_method: "user" | "ttl";
+        } | null | undefined;
+    }>;
+    "branches.compareSchema": (options: ToolClientOptions) => import("../operation.js").NeonTool<z.ZodObject<{
+        project_id: z.ZodString;
+        branch_id: z.ZodString;
+        database_name: z.ZodString;
+        base_branch_id: z.ZodOptional<z.ZodString>;
+        lsn: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodOptional<z.ZodISODateTime>;
+        base_lsn: z.ZodOptional<z.ZodString>;
+        base_timestamp: z.ZodOptional<z.ZodISODateTime>;
+    }, z.core.$strict>, "compare_schema_branches", {
+        diff?: string | null | undefined;
+    }>;
     "branches.finalizeRestore": (options: ToolClientOptions) => import("../operation.js").NeonTool<z.ZodObject<{
         project_id: z.ZodString;
         branch_id: z.ZodString;

package/dist/lib/ergonomic/catalog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../src/lib/ergonomic/catalog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,OAAO,EAMN,KAAK,iBAAiB,EACtB,MAAM,WAAW,CAAC;AASnB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAS3C,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,UAAU,CAAC,CAAC;AAE7D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqtC6C,CAAC"}
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../src/lib/ergonomic/catalog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,OAAO,EAMN,KAAK,iBAAiB,EACtB,MAAM,WAAW,CAAC;AAanB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAS3C,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,UAAU,CAAC,CAAC;AAE7D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAytC6C,CAAC"}

package/dist/lib/ergonomic/catalog.js

@@ -1,6 +1,6 @@
 import { decodeBase64 } from "../binary.js";
 import { bindTool, collectObjectList, collectPages, fromGenerated, publishedId } from "./bind.js";
-import { connectionStringTool, createBranchWithComputeTool, createProjectAndConnectTool, getDefaultTool, restoreSnapshotTool, setScheduleTool } from "./composed.js";
+import { compareSchemaTool, connectionStringTool, createBranchAndConnectTool, createBranchTool, createProjectAndConnectTool, createProjectTool, getDefaultTool, resetFromParentTool, restoreSnapshotTool, setScheduleTool } from "./composed.js";
 import * as z from "zod";
 //#region src/lib/ergonomic/catalog.ts
 const logReadAnnotations = {
@@ -28,6 +28,7 @@ const toolFactories = {
 		generated: "getProject",
 		run: (neon, input, signal) => neon.projects.get(input.project_id, { signal })
 	}),
+	"projects.create": createProjectTool,
 	"projects.createAndConnect": createProjectAndConnectTool,
 	"projects.update": (options) => fromGenerated(options, {
 		id: "projects.update",
@@ -122,7 +123,8 @@ const toolFactories = {
 		generated: "getProjectBranch",
 		run: (neon, input, signal) => neon.branches.get(input.project_id, input.branch_id, { signal })
 	}),
-	"branches.createWithCompute": createBranchWithComputeTool,
+	"branches.create": createBranchTool,
+	"branches.createAndConnect": createBranchAndConnectTool,
 	"branches.update": (options) => fromGenerated(options, {
 		id: "branches.update",
 		generated: "updateProjectBranch",
@@ -144,6 +146,8 @@ const toolFactories = {
 		generated: "setDefaultProjectBranch",
 		run: (neon, input, signal) => neon.branches.setDefault(input.project_id, input.branch_id, { signal })
 	}),
+	"branches.resetFromParent": resetFromParentTool,
+	"branches.compareSchema": compareSchemaTool,
 	"branches.finalizeRestore": (options) => fromGenerated(options, {
 		id: "branches.finalizeRestore",
 		generated: "finalizeRestoreBranch",

package/dist/lib/ergonomic/composed.d.ts

@@ -1,6 +1,17 @@
 import * as z from "zod";
 import { type ToolClientOptions } from "./bind.js";
-export declare const createBranchWithComputeInputSchema: z.ZodObject<{
+export declare const createBranchInputSchema: z.ZodObject<{
+    project_id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    parent_id: z.ZodOptional<z.ZodString>;
+    compute: z.ZodOptional<z.ZodObject<{
+        min_cu: z.ZodOptional<z.ZodNumber>;
+        max_cu: z.ZodOptional<z.ZodNumber>;
+        suspend_timeout_seconds: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>>;
+    no_compute: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const createBranchAndConnectInputSchema: z.ZodObject<{
     project_id: z.ZodString;
     name: z.ZodOptional<z.ZodString>;
     parent_id: z.ZodOptional<z.ZodString>;
@@ -11,6 +22,61 @@ export declare const createBranchWithComputeInputSchema: z.ZodObject<{
     }, z.core.$strict>>;
     pooled: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
+export declare const createProjectInputSchema: z.ZodObject<{
+    settings: z.ZodOptional<z.ZodObject<{
+        quota: z.ZodOptional<z.ZodObject<{
+            active_time_seconds: z.ZodOptional<z.ZodInt>;
+            compute_time_seconds: z.ZodOptional<z.ZodInt>;
+            written_data_bytes: z.ZodOptional<z.ZodInt>;
+            data_transfer_bytes: z.ZodOptional<z.ZodInt>;
+            logical_size_bytes: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strict>>;
+        allowed_ips: z.ZodOptional<z.ZodObject<{
+            ips: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            protected_branches_only: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        enable_logical_replication: z.ZodOptional<z.ZodBoolean>;
+        maintenance_window: z.ZodOptional<z.ZodObject<{
+            weekdays: z.ZodArray<z.ZodInt>;
+            start_time: z.ZodString;
+            end_time: z.ZodString;
+        }, z.core.$strict>>;
+        block_public_connections: z.ZodOptional<z.ZodBoolean>;
+        block_vpc_connections: z.ZodOptional<z.ZodBoolean>;
+        audit_log_level: z.ZodOptional<z.ZodEnum<{
+            base: "base";
+            extended: "extended";
+            full: "full";
+        }>>;
+        hipaa: z.ZodOptional<z.ZodBoolean>;
+        preload_libraries: z.ZodOptional<z.ZodObject<{
+            use_defaults: z.ZodOptional<z.ZodBoolean>;
+            enabled_libraries: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    name: z.ZodOptional<z.ZodString>;
+    branch: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        role_name: z.ZodOptional<z.ZodString>;
+        database_name: z.ZodOptional<z.ZodString>;
+        annotations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>>;
+    autoscaling_limit_min_cu: z.ZodOptional<z.ZodNumber>;
+    autoscaling_limit_max_cu: z.ZodOptional<z.ZodNumber>;
+    provisioner: z.ZodOptional<z.ZodString>;
+    region_id: z.ZodOptional<z.ZodString>;
+    default_endpoint_settings: z.ZodOptional<z.ZodObject<{
+        pg_settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        pgbouncer_settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        autoscaling_limit_min_cu: z.ZodOptional<z.ZodNumber>;
+        autoscaling_limit_max_cu: z.ZodOptional<z.ZodNumber>;
+        suspend_timeout_seconds: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>>;
+    pg_version: z.ZodOptional<z.ZodInt>;
+    store_passwords: z.ZodOptional<z.ZodBoolean>;
+    history_retention_seconds: z.ZodOptional<z.ZodInt>;
+    org_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
 export declare const createProjectAndConnectInputSchema: z.ZodObject<{
     pooled: z.ZodOptional<z.ZodBoolean>;
     settings: z.ZodOptional<z.ZodObject<{
@@ -70,6 +136,21 @@ export declare const createProjectAndConnectInputSchema: z.ZodObject<{
 export declare const getDefaultInputSchema: z.ZodObject<{
     project_id: z.ZodString;
 }, z.core.$strict>;
+export declare const resetFromParentInputSchema: z.ZodObject<{
+    project_id: z.ZodString;
+    branch_id: z.ZodString;
+    preserve_under_name: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const compareSchemaInputSchema: z.ZodObject<{
+    project_id: z.ZodString;
+    branch_id: z.ZodString;
+    database_name: z.ZodString;
+    base_branch_id: z.ZodOptional<z.ZodString>;
+    lsn: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodOptional<z.ZodISODateTime>;
+    base_lsn: z.ZodOptional<z.ZodString>;
+    base_timestamp: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strict>;
 export declare const connectionStringInputSchema: z.ZodObject<{
     project_id: z.ZodString;
     branch_id: z.ZodOptional<z.ZodString>;
@@ -100,7 +181,60 @@ export declare const setScheduleInputSchema: z.ZodObject<{
         retention_seconds: z.ZodOptional<z.ZodInt>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
-export declare const createBranchWithComputeTool: (options: ToolClientOptions) => import("../operation.js").NeonTool<z.ZodObject<{
+export declare const createBranchTool: (options: ToolClientOptions) => import("../operation.js").NeonTool<z.ZodObject<{
+    project_id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    parent_id: z.ZodOptional<z.ZodString>;
+    compute: z.ZodOptional<z.ZodObject<{
+        min_cu: z.ZodOptional<z.ZodNumber>;
+        max_cu: z.ZodOptional<z.ZodNumber>;
+        suspend_timeout_seconds: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>>;
+    no_compute: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>, "create_branches", {
+    id: string;
+    project_id: string;
+    parent_id?: string | null | undefined;
+    parent_lsn?: string | null | undefined;
+    parent_timestamp?: string | null | undefined;
+    name: string;
+    current_state: import("@neon/sdk").BranchState;
+    pending_state?: string | null | undefined;
+    state_changed_at: string;
+    logical_size?: number | null | undefined;
+    creation_source: string;
+    primary?: boolean | null | undefined;
+    default: boolean;
+    protected: boolean;
+    cpu_used_sec: number;
+    compute_time_seconds: number;
+    active_time_seconds: number;
+    written_data_bytes: number;
+    data_transfer_bytes: number;
+    created_at: string;
+    updated_at: string;
+    ttl_interval_seconds?: number | null | undefined;
+    expires_at?: string | null | undefined;
+    last_reset_at?: string | null | undefined;
+    created_by?: {
+        name?: string | null | undefined;
+        image?: string | null | undefined;
+    } | null | undefined;
+    init_source?: string | null | undefined;
+    restore_status?: string | null | undefined;
+    restored_from?: string | null | undefined;
+    restored_as?: string | null | undefined;
+    restricted_actions?: {
+        name: string;
+        reason: string;
+    }[] | null | undefined;
+    recovery?: {
+        deleted_at: string;
+        recoverable_until: string;
+        deletion_method: "user" | "ttl";
+    } | null | undefined;
+}>;
+export declare const createBranchAndConnectTool: (options: ToolClientOptions) => import("../operation.js").NeonTool<z.ZodObject<{
     project_id: z.ZodString;
     name: z.ZodOptional<z.ZodString>;
     parent_id: z.ZodOptional<z.ZodString>;
@@ -110,7 +244,7 @@ export declare const createBranchWithComputeTool: (options: ToolClientOptions) =
         suspend_timeout_seconds: z.ZodOptional<z.ZodInt>;
     }, z.core.$strict>>;
     pooled: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strict>, "create_with_compute_branches", {
+}, z.core.$strict>, "create_and_connect_branches", {
     branch: {
         id: string;
         project_id: string;
@@ -195,6 +329,137 @@ export declare const createBranchWithComputeTool: (options: ToolClientOptions) =
     };
     connectionString: string;
 }>;
+export declare const createProjectTool: (options: ToolClientOptions) => import("../operation.js").NeonTool<z.ZodObject<{
+    settings: z.ZodOptional<z.ZodObject<{
+        quota: z.ZodOptional<z.ZodObject<{
+            active_time_seconds: z.ZodOptional<z.ZodInt>;
+            compute_time_seconds: z.ZodOptional<z.ZodInt>;
+            written_data_bytes: z.ZodOptional<z.ZodInt>;
+            data_transfer_bytes: z.ZodOptional<z.ZodInt>;
+            logical_size_bytes: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strict>>;
+        allowed_ips: z.ZodOptional<z.ZodObject<{
+            ips: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            protected_branches_only: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        enable_logical_replication: z.ZodOptional<z.ZodBoolean>;
+        maintenance_window: z.ZodOptional<z.ZodObject<{
+            weekdays: z.ZodArray<z.ZodInt>;
+            start_time: z.ZodString;
+            end_time: z.ZodString;
+        }, z.core.$strict>>;
+        block_public_connections: z.ZodOptional<z.ZodBoolean>;
+        block_vpc_connections: z.ZodOptional<z.ZodBoolean>;
+        audit_log_level: z.ZodOptional<z.ZodEnum<{
+            base: "base";
+            extended: "extended";
+            full: "full";
+        }>>;
+        hipaa: z.ZodOptional<z.ZodBoolean>;
+        preload_libraries: z.ZodOptional<z.ZodObject<{
+            use_defaults: z.ZodOptional<z.ZodBoolean>;
+            enabled_libraries: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    name: z.ZodOptional<z.ZodString>;
+    branch: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        role_name: z.ZodOptional<z.ZodString>;
+        database_name: z.ZodOptional<z.ZodString>;
+        annotations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>>;
+    autoscaling_limit_min_cu: z.ZodOptional<z.ZodNumber>;
+    autoscaling_limit_max_cu: z.ZodOptional<z.ZodNumber>;
+    provisioner: z.ZodOptional<z.ZodString>;
+    region_id: z.ZodOptional<z.ZodString>;
+    default_endpoint_settings: z.ZodOptional<z.ZodObject<{
+        pg_settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        pgbouncer_settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        autoscaling_limit_min_cu: z.ZodOptional<z.ZodNumber>;
+        autoscaling_limit_max_cu: z.ZodOptional<z.ZodNumber>;
+        suspend_timeout_seconds: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>>;
+    pg_version: z.ZodOptional<z.ZodInt>;
+    store_passwords: z.ZodOptional<z.ZodBoolean>;
+    history_retention_seconds: z.ZodOptional<z.ZodInt>;
+    org_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, "create_projects", {
+    data_storage_bytes_hour: number;
+    data_transfer_bytes: number;
+    written_data_bytes: number;
+    compute_time_seconds: number;
+    active_time_seconds: number;
+    cpu_used_sec: number;
+    id: string;
+    platform_id: string;
+    region_id: string;
+    name: string;
+    provisioner: import("@neon/sdk").Provisioner;
+    default_endpoint_settings?: {
+        pg_settings?: {
+            [x: string]: string;
+        } | null | undefined;
+        pgbouncer_settings?: {
+            [x: string]: string;
+        } | null | undefined;
+        autoscaling_limit_min_cu?: number | null | undefined;
+        autoscaling_limit_max_cu?: number | null | undefined;
+        suspend_timeout_seconds?: number | null | undefined;
+    } | null | undefined;
+    settings?: {
+        quota?: {
+            active_time_seconds?: number | null | undefined;
+            compute_time_seconds?: number | null | undefined;
+            written_data_bytes?: number | null | undefined;
+            data_transfer_bytes?: number | null | undefined;
+            logical_size_bytes?: number | null | undefined;
+        } | null | undefined;
+        allowed_ips?: {
+            ips?: string[] | null | undefined;
+            protected_branches_only?: boolean | null | undefined;
+        } | null | undefined;
+        enable_logical_replication?: boolean | null | undefined;
+        maintenance_window?: {
+            weekdays: number[];
+            start_time: string;
+            end_time: string;
+        } | null | undefined;
+        block_public_connections?: boolean | null | undefined;
+        block_vpc_connections?: boolean | null | undefined;
+        audit_log_level?: import("@neon/sdk").ProjectAuditLogLevel | null | undefined;
+        hipaa?: boolean | null | undefined;
+        preload_libraries?: {
+            use_defaults?: boolean | null | undefined;
+            enabled_libraries?: string[] | null | undefined;
+        } | null | undefined;
+    } | null | undefined;
+    pg_version: import("@neon/sdk").PgVersion;
+    proxy_host: string;
+    branch_logical_size_limit: number;
+    branch_logical_size_limit_bytes: number;
+    store_passwords: boolean;
+    maintenance_starts_at?: string | null | undefined;
+    creation_source: string;
+    history_retention_seconds: number;
+    created_at: string;
+    updated_at: string;
+    synthetic_storage_size?: number | null | undefined;
+    consumption_period_start: string;
+    consumption_period_end: string;
+    quota_reset_at?: string | null | undefined;
+    owner_id: string;
+    owner?: {
+        email: string;
+        name: string;
+        branches_limit: number;
+        subscription_type: import("@neon/sdk").BillingSubscriptionType;
+    } | null | undefined;
+    compute_last_active_at?: string | null | undefined;
+    org_id?: string | null | undefined;
+    maintenance_scheduled_for?: string | null | undefined;
+    hipaa_enabled_at?: string | null | undefined;
+    effective_project_permission?: (import("@neon/sdk").ProjectPermissionLevel | null) | undefined;
+}>;
 export declare const createProjectAndConnectTool: (options: ToolClientOptions) => import("../operation.js").NeonTool<z.ZodObject<{
     pooled: z.ZodOptional<z.ZodBoolean>;
     settings: z.ZodOptional<z.ZodObject<{
@@ -375,6 +640,65 @@ export declare const getDefaultTool: (options: ToolClientOptions) => import("../
         deletion_method: "user" | "ttl";
     } | null | undefined;
 }>;
+export declare const resetFromParentTool: (options: ToolClientOptions) => import("../operation.js").NeonTool<z.ZodObject<{
+    project_id: z.ZodString;
+    branch_id: z.ZodString;
+    preserve_under_name: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, "reset_from_parent_branches", {
+    id: string;
+    project_id: string;
+    parent_id?: string | null | undefined;
+    parent_lsn?: string | null | undefined;
+    parent_timestamp?: string | null | undefined;
+    name: string;
+    current_state: import("@neon/sdk").BranchState;
+    pending_state?: string | null | undefined;
+    state_changed_at: string;
+    logical_size?: number | null | undefined;
+    creation_source: string;
+    primary?: boolean | null | undefined;
+    default: boolean;
+    protected: boolean;
+    cpu_used_sec: number;
+    compute_time_seconds: number;
+    active_time_seconds: number;
+    written_data_bytes: number;
+    data_transfer_bytes: number;
+    created_at: string;
+    updated_at: string;
+    ttl_interval_seconds?: number | null | undefined;
+    expires_at?: string | null | undefined;
+    last_reset_at?: string | null | undefined;
+    created_by?: {
+        name?: string | null | undefined;
+        image?: string | null | undefined;
+    } | null | undefined;
+    init_source?: string | null | undefined;
+    restore_status?: string | null | undefined;
+    restored_from?: string | null | undefined;
+    restored_as?: string | null | undefined;
+    restricted_actions?: {
+        name: string;
+        reason: string;
+    }[] | null | undefined;
+    recovery?: {
+        deleted_at: string;
+        recoverable_until: string;
+        deletion_method: "user" | "ttl";
+    } | null | undefined;
+}>;
+export declare const compareSchemaTool: (options: ToolClientOptions) => import("../operation.js").NeonTool<z.ZodObject<{
+    project_id: z.ZodString;
+    branch_id: z.ZodString;
+    database_name: z.ZodString;
+    base_branch_id: z.ZodOptional<z.ZodString>;
+    lsn: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodOptional<z.ZodISODateTime>;
+    base_lsn: z.ZodOptional<z.ZodString>;
+    base_timestamp: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strict>, "compare_schema_branches", {
+    diff?: string | null | undefined;
+}>;
 export declare const connectionStringTool: (options: ToolClientOptions) => import("../operation.js").NeonTool<z.ZodObject<{
     project_id: z.ZodString;
     branch_id: z.ZodOptional<z.ZodString>;

package/dist/lib/ergonomic/composed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"composed.d.ts","sourceRoot":"","sources":["../../../src/lib/ergonomic/composed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,OAAO,EAAyB,KAAK,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAuB1E,eAAO,MAAM,kCAAkC;;;;;;;;;;kBAY7C,CAAC;AAEH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAG7C,CAAC;AAEH,eAAO,MAAM,qBAAqB;;kBAEhC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;kBAOtC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;kBAWrC,CAAC;AAIH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;kBASjC,CAAC;AAEH,eAAO,MAAM,2BAA2B,GAAI,SAAS,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2CpE,CAAC;AAEH,eAAO,MAAM,2BAA2B,GAAI,SAAS,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BpE,CAAC;AAEH,eAAO,MAAM,cAAc,GAAI,SAAS,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsBvD,CAAC;AAEH,eAAO,MAAM,oBAAoB,GAAI,SAAS,iBAAiB;;;;;;;yDA0C7D,CAAC;AAEH,eAAO,MAAM,mBAAmB,GAAI,SAAS,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+B5D,CAAC;AAEH,eAAO,MAAM,eAAe,GAAI,SAAS,iBAAiB;;;;;;;;;;;;;;mDA2BxD,CAAC"}
+{"version":3,"file":"composed.d.ts","sourceRoot":"","sources":["../../../src/lib/ergonomic/composed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,OAAO,EAAyB,KAAK,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAmD1E,eAAO,MAAM,uBAAuB;;;;;;;;;;kBAqBjC,CAAC;AAEJ,eAAO,MAAM,iCAAiC;;;;;;;;;;kBAM5C,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEnC,CAAC;AAEH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAG7C,CAAC;AAEH,eAAO,MAAM,qBAAqB;;kBAEhC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;kBAOrC,CAAC;AAIH,eAAO,MAAM,wBAAwB;;;;;;;;;kBASnC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;kBAOtC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;kBAWrC,CAAC;AAIH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;kBASjC,CAAC;AAEH,eAAO,MAAM,gBAAgB,GAAI,SAAS,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0CzD,CAAC;AAEH,eAAO,MAAM,0BAA0B,GAAI,SAAS,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCnE,CAAC;AAEH,eAAO,MAAM,iBAAiB,GAAI,SAAS,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqB1D,CAAC;AAEH,eAAO,MAAM,2BAA2B,GAAI,SAAS,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BpE,CAAC;AAEH,eAAO,MAAM,cAAc,GAAI,SAAS,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsBvD,CAAC;AAEH,eAAO,MAAM,mBAAmB,GAAI,SAAS,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6B5D,CAAC;AAEH,eAAO,MAAM,iBAAiB,GAAI,SAAS,iBAAiB;;;;;;;;;;;EA0C1D,CAAC;AAEH,eAAO,MAAM,oBAAoB,GAAI,SAAS,iBAAiB;;;;;;;yDA0C7D,CAAC;AAEH,eAAO,MAAM,mBAAmB,GAAI,SAAS,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+B5D,CAAC;AAEH,eAAO,MAAM,eAAe,GAAI,SAAS,iBAAiB;;;;;;;;;;;;;;mDA2BxD,CAAC"}

package/dist/lib/ergonomic/composed.js

@@ -1,4 +1,4 @@
-import { zBackupScheduleItem, zBranchCreateRequest, zComputeUnit, zCreateProjectBody, zCreateProjectBranchPath, zGetConnectionUriPath, zGetConnectionUriQuery, zListProjectBranchesPath, zRestoreSnapshotBody, zRestoreSnapshotPath, zSetSnapshotSchedulePath, zSuspendTimeoutSeconds } from "../../generated/zod.gen.js";
+import { zBackupScheduleItem, zBranchCreateRequest, zBranchRestoreRequest, zComputeUnit, zCreateProjectBody, zCreateProjectBranchPath, zGetConnectionUriPath, zGetConnectionUriQuery, zGetProjectBranchSchemaComparisonPath, zGetProjectBranchSchemaComparisonQuery, zListProjectBranchesPath, zRestoreProjectBranchPath, zRestoreSnapshotBody, zRestoreSnapshotPath, zSetSnapshotSchedulePath, zSuspendTimeoutSeconds } from "../../generated/zod.gen.js";
 import { bindTool, publishedId } from "./bind.js";
 import * as z from "zod";
 //#region src/lib/ergonomic/composed.ts
@@ -14,22 +14,59 @@ const readAnnotations = {
 const pooledField = z.boolean().describe("Return a pooled connection string. Default true. Set false for a direct connection.").optional();
 const branchCreateFields = zBranchCreateRequest.shape.branch.unwrap().shape;
 const projectCreateFields = zCreateProjectBody.shape.project.shape;
-const createBranchWithComputeInputSchema = z.strictObject({
+const computeSettingsSchema = z.strictObject({
+	min_cu: zComputeUnit.optional(),
+	max_cu: zComputeUnit.optional(),
+	suspend_timeout_seconds: zSuspendTimeoutSeconds.optional()
+}).optional();
+const mapCompute = (compute) => compute === void 0 ? void 0 : {
+	minCu: compute.min_cu,
+	maxCu: compute.max_cu,
+	suspendTimeoutSeconds: compute.suspend_timeout_seconds
+};
+const NO_COMPUTE_WITH_COMPUTE = "Pass compute settings or no_compute, not both.";
+const createBranchInputSchema = z.strictObject({
+	project_id: zCreateProjectBranchPath.shape.project_id,
+	name: branchCreateFields.name,
+	parent_id: branchCreateFields.parent_id,
+	compute: computeSettingsSchema,
+	no_compute: z.boolean().describe("Skip the read-write endpoint. Default false. Cannot be combined with compute.").optional()
+}).superRefine((value, ctx) => {
+	if (value.no_compute === true && value.compute !== void 0) ctx.addIssue({
+		code: "custom",
+		message: NO_COMPUTE_WITH_COMPUTE,
+		path: ["no_compute"]
+	});
+});
+const createBranchAndConnectInputSchema = z.strictObject({
 	project_id: zCreateProjectBranchPath.shape.project_id,
 	name: branchCreateFields.name,
 	parent_id: branchCreateFields.parent_id,
-	compute: z.strictObject({
-		min_cu: zComputeUnit.optional(),
-		max_cu: zComputeUnit.optional(),
-		suspend_timeout_seconds: zSuspendTimeoutSeconds.optional()
-	}).optional(),
+	compute: computeSettingsSchema,
 	pooled: pooledField
 });
+const createProjectInputSchema = z.strictObject({ ...projectCreateFields });
 const createProjectAndConnectInputSchema = z.strictObject({
 	...projectCreateFields,
 	pooled: pooledField
 });
 const getDefaultInputSchema = z.strictObject({ project_id: zListProjectBranchesPath.shape.project_id });
+const resetFromParentInputSchema = z.strictObject({
+	project_id: zRestoreProjectBranchPath.shape.project_id,
+	branch_id: zRestoreProjectBranchPath.shape.branch_id,
+	preserve_under_name: zBranchRestoreRequest.shape.preserve_under_name.describe("Name under which to save the current branch before the reset. Required when the branch has children; those children move to the new branch.")
+});
+const compareQuery = zGetProjectBranchSchemaComparisonQuery.shape;
+const compareSchemaInputSchema = z.strictObject({
+	project_id: zGetProjectBranchSchemaComparisonPath.shape.project_id,
+	branch_id: zGetProjectBranchSchemaComparisonPath.shape.branch_id,
+	database_name: compareQuery.db_name,
+	base_branch_id: compareQuery.base_branch_id,
+	lsn: compareQuery.lsn,
+	timestamp: compareQuery.timestamp,
+	base_lsn: compareQuery.base_lsn,
+	base_timestamp: compareQuery.base_timestamp
+});
 const connectionStringInputSchema = z.strictObject({
 	project_id: zGetConnectionUriPath.shape.project_id,
 	branch_id: zGetConnectionUriQuery.shape.branch_id,
@@ -58,12 +95,39 @@ const setScheduleInputSchema = z.strictObject({
 		frequency: snapshotFrequency
 	}))
 });
-const createBranchWithComputeTool = (options) => bindTool(options, {
-	operationId: "branches.createWithCompute",
-	id: publishedId("branches.createWithCompute"),
-	title: "Create branch with compute",
+const createBranchTool = (options) => bindTool(options, {
+	operationId: "branches.create",
+	id: publishedId("branches.create"),
+	title: "Create branch",
+	description: "Create a branch with a read-write endpoint by default. Pass no_compute to skip the endpoint. The call waits until operation-backed provisioning finishes, up to five minutes by default. Does not return a connection string; use branches.createAndConnect or postgres.connectionString for that.",
+	inputSchema: createBranchInputSchema,
+	annotations: writeAnnotations,
+	requiresApproval: true,
+	metadata: {
+		method: "POST",
+		path: "/projects/{project_id}/branches",
+		stability: "stable",
+		deprecated: false,
+		tags: ["Branch"]
+	}
+}, (neon, input, signal) => {
+	if (input.no_compute === true) return neon.branches.create(input.project_id, {
+		name: input.name,
+		parent_id: input.parent_id,
+		noCompute: true
+	}, { signal });
+	return neon.branches.create(input.project_id, {
+		name: input.name,
+		parent_id: input.parent_id,
+		compute: mapCompute(input.compute)
+	}, { signal });
+});
+const createBranchAndConnectTool = (options) => bindTool(options, {
+	operationId: "branches.createAndConnect",
+	id: publishedId("branches.createAndConnect"),
+	title: "Create branch and connect",
 	description: "Create a branch with a read-write endpoint and return its connection string. The call waits until operation-backed provisioning finishes, up to five minutes by default.",
-	inputSchema: createBranchWithComputeInputSchema,
+	inputSchema: createBranchAndConnectInputSchema,
 	annotations: writeAnnotations,
 	requiresApproval: true,
 	metadata: {
@@ -73,18 +137,30 @@ const createBranchWithComputeTool = (options) => bindTool(options, {
 		deprecated: false,
 		tags: ["Branch"]
 	}
-}, (neon, input, signal) => neon.branches.createWithCompute(input.project_id, {
+}, (neon, input, signal) => neon.branches.createAndConnect(input.project_id, {
 	name: input.name,
 	parentId: input.parent_id,
-	compute: input.compute === void 0 ? void 0 : {
-		minCu: input.compute.min_cu,
-		maxCu: input.compute.max_cu,
-		suspendTimeoutSeconds: input.compute.suspend_timeout_seconds
-	}
+	compute: mapCompute(input.compute)
 }, {
 	signal,
 	...input.pooled === void 0 ? {} : { pooled: input.pooled }
 }));
+const createProjectTool = (options) => bindTool(options, {
+	operationId: "projects.create",
+	id: publishedId("projects.create"),
+	title: "Create project",
+	description: "Create a project. The API always provisions a default branch with read-write compute. The call waits until operation-backed provisioning finishes, up to five minutes by default. Does not return a connection string; use projects.createAndConnect or postgres.connectionString for that.",
+	inputSchema: createProjectInputSchema,
+	annotations: writeAnnotations,
+	requiresApproval: true,
+	metadata: {
+		method: "POST",
+		path: "/projects",
+		stability: "stable",
+		deprecated: false,
+		tags: ["Project"]
+	}
+}, (neon, input, signal) => neon.projects.create(input, { signal }));
 const createProjectAndConnectTool = (options) => bindTool(options, {
 	operationId: "projects.createAndConnect",
 	id: publishedId("projects.createAndConnect"),
@@ -123,6 +199,45 @@ const getDefaultTool = (options) => bindTool(options, {
 		tags: ["Branch"]
 	}
 }, (neon, input, signal) => neon.branches.getDefault(input.project_id, { signal }));
+const resetFromParentTool = (options) => bindTool(options, {
+	operationId: "branches.resetFromParent",
+	id: publishedId("branches.resetFromParent"),
+	title: "Reset branch from parent",
+	description: "Reset a branch to its parent's current HEAD. Discards every change the branch has written since it diverged. preserve_under_name is required when the branch has children. For an LSN or timestamp restore, use the raw restoreProjectBranch operation.",
+	inputSchema: resetFromParentInputSchema,
+	annotations: writeAnnotations,
+	requiresApproval: true,
+	metadata: {
+		method: "POST",
+		path: "/projects/{project_id}/branches/{branch_id}/restore",
+		stability: "stable",
+		deprecated: false,
+		tags: ["Branch"]
+	}
+}, (neon, input, signal) => neon.branches.resetFromParent(input.project_id, input.branch_id, input.preserve_under_name === void 0 ? void 0 : { preserveUnderName: input.preserve_under_name }, { signal }));
+const compareSchemaTool = (options) => bindTool(options, {
+	operationId: "branches.compareSchema",
+	id: publishedId("branches.compareSchema"),
+	title: "Compare database schema",
+	description: "Compare a branch database schema to another branch. Omitting base_branch_id compares against the parent. Returns a unified SQL diff.",
+	inputSchema: compareSchemaInputSchema,
+	annotations: readAnnotations,
+	requiresApproval: false,
+	metadata: {
+		method: "GET",
+		path: "/projects/{project_id}/branches/{branch_id}/compare_schema",
+		stability: "stable",
+		deprecated: false,
+		tags: ["Branch"]
+	}
+}, (neon, input, signal) => neon.branches.compareSchema(input.project_id, input.branch_id, {
+	databaseName: input.database_name,
+	...input.base_branch_id === void 0 ? {} : { baseBranchId: input.base_branch_id },
+	...input.lsn === void 0 ? {} : { lsn: input.lsn },
+	...input.timestamp === void 0 ? {} : { timestamp: input.timestamp },
+	...input.base_lsn === void 0 ? {} : { baseLsn: input.base_lsn },
+	...input.base_timestamp === void 0 ? {} : { baseTimestamp: input.base_timestamp }
+}, { signal }));
 const connectionStringTool = (options) => bindTool(options, {
 	operationId: "postgres.connectionString",
 	id: publishedId("postgres.connectionString"),
@@ -183,4 +298,4 @@ const setScheduleTool = (options) => bindTool(options, {
 	}
 }, (neon, input, signal) => neon.snapshots.setSchedule(input.project_id, input.branch_id, { schedule: input.schedule }, { signal }));
 //#endregion
-export { connectionStringInputSchema, connectionStringTool, createBranchWithComputeInputSchema, createBranchWithComputeTool, createProjectAndConnectInputSchema, createProjectAndConnectTool, getDefaultInputSchema, getDefaultTool, restoreSnapshotInputSchema, restoreSnapshotTool, setScheduleInputSchema, setScheduleTool };
+export { compareSchemaInputSchema, compareSchemaTool, connectionStringInputSchema, connectionStringTool, createBranchAndConnectInputSchema, createBranchAndConnectTool, createBranchInputSchema, createBranchTool, createProjectAndConnectInputSchema, createProjectAndConnectTool, createProjectInputSchema, createProjectTool, getDefaultInputSchema, getDefaultTool, resetFromParentInputSchema, resetFromParentTool, restoreSnapshotInputSchema, restoreSnapshotTool, setScheduleInputSchema, setScheduleTool };

package/dist/lib/ergonomic/ids.d.ts

@@ -1,6 +1,6 @@
-export declare const hiddenToolIds: readonly ["operations.waitFor", "branches.create", "projects.create", "postgres.roles.password", "storage.objects.get"];
+export declare const hiddenToolIds: readonly ["operations.waitFor", "postgres.roles.password", "storage.objects.get"];
 export type HiddenToolId = (typeof hiddenToolIds)[number];
-export declare const toolIds: readonly ["projects.list", "projects.get", "projects.createAndConnect", "projects.update", "projects.delete", "projects.recover", "projects.transfer", "projects.transferFromUser", "projects.permissions.list", "projects.permissions.grant", "projects.permissions.revoke", "projects.members.list", "projects.members.setRole", "projects.members.removeRole", "branches.list", "branches.get", "branches.createWithCompute", "branches.update", "branches.delete", "branches.getDefault", "branches.setDefault", "branches.finalizeRestore", "postgres.connectionString", "postgres.endpoints.list", "postgres.endpoints.listByBranch", "postgres.endpoints.get", "postgres.endpoints.create", "postgres.endpoints.update", "postgres.endpoints.delete", "postgres.endpoints.start", "postgres.endpoints.suspend", "postgres.endpoints.restart", "postgres.roles.list", "postgres.roles.get", "postgres.roles.create", "postgres.roles.delete", "postgres.roles.resetPassword", "postgres.databases.list", "postgres.databases.get", "postgres.databases.create", "postgres.databases.update", "postgres.databases.delete", "postgres.dataApi.get", "postgres.dataApi.create", "postgres.dataApi.update", "postgres.dataApi.delete", "storage.get", "storage.buckets.list", "storage.buckets.create", "storage.buckets.delete", "storage.objects.list", "storage.objects.delete", "storage.objects.deleteByPrefix", "storage.objects.presign", "functions.list", "functions.get", "functions.update", "functions.delete", "functions.deploy", "credentials.list", "credentials.create", "credentials.revoke", "aiGateway.get", "logs.query", "logs.fields", "logs.fieldValues", "snapshots.list", "snapshots.create", "snapshots.update", "snapshots.delete", "snapshots.restore", "snapshots.getSchedule", "snapshots.setSchedule", "operations.list", "operations.get", "auth.get", "auth.create", "auth.disable", "auth.updateConfig", "auth.oauthProviders.list", "auth.oauthProviders.add", "auth.oauthProviders.update", "auth.oauthProviders.delete", "auth.trustedDomains.list", "auth.trustedDomains.add", "auth.trustedDomains.delete", "auth.users.create", "auth.users.delete", "auth.users.updateRole", "consumption.perProject", "consumption.perProjectV2", "consumption.perBranchV2", "apiKeys.list", "apiKeys.create", "apiKeys.revoke", "regions.list", "user.me", "user.organizations"];
+export declare const toolIds: readonly ["projects.list", "projects.get", "projects.create", "projects.createAndConnect", "projects.update", "projects.delete", "projects.recover", "projects.transfer", "projects.transferFromUser", "projects.permissions.list", "projects.permissions.grant", "projects.permissions.revoke", "projects.members.list", "projects.members.setRole", "projects.members.removeRole", "branches.list", "branches.get", "branches.create", "branches.createAndConnect", "branches.update", "branches.delete", "branches.getDefault", "branches.setDefault", "branches.resetFromParent", "branches.compareSchema", "branches.finalizeRestore", "postgres.connectionString", "postgres.endpoints.list", "postgres.endpoints.listByBranch", "postgres.endpoints.get", "postgres.endpoints.create", "postgres.endpoints.update", "postgres.endpoints.delete", "postgres.endpoints.start", "postgres.endpoints.suspend", "postgres.endpoints.restart", "postgres.roles.list", "postgres.roles.get", "postgres.roles.create", "postgres.roles.delete", "postgres.roles.resetPassword", "postgres.databases.list", "postgres.databases.get", "postgres.databases.create", "postgres.databases.update", "postgres.databases.delete", "postgres.dataApi.get", "postgres.dataApi.create", "postgres.dataApi.update", "postgres.dataApi.delete", "storage.get", "storage.buckets.list", "storage.buckets.create", "storage.buckets.delete", "storage.objects.list", "storage.objects.delete", "storage.objects.deleteByPrefix", "storage.objects.presign", "functions.list", "functions.get", "functions.update", "functions.delete", "functions.deploy", "credentials.list", "credentials.create", "credentials.revoke", "aiGateway.get", "logs.query", "logs.fields", "logs.fieldValues", "snapshots.list", "snapshots.create", "snapshots.update", "snapshots.delete", "snapshots.restore", "snapshots.getSchedule", "snapshots.setSchedule", "operations.list", "operations.get", "auth.get", "auth.create", "auth.disable", "auth.updateConfig", "auth.oauthProviders.list", "auth.oauthProviders.add", "auth.oauthProviders.update", "auth.oauthProviders.delete", "auth.trustedDomains.list", "auth.trustedDomains.add", "auth.trustedDomains.delete", "auth.users.create", "auth.users.delete", "auth.users.updateRole", "consumption.perProject", "consumption.perProjectV2", "consumption.perBranchV2", "apiKeys.list", "apiKeys.create", "apiKeys.revoke", "regions.list", "user.me", "user.organizations"];
 export type NeonToolId = (typeof toolIds)[number];
 export declare const isNeonToolId: (id: string) => id is NeonToolId;
 export declare const unpublishedToolError: (id: string) => TypeError;

package/dist/lib/ergonomic/ids.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ids.d.ts","sourceRoot":"","sources":["../../../src/lib/ergonomic/ids.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,yHAMhB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AAE1D,eAAO,MAAM,OAAO,gxEAmGV,CAAC;AAEX,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;AAElD,eAAO,MAAM,YAAY,GAAI,IAAI,MAAM,KAAG,EAAE,IAAI,UACJ,CAAC;AAa7C,eAAO,MAAM,oBAAoB,GAAI,IAAI,MAAM,KAAG,SAOjD,CAAC"}
+{"version":3,"file":"ids.d.ts","sourceRoot":"","sources":["../../../src/lib/ergonomic/ids.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,mFAIhB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AAE1D,eAAO,MAAM,OAAO,22EAuGV,CAAC;AAEX,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;AAElD,eAAO,MAAM,YAAY,GAAI,IAAI,MAAM,KAAG,EAAE,IAAI,UACJ,CAAC;AAS7C,eAAO,MAAM,oBAAoB,GAAI,IAAI,MAAM,KAAG,SAOjD,CAAC"}

package/dist/lib/ergonomic/ids.js

@@ -1,14 +1,13 @@
 //#region src/lib/ergonomic/ids.ts
 const hiddenToolIds = [
 	"operations.waitFor",
-	"branches.create",
-	"projects.create",
 	"postgres.roles.password",
 	"storage.objects.get"
 ];
 const toolIds = [
 	"projects.list",
 	"projects.get",
+	"projects.create",
 	"projects.createAndConnect",
 	"projects.update",
 	"projects.delete",
@@ -23,11 +22,14 @@ const toolIds = [
 	"projects.members.removeRole",
 	"branches.list",
 	"branches.get",
-	"branches.createWithCompute",
+	"branches.create",
+	"branches.createAndConnect",
 	"branches.update",
 	"branches.delete",
 	"branches.getDefault",
 	"branches.setDefault",
+	"branches.resetFromParent",
+	"branches.compareSchema",
 	"branches.finalizeRestore",
 	"postgres.connectionString",
 	"postgres.endpoints.list",
@@ -108,8 +110,6 @@ const toolIds = [
 ];
 const isNeonToolId = (id) => toolIds.includes(id);
 const hiddenToolHint = {
-	"projects.create": "Use \"projects.createAndConnect\", which attaches compute and returns a connection string.",
-	"branches.create": "Use \"branches.createWithCompute\", which attaches compute and returns a connection string.",
 	"operations.waitFor": "Write tools wait for readiness. operations.waitFor is not a tool.",
 	"postgres.roles.password": "Role passwords are not published as a tool.",
 	"storage.objects.get": "Object bytes are not published as a tool."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neon/tools",
-  "version": "0.7.0",
+  "version": "1.0.0",
   "description": "Agent tools for the Neon SDK ergonomic client, compatible with MCP, Eve, and Mastra.",
   "keywords": [
     "neon",
@@ -69,7 +69,7 @@
   ],
   "dependencies": {
     "zod": "^4.4.3",
-    "@neon/sdk": "2.2.0"
+    "@neon/sdk": "3.0.0"
   },
   "devDependencies": {
     "@hey-api/openapi-ts": "0.98.2",