archetype-engine 2.0.0

package/dist/src/ai/adapters/vercel.d.ts

@@ -0,0 +1,434 @@
+/**
+ * Vercel AI SDK Adapter
+ *
+ * Converts tool definitions to Vercel AI SDK format with execute functions.
+ *
+ * @module ai/adapters/vercel
+ */
+import type { ManifestBuilder } from '../types';
+import { z } from 'zod';
+/**
+ * Field schema for Zod validation
+ */
+declare const fieldZodSchema: z.ZodObject<{
+    type: z.ZodEnum<["text", "number", "boolean", "date"]>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    unique: z.ZodOptional<z.ZodBoolean>;
+    email: z.ZodOptional<z.ZodBoolean>;
+    url: z.ZodOptional<z.ZodBoolean>;
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+    oneOf: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    integer: z.ZodOptional<z.ZodBoolean>;
+    positive: z.ZodOptional<z.ZodBoolean>;
+    default: z.ZodOptional<z.ZodUnknown>;
+    label: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "number" | "boolean" | "text" | "date";
+    email?: boolean | undefined;
+    url?: boolean | undefined;
+    oneOf?: string[] | undefined;
+    min?: number | undefined;
+    max?: number | undefined;
+    integer?: boolean | undefined;
+    positive?: boolean | undefined;
+    required?: boolean | undefined;
+    unique?: boolean | undefined;
+    default?: unknown;
+    label?: string | undefined;
+}, {
+    type: "number" | "boolean" | "text" | "date";
+    email?: boolean | undefined;
+    url?: boolean | undefined;
+    oneOf?: string[] | undefined;
+    min?: number | undefined;
+    max?: number | undefined;
+    integer?: boolean | undefined;
+    positive?: boolean | undefined;
+    required?: boolean | undefined;
+    unique?: boolean | undefined;
+    default?: unknown;
+    label?: string | undefined;
+}>;
+/**
+ * Relation schema for Zod validation
+ */
+declare const relationZodSchema: z.ZodObject<{
+    type: z.ZodEnum<["hasOne", "hasMany", "belongsToMany"]>;
+    entity: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "hasOne" | "hasMany" | "belongsToMany";
+    entity: string;
+}, {
+    type: "hasOne" | "hasMany" | "belongsToMany";
+    entity: string;
+}>;
+/**
+ * Create Vercel AI SDK tools bound to a ManifestBuilder
+ *
+ * @example
+ * ```typescript
+ * import { createManifestBuilder } from 'archetype-engine/ai'
+ * import { getVercelAITools } from 'archetype-engine/ai/adapters/vercel'
+ * import { generateText } from 'ai'
+ * import { openai } from '@ai-sdk/openai'
+ *
+ * const builder = createManifestBuilder()
+ * const tools = getVercelAITools(builder)
+ *
+ * const result = await generateText({
+ *   model: openai('gpt-4o'),
+ *   tools,
+ *   prompt: 'Create a blog with users and posts'
+ * })
+ * ```
+ */
+export declare function getVercelAITools(builder: ManifestBuilder): {
+    add_entity: {
+        description: string;
+        parameters: z.ZodObject<{
+            name: z.ZodString;
+            fields: z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodEnum<["text", "number", "boolean", "date"]>;
+                required: z.ZodOptional<z.ZodBoolean>;
+                unique: z.ZodOptional<z.ZodBoolean>;
+                email: z.ZodOptional<z.ZodBoolean>;
+                url: z.ZodOptional<z.ZodBoolean>;
+                min: z.ZodOptional<z.ZodNumber>;
+                max: z.ZodOptional<z.ZodNumber>;
+                oneOf: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                integer: z.ZodOptional<z.ZodBoolean>;
+                positive: z.ZodOptional<z.ZodBoolean>;
+                default: z.ZodOptional<z.ZodUnknown>;
+                label: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                type: "number" | "boolean" | "text" | "date";
+                email?: boolean | undefined;
+                url?: boolean | undefined;
+                oneOf?: string[] | undefined;
+                min?: number | undefined;
+                max?: number | undefined;
+                integer?: boolean | undefined;
+                positive?: boolean | undefined;
+                required?: boolean | undefined;
+                unique?: boolean | undefined;
+                default?: unknown;
+                label?: string | undefined;
+            }, {
+                type: "number" | "boolean" | "text" | "date";
+                email?: boolean | undefined;
+                url?: boolean | undefined;
+                oneOf?: string[] | undefined;
+                min?: number | undefined;
+                max?: number | undefined;
+                integer?: boolean | undefined;
+                positive?: boolean | undefined;
+                required?: boolean | undefined;
+                unique?: boolean | undefined;
+                default?: unknown;
+                label?: string | undefined;
+            }>>;
+            relations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodEnum<["hasOne", "hasMany", "belongsToMany"]>;
+                entity: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "hasOne" | "hasMany" | "belongsToMany";
+                entity: string;
+            }, {
+                type: "hasOne" | "hasMany" | "belongsToMany";
+                entity: string;
+            }>>>;
+            behaviors: z.ZodOptional<z.ZodObject<{
+                timestamps: z.ZodOptional<z.ZodBoolean>;
+                softDelete: z.ZodOptional<z.ZodBoolean>;
+                audit: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                timestamps?: boolean | undefined;
+                softDelete?: boolean | undefined;
+                audit?: boolean | undefined;
+            }, {
+                timestamps?: boolean | undefined;
+                softDelete?: boolean | undefined;
+                audit?: boolean | undefined;
+            }>>;
+            protected: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["write", "all"]>]>>;
+        }, "strip", z.ZodTypeAny, {
+            fields: Record<string, {
+                type: "number" | "boolean" | "text" | "date";
+                email?: boolean | undefined;
+                url?: boolean | undefined;
+                oneOf?: string[] | undefined;
+                min?: number | undefined;
+                max?: number | undefined;
+                integer?: boolean | undefined;
+                positive?: boolean | undefined;
+                required?: boolean | undefined;
+                unique?: boolean | undefined;
+                default?: unknown;
+                label?: string | undefined;
+            }>;
+            name: string;
+            protected?: boolean | "write" | "all" | undefined;
+            relations?: Record<string, {
+                type: "hasOne" | "hasMany" | "belongsToMany";
+                entity: string;
+            }> | undefined;
+            behaviors?: {
+                timestamps?: boolean | undefined;
+                softDelete?: boolean | undefined;
+                audit?: boolean | undefined;
+            } | undefined;
+        }, {
+            fields: Record<string, {
+                type: "number" | "boolean" | "text" | "date";
+                email?: boolean | undefined;
+                url?: boolean | undefined;
+                oneOf?: string[] | undefined;
+                min?: number | undefined;
+                max?: number | undefined;
+                integer?: boolean | undefined;
+                positive?: boolean | undefined;
+                required?: boolean | undefined;
+                unique?: boolean | undefined;
+                default?: unknown;
+                label?: string | undefined;
+            }>;
+            name: string;
+            protected?: boolean | "write" | "all" | undefined;
+            relations?: Record<string, {
+                type: "hasOne" | "hasMany" | "belongsToMany";
+                entity: string;
+            }> | undefined;
+            behaviors?: {
+                timestamps?: boolean | undefined;
+                softDelete?: boolean | undefined;
+                audit?: boolean | undefined;
+            } | undefined;
+        }>;
+        execute: (params: {
+            name: string;
+            fields: Record<string, z.infer<typeof fieldZodSchema>>;
+            relations?: Record<string, z.infer<typeof relationZodSchema>>;
+            behaviors?: {
+                timestamps?: boolean;
+                softDelete?: boolean;
+                audit?: boolean;
+            };
+            protected?: boolean | "write" | "all";
+        }) => Promise<import("../types").ToolResult>;
+    };
+    update_entity: {
+        description: string;
+        parameters: z.ZodObject<{
+            name: z.ZodString;
+            fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodOptional<z.ZodEnum<["text", "number", "boolean", "date"]>>;
+                required: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+                unique: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+                email: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+                url: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+                min: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+                max: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+                oneOf: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+                integer: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+                positive: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+                default: z.ZodOptional<z.ZodOptional<z.ZodUnknown>>;
+                label: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            }, "strip", z.ZodTypeAny, {
+                email?: boolean | undefined;
+                url?: boolean | undefined;
+                oneOf?: string[] | undefined;
+                min?: number | undefined;
+                max?: number | undefined;
+                integer?: boolean | undefined;
+                positive?: boolean | undefined;
+                type?: "number" | "boolean" | "text" | "date" | undefined;
+                required?: boolean | undefined;
+                unique?: boolean | undefined;
+                default?: unknown;
+                label?: string | undefined;
+            }, {
+                email?: boolean | undefined;
+                url?: boolean | undefined;
+                oneOf?: string[] | undefined;
+                min?: number | undefined;
+                max?: number | undefined;
+                integer?: boolean | undefined;
+                positive?: boolean | undefined;
+                type?: "number" | "boolean" | "text" | "date" | undefined;
+                required?: boolean | undefined;
+                unique?: boolean | undefined;
+                default?: unknown;
+                label?: string | undefined;
+            }>>>;
+            relations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodEnum<["hasOne", "hasMany", "belongsToMany"]>;
+                entity: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "hasOne" | "hasMany" | "belongsToMany";
+                entity: string;
+            }, {
+                type: "hasOne" | "hasMany" | "belongsToMany";
+                entity: string;
+            }>>>;
+            behaviors: z.ZodOptional<z.ZodObject<{
+                timestamps: z.ZodOptional<z.ZodBoolean>;
+                softDelete: z.ZodOptional<z.ZodBoolean>;
+                audit: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                timestamps?: boolean | undefined;
+                softDelete?: boolean | undefined;
+                audit?: boolean | undefined;
+            }, {
+                timestamps?: boolean | undefined;
+                softDelete?: boolean | undefined;
+                audit?: boolean | undefined;
+            }>>;
+            protected: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["write", "all"]>]>>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            fields?: Record<string, {
+                email?: boolean | undefined;
+                url?: boolean | undefined;
+                oneOf?: string[] | undefined;
+                min?: number | undefined;
+                max?: number | undefined;
+                integer?: boolean | undefined;
+                positive?: boolean | undefined;
+                type?: "number" | "boolean" | "text" | "date" | undefined;
+                required?: boolean | undefined;
+                unique?: boolean | undefined;
+                default?: unknown;
+                label?: string | undefined;
+            }> | undefined;
+            protected?: boolean | "write" | "all" | undefined;
+            relations?: Record<string, {
+                type: "hasOne" | "hasMany" | "belongsToMany";
+                entity: string;
+            }> | undefined;
+            behaviors?: {
+                timestamps?: boolean | undefined;
+                softDelete?: boolean | undefined;
+                audit?: boolean | undefined;
+            } | undefined;
+        }, {
+            name: string;
+            fields?: Record<string, {
+                email?: boolean | undefined;
+                url?: boolean | undefined;
+                oneOf?: string[] | undefined;
+                min?: number | undefined;
+                max?: number | undefined;
+                integer?: boolean | undefined;
+                positive?: boolean | undefined;
+                type?: "number" | "boolean" | "text" | "date" | undefined;
+                required?: boolean | undefined;
+                unique?: boolean | undefined;
+                default?: unknown;
+                label?: string | undefined;
+            }> | undefined;
+            protected?: boolean | "write" | "all" | undefined;
+            relations?: Record<string, {
+                type: "hasOne" | "hasMany" | "belongsToMany";
+                entity: string;
+            }> | undefined;
+            behaviors?: {
+                timestamps?: boolean | undefined;
+                softDelete?: boolean | undefined;
+                audit?: boolean | undefined;
+            } | undefined;
+        }>;
+        execute: (params: {
+            name: string;
+            fields?: Record<string, Partial<z.infer<typeof fieldZodSchema>>>;
+            relations?: Record<string, z.infer<typeof relationZodSchema>>;
+            behaviors?: {
+                timestamps?: boolean;
+                softDelete?: boolean;
+                audit?: boolean;
+            };
+            protected?: boolean | "write" | "all";
+        }) => Promise<import("../types").ToolResult>;
+    };
+    remove_entity: {
+        description: string;
+        parameters: z.ZodObject<{
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+        }, {
+            name: string;
+        }>;
+        execute: (params: {
+            name: string;
+        }) => Promise<import("../types").ToolResult>;
+    };
+    set_database: {
+        description: string;
+        parameters: z.ZodObject<{
+            type: z.ZodEnum<["sqlite", "postgres", "mysql"]>;
+            file: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type: "sqlite" | "postgres" | "mysql";
+            url?: string | undefined;
+            file?: string | undefined;
+        }, {
+            type: "sqlite" | "postgres" | "mysql";
+            url?: string | undefined;
+            file?: string | undefined;
+        }>;
+        execute: (params: {
+            type: "sqlite" | "postgres" | "mysql";
+            file?: string;
+            url?: string;
+        }) => Promise<import("../types").ToolResult>;
+    };
+    set_auth: {
+        description: string;
+        parameters: z.ZodObject<{
+            enabled: z.ZodBoolean;
+            providers: z.ZodOptional<z.ZodArray<z.ZodEnum<["credentials", "google", "github", "discord"]>, "many">>;
+            sessionStrategy: z.ZodOptional<z.ZodEnum<["jwt", "database"]>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            providers?: ("credentials" | "google" | "github" | "discord")[] | undefined;
+            sessionStrategy?: "database" | "jwt" | undefined;
+        }, {
+            enabled: boolean;
+            providers?: ("credentials" | "google" | "github" | "discord")[] | undefined;
+            sessionStrategy?: "database" | "jwt" | undefined;
+        }>;
+        execute: (params: {
+            enabled: boolean;
+            providers?: ("credentials" | "google" | "github" | "discord")[];
+            sessionStrategy?: "jwt" | "database";
+        }) => Promise<import("../types").ToolResult>;
+    };
+    validate: {
+        description: string;
+        parameters: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+        execute: () => Promise<{
+            success: boolean;
+            message: string;
+            errors: import("../..").ValidationError[];
+            warnings: import("../..").ValidationError[];
+        }>;
+    };
+    generate: {
+        description: string;
+        parameters: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+        execute: () => Promise<{
+            success: boolean;
+            message: string;
+            files: string[];
+            errors: string[] | undefined;
+        }>;
+    };
+};
+/**
+ * Convenience type for the tools object
+ */
+export type VercelAITools = ReturnType<typeof getVercelAITools>;
+export {};
+//# sourceMappingURL=vercel.d.ts.map

