@neon/tools 0.5.0 → 0.6.0

package/dist/lib/ergonomic/ids.js

@@ -0,0 +1,122 @@
+//#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.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"
+];
+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."
+};
+const unpublishedToolError = (id) => {
+	if (hiddenToolIds.includes(id)) return /* @__PURE__ */ new TypeError(`Neon tool "${id}" is not published. ${hiddenToolHint[id]}`);
+	return /* @__PURE__ */ new TypeError(`Unknown Neon tool "${id}".`);
+};
+//#endregion
+export { hiddenToolIds, isNeonToolId, toolIds, unpublishedToolError };

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

@@ -0,0 +1,4 @@
+export { type PublishedId, publishedId, type ToolClientOptions, } from "./bind.js";
+export { type ToolFactory, toolFactories } from "./catalog.js";
+export { type HiddenToolId, hiddenToolIds, isNeonToolId, type NeonToolId, toolIds, unpublishedToolError, } from "./ids.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/ergonomic/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,WAAW,EAChB,WAAW,EACX,KAAK,iBAAiB,GACtB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,KAAK,WAAW,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,EACN,KAAK,YAAY,EACjB,aAAa,EACb,YAAY,EACZ,KAAK,UAAU,EACf,OAAO,EACP,oBAAoB,GACpB,MAAM,UAAU,CAAC"}

package/dist/lib/ergonomic/index.js