package/dist/src/ai/adapters/vercel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vercel.d.ts","sourceRoot":"","sources":["../../../../src/ai/adapters/vercel.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE/C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;GAEG;AACH,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAalB,CAAA;AAEF;;GAEG;AACH,QAAA,MAAM,iBAAiB;;;;;;;;;EAGrB,CAAA;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAiB3B;YACtB,IAAI,EAAE,MAAM,CAAA;YACZ,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC,CAAA;YACtD,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC,CAAA;YAC7D,SAAS,CAAC,EAAE;gBAAE,UAAU,CAAC,EAAE,OAAO,CAAC;gBAAC,UAAU,CAAC,EAAE,OAAO,CAAC;gBAAC,KAAK,CAAC,EAAE,OAAO,CAAA;aAAE,CAAA;YAC3E,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,KAAK,CAAA;SACtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAqBuB;YACtB,IAAI,EAAE,MAAM,CAAA;YACZ,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC,CAAC,CAAA;YAChE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC,CAAA;YAC7D,SAAS,CAAC,EAAE;gBAAE,UAAU,CAAC,EAAE,OAAO,CAAC;gBAAC,UAAU,CAAC,EAAE,OAAO,CAAC;gBAAC,KAAK,CAAC,EAAE,OAAO,CAAA;aAAE,CAAA;YAC3E,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,KAAK,CAAA;SACtC;;;;;;;;;;;0BAWuB;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE;;;;;;;;;;;;;;;;;0BAahB;YAAE,IAAI,EAAE,QAAQ,GAAG,UAAU,GAAG,OAAO,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,CAAC;YAAC,GAAG,CAAC,EAAE,MAAM,CAAA;SAAE;;;;;;;;;;;;;;;;;0BAatE;YACtB,OAAO,EAAE,OAAO,CAAA;YAChB,SAAS,CAAC,EAAE,CAAC,aAAa,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC,EAAE,CAAA;YAC/D,eAAe,CAAC,EAAE,KAAK,GAAG,UAAU,CAAA;SACrC;;;;;;;;;;;;;;;;;;;;;;EAoCN;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

package/dist/src/ai/adapters/vercel.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * Vercel AI SDK Adapter
+ *
+ * Converts tool definitions to Vercel AI SDK format with execute functions.
+ *
+ * @module ai/adapters/vercel
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVercelAITools = getVercelAITools;
+const tools_1 = require("../tools");
+const zod_1 = require("zod");
+/**
+ * Field schema for Zod validation
+ */
+const fieldZodSchema = zod_1.z.object({
+    type: zod_1.z.enum(['text', 'number', 'boolean', 'date']),
+    required: zod_1.z.boolean().optional(),
+    unique: zod_1.z.boolean().optional(),
+    email: zod_1.z.boolean().optional(),
+    url: zod_1.z.boolean().optional(),
+    min: zod_1.z.number().optional(),
+    max: zod_1.z.number().optional(),
+    oneOf: zod_1.z.array(zod_1.z.string()).optional(),
+    integer: zod_1.z.boolean().optional(),
+    positive: zod_1.z.boolean().optional(),
+    default: zod_1.z.unknown().optional(),
+    label: zod_1.z.string().optional(),
+});
+/**
+ * Relation schema for Zod validation
+ */
+const relationZodSchema = zod_1.z.object({
+    type: zod_1.z.enum(['hasOne', 'hasMany', 'belongsToMany']),
+    entity: zod_1.z.string(),
+});
+/**
+ * Create Vercel AI SDK tools bound to a ManifestBuilder
+ *
+ * @example
+ * ```typescript
+ * import { createManifestBuilder } from 'archetype-engine/ai'
+ * import { getVercelAITools } from 'archetype-engine/ai/adapters/vercel'
+ * import { generateText } from 'ai'
+ * import { openai } from '@ai-sdk/openai'
+ *
+ * const builder = createManifestBuilder()
+ * const tools = getVercelAITools(builder)
+ *
+ * const result = await generateText({
+ *   model: openai('gpt-4o'),
+ *   tools,
+ *   prompt: 'Create a blog with users and posts'
+ * })
+ * ```
+ */
+function getVercelAITools(builder) {
+    return {
+        add_entity: {
+            description: tools_1.toolDefinitions.add_entity.description,
+            parameters: zod_1.z.object({
+                name: zod_1.z.string().describe('Entity name in PascalCase'),
+                fields: zod_1.z.record(fieldZodSchema).describe('Field definitions'),
+                relations: zod_1.z.record(relationZodSchema).optional().describe('Relation definitions'),
+                behaviors: zod_1.z
+                    .object({
+                    timestamps: zod_1.z.boolean().optional(),
+                    softDelete: zod_1.z.boolean().optional(),
+                    audit: zod_1.z.boolean().optional(),
+                })
+                    .optional(),
+                protected: zod_1.z.union([zod_1.z.boolean(), zod_1.z.enum(['write', 'all'])]).optional(),
+            }),
+            execute: async (params) => {
+                const result = builder.addEntity(params);
+                return result;
+            },
+        },
+        update_entity: {
+            description: tools_1.toolDefinitions.update_entity.description,
+            parameters: zod_1.z.object({
+                name: zod_1.z.string().describe('Entity name to update'),
+                fields: zod_1.z.record(fieldZodSchema.partial()).optional(),
+                relations: zod_1.z.record(relationZodSchema).optional(),
+                behaviors: zod_1.z
+                    .object({
+                    timestamps: zod_1.z.boolean().optional(),
+                    softDelete: zod_1.z.boolean().optional(),
+                    audit: zod_1.z.boolean().optional(),
+                })
+                    .optional(),
+                protected: zod_1.z.union([zod_1.z.boolean(), zod_1.z.enum(['write', 'all'])]).optional(),
+            }),
+            execute: async (params) => {
+                const result = builder.updateEntity(params);
+                return result;
+            },
+        },
+        remove_entity: {
+            description: tools_1.toolDefinitions.remove_entity.description,
+            parameters: zod_1.z.object({
+                name: zod_1.z.string().describe('Entity name to remove'),
+            }),
+            execute: async (params) => {
+                const result = builder.removeEntity(params);
+                return result;
+            },
+        },
+        set_database: {
+            description: tools_1.toolDefinitions.set_database.description,
+            parameters: zod_1.z.object({
+                type: zod_1.z.enum(['sqlite', 'postgres', 'mysql']),
+                file: zod_1.z.string().optional().describe('SQLite file path'),
+                url: zod_1.z.string().optional().describe('Connection URL for Postgres/MySQL'),
+            }),
+            execute: async (params) => {
+                const result = builder.setDatabase(params);
+                return result;
+            },
+        },
+        set_auth: {
+            description: tools_1.toolDefinitions.set_auth.description,
+            parameters: zod_1.z.object({
+                enabled: zod_1.z.boolean(),
+                providers: zod_1.z.array(zod_1.z.enum(['credentials', 'google', 'github', 'discord'])).optional(),
+                sessionStrategy: zod_1.z.enum(['jwt', 'database']).optional(),
+            }),
+            execute: async (params) => {
+                const result = builder.setAuth(params);
+                return result;
+            },
+        },
+        validate: {
+            description: tools_1.toolDefinitions.validate.description,
+            parameters: zod_1.z.object({}),
+            execute: async () => {
+                const result = builder.validate();
+                return {
+                    success: result.valid,
+                    message: result.valid ? 'Manifest is valid' : `Found ${result.errors.length} error(s)`,
+                    errors: result.errors,
+                    warnings: result.warnings,
+                };
+            },
+        },
+        generate: {
+            description: tools_1.toolDefinitions.generate.description,
+            parameters: zod_1.z.object({}),
+            execute: async () => {
+                const result = await builder.generate();
+                return {
+                    success: result.success,
+                    message: result.success
+                        ? `Generated ${result.files.length} files`
+                        : `Generation failed: ${result.errors?.join(', ')}`,
+                    files: result.files.map(f => f.path),
+                    errors: result.errors,
+                };
+            },
+        },
+    };
+}