@@ -0,0 +1,4 @@
+import { publishedId } from "./bind.js";
+import { toolFactories } from "./catalog.js";
+import { hiddenToolIds, isNeonToolId, toolIds, unpublishedToolError } from "./ids.js";
+export { hiddenToolIds, isNeonToolId, publishedId, toolFactories, toolIds, unpublishedToolError };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@neon/tools",
-  "version": "0.5.0",
-  "description": "Agent tools for the Neon Management API and SDK workflows, compatible with MCP, Eve, and Mastra.",
+  "version": "0.6.0",
+  "description": "Agent tools for the Neon SDK ergonomic client, compatible with MCP, Eve, and Mastra.",
   "keywords": [
     "neon",
     "database",

package/dist/lib/workflows.d.ts

@@ -1,315 +0,0 @@
-import { type NeonConfig } from "@neon/sdk";
-import * as z from "zod";
-import { type NeonBearerCredential } from "./auth.js";
-import type { NeonTool } from "./operation.js";
-export interface WorkflowClientOptions {
-    apiKey?: NeonBearerCredential;
-    baseUrl?: string;
-    fetch?: typeof fetch;
-    wait?: NeonConfig["wait"];
-}
-export declare const createBranchWithComputeInputSchema: 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>>;
-    pooled: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strict>;
-export declare const createProjectAndConnectInputSchema: z.ZodObject<{
-    pooled: z.ZodOptional<z.ZodBoolean>;
-    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 workflowIds: readonly ["createBranchWithCompute", "createProjectAndConnect"];
-export type NeonWorkflowId = (typeof workflowIds)[number];
-export declare const workflowFactories: {
-    createBranchWithCompute: (options: WorkflowClientOptions) => 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>>;
-        pooled: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strict>, "create_branch_with_compute", {
-        branch: {
-            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;
-        };
-        endpoint: {
-            host: string;
-            id: string;
-            name?: string | null | undefined;
-            project_id: string;
-            branch_id: string;
-            autoscaling_limit_min_cu: import("@neon/sdk").ComputeUnit;
-            autoscaling_limit_max_cu: import("@neon/sdk").ComputeUnit;
-            region_id: string;
-            type: import("@neon/sdk").EndpointType;
-            current_state: import("@neon/sdk").EndpointState;
-            pending_state?: import("@neon/sdk").EndpointState | null | undefined;
-            settings: {
-                pg_settings?: {
-                    [x: string]: string;
-                } | null | undefined;
-                pgbouncer_settings?: {
-                    [x: string]: string;
-                } | null | undefined;
-                preload_libraries?: {
-                    use_defaults?: boolean | null | undefined;
-                    enabled_libraries?: string[] | null | undefined;
-                } | null | undefined;
-            };
-            pooler_enabled: boolean;
-            pooler_mode: import("@neon/sdk").EndpointPoolerMode;
-            disabled: boolean;
-            passwordless_access: boolean;
-            last_active?: string | null | undefined;
-            creation_source: string;
-            created_at: string;
-            updated_at: string;
-            started_at?: string | null | undefined;
-            suspended_at?: string | null | undefined;
-            proxy_host: string;
-            suspend_timeout_seconds: import("@neon/sdk").SuspendTimeoutSeconds;
-            provisioner: import("@neon/sdk").Provisioner;
-            compute_release_version?: string | null | undefined;
-        };
-        connectionString: string;
-    }>;
-    createProjectAndConnect: (options: WorkflowClientOptions) => NeonTool<z.ZodObject<{
-        pooled: z.ZodOptional<z.ZodBoolean>;
-        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_project_and_connect", {
-        project: {
-            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;
-        };
-        connectionString: string;
-    }>;
-};
-export type WorkflowFactories = typeof workflowFactories;
-export declare const isNeonWorkflowId: (id: string) => id is NeonWorkflowId;
-export declare const workflowFactoryFor: (workflowId: NeonWorkflowId) => WorkflowFactories[NeonWorkflowId];
-//# sourceMappingURL=workflows.d.ts.map

package/dist/lib/workflows.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"workflows.d.ts","sourceRoot":"","sources":["../../src/lib/workflows.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqC,KAAK,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/E,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,OAAO,EAEN,KAAK,oBAAoB,EAEzB,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAEX,QAAQ,EAER,MAAM,gBAAgB,CAAC;AAGxB,MAAM,WAAW,qBAAqB;IACrC,MAAM,CAAC,EAAE,oBAAoB,CAAC;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;IACrB,IAAI,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC;CAC1B;AAkBD,eAAO,MAAM,kCAAkC;;;;;;;;;;kBAY7C,CAAC;AAEH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAG7C,CAAC;AAEH,eAAO,MAAM,WAAW,iEAGd,CAAC;AAEX,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAkI1D,eAAO,MAAM,iBAAiB;uCA1EgB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCA6CrB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgClE,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC;AAEzD,eAAO,MAAM,gBAAgB,GAAI,IAAI,MAAM,KAAG,EAAE,IAAI,cACJ,CAAC;AAEjD,eAAO,MAAM,kBAAkB,GAC9B,YAAY,cAAc,KACxB,iBAAiB,CAAC,cAAc,CAQlC,CAAC"}

package/dist/lib/workflows.js

@@ -1,113 +0,0 @@
-import { missingBearerCredential, requireBearerCredential } from "./auth.js";
-import { zBranchCreateRequest, zComputeUnit, zCreateProjectBody, zCreateProjectBranchPath, zSuspendTimeoutSeconds } from "../generated/zod.gen.js";
-import { toToolResult } from "./result.js";
-import { createNeonClient } from "@neon/sdk";
-import * as z from "zod";
-//#region src/lib/workflows.ts
-const branchCreateFields = zBranchCreateRequest.shape.branch.unwrap().shape;
-const projectCreateFields = zCreateProjectBody.shape.project.shape;
-const writeAnnotations = {
-	readOnlyHint: false,
-	destructiveHint: true,
-	openWorldHint: true
-};
-const pooledField = z.boolean().describe("Return a pooled connection string. Default true. Set false for a direct connection.").optional();
-const createBranchWithComputeInputSchema = 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(),
-	pooled: pooledField
-});
-const createProjectAndConnectInputSchema = z.strictObject({
-	...projectCreateFields,
-	pooled: pooledField
-});
-const workflowIds = ["createBranchWithCompute", "createProjectAndConnect"];
-const resolveApiKey = (options, context) => {
-	if (context !== void 0 && "apiKey" in context) {
-		if (context.apiKey === void 0) throw new TypeError("A Neon API key or OAuth access token is required");
-		return requireBearerCredential(context.apiKey);
-	}
-	return options.apiKey === void 0 ? missingBearerCredential : requireBearerCredential(options.apiKey);
-};
-const workflowClient = (options, context) => createNeonClient({
-	apiKey: resolveApiKey(options, context),
-	throwOnError: true,
-	...options.baseUrl === void 0 ? {} : { baseUrl: options.baseUrl },
-	...options.fetch === void 0 ? {} : { fetch: options.fetch },
-	...options.wait === void 0 ? {} : { wait: options.wait }
-});
-const bindWorkflow = (options, tool, run) => ({
-	...tool,
-	async execute(input, context) {
-		const parsed = await tool.inputSchema.parseAsync(input);
-		const result = await run(workflowClient(options, context), parsed, context?.signal);
-		return toToolResult(result);
-	}
-});
-const createBranchWithComputeTool = (options) => bindWorkflow(options, {
-	operationId: "createBranchWithCompute",
-	id: "create_branch_with_compute",
-	title: "Create branch with compute",
-	description: "Create a branch with a read-write endpoint and return its connection string. Use this instead of create_project_branch when the next step needs to connect: create_project_branch omits compute unless you pass endpoints, and it does not wait or return a connection string. The call waits until the compute is ready, up to five minutes by default.",
-	inputSchema: createBranchWithComputeInputSchema,
-	annotations: writeAnnotations,
-	requiresApproval: true,
-	metadata: {
-		method: "POST",
-		path: "/projects/{project_id}/branches",
-		stability: "stable",
-		deprecated: false,
-		tags: ["Branch"]
-	}
-}, (neon, input, signal) => neon.branches.createWithCompute(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
-	}
-}, {
-	signal,
-	...input.pooled === void 0 ? {} : { pooled: input.pooled }
-}));
-const createProjectAndConnectTool = (options) => bindWorkflow(options, {
-	operationId: "createProjectAndConnect",
-	id: "create_project_and_connect",
-	title: "Create project and connect",
-	description: "Create a project and return a connection string to its default branch. Use this instead of create_project when the next step needs to connect. The call waits until the default compute is ready, up to five minutes by default.",
-	inputSchema: createProjectAndConnectInputSchema,
-	annotations: writeAnnotations,
-	requiresApproval: true,
-	metadata: {
-		method: "POST",
-		path: "/projects",
-		stability: "stable",
-		deprecated: false,
-		tags: ["Project"]
-	}
-}, (neon, input, signal) => {
-	const { pooled, ...project } = input;
-	return neon.projects.createAndConnect(project, {
-		signal,
-		...pooled === void 0 ? {} : { pooled }
-	});
-});
-const workflowFactories = {
-	createBranchWithCompute: createBranchWithComputeTool,
-	createProjectAndConnect: createProjectAndConnectTool
-};
-const isNeonWorkflowId = (id) => workflowIds.includes(id);
-const workflowFactoryFor = (workflowId) => {
-	const knownWorkflowId = workflowIds.find((candidate) => candidate === workflowId);
-	if (knownWorkflowId === void 0) throw new TypeError(`Unknown Neon workflow "${workflowId}".`);
-	return workflowFactories[knownWorkflowId];
-};
-//#endregion
-export { createBranchWithComputeInputSchema, createProjectAndConnectInputSchema, isNeonWorkflowId, workflowFactories, workflowFactoryFor, workflowIds };