@purpleschool/gptbot 0.12.98-stage-2 → 0.12.98

package/build/models/canvas-template.schema.js

@@ -1,19 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CanvasTemplateSchema = exports.CanvasTemplateGraphSchema = void 0;
+exports.GeneratedCanvasTemplateSchema = exports.CanvasTemplateSchema = exports.CanvasTemplateTagSchema = exports.CanvasTemplateGraphSchema = void 0;
 const zod_1 = require("zod");
 const constants_1 = require("../constants");
 const canvas_node_schema_1 = require("./canvas-node.schema");
-const CanvasTemplateGraphNodeSchema = zod_1.z.object({
+const CanvasTemplateGraphNodeSchema = zod_1.z
+    .object({
     uuid: zod_1.z.string().trim().min(1),
     nodeDefinitionId: zod_1.z.nativeEnum(constants_1.CANVAS_NODE_TYPE),
     position: canvas_node_schema_1.CanvasNodePositionSchema,
-    params: canvas_node_schema_1.CanvasNodeParamsSchema.nullable().optional(),
+    params: zod_1.z.unknown().nullable().optional(),
+})
+    .superRefine((node, ctx) => {
+    (0, canvas_node_schema_1.validateCanvasNodeParamsByType)(node.nodeDefinitionId, node.params, ctx);
 });
 const CanvasTemplateGraphEdgeSchema = zod_1.z.object({
     sourceId: zod_1.z.string().trim().min(1),
     targetId: zod_1.z.string().trim().min(1),
-    handle: zod_1.z.nativeEnum(constants_1.INPUT_OUTPUT_TYPE),
+    sourceHandle: zod_1.z.nativeEnum(constants_1.INPUT_OUTPUT_TYPE),
+    targetHandle: zod_1.z.nativeEnum(constants_1.INPUT_OUTPUT_TYPE),
 });
 exports.CanvasTemplateGraphSchema = zod_1.z
     .object({
@@ -50,14 +55,29 @@ exports.CanvasTemplateGraphSchema = zod_1.z
         }
     }
 });
+exports.CanvasTemplateTagSchema = zod_1.z.object({
+    icons: zod_1.z.object({
+        svg: zod_1.z.string(),
+        png: zod_1.z.string(),
+    }),
+    alias: zod_1.z.string().trim().min(1),
+    title: zod_1.z.string().trim().min(1),
+});
 exports.CanvasTemplateSchema = zod_1.z.object({
     uuid: zod_1.z.string().uuid(),
     name: zod_1.z.string(),
     description: zod_1.z.string().nullable(),
-    userId: zod_1.z.string().uuid().nullable(),
+    isPopular: zod_1.z.boolean(),
     previewImageUrl: zod_1.z.string().url().nullable(),
-    tags: zod_1.z.array(zod_1.z.string()),
+    tags: zod_1.z.array(exports.CanvasTemplateTagSchema),
     graph: exports.CanvasTemplateGraphSchema,
     createdAt: zod_1.z.date(),
     updatedAt: zod_1.z.date(),
 });
+exports.GeneratedCanvasTemplateSchema = zod_1.z.object({
+    name: zod_1.z.string().trim().min(1),
+    description: zod_1.z.string().trim().min(1),
+    previewImageUrl: zod_1.z.string().url().nullable(),
+    tags: zod_1.z.array(exports.CanvasTemplateTagSchema),
+    graph: exports.CanvasTemplateGraphSchema,
+});

package/build/models/canvas.schema.js

@@ -2,12 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CanvasSchema = void 0;
 const zod_1 = require("zod");
-const constants_1 = require("../constants");
 exports.CanvasSchema = zod_1.z.object({
     uuid: zod_1.z.string().uuid(),
     name: zod_1.z.string(),
     userId: zod_1.z.string().uuid(),
-    status: zod_1.z.nativeEnum(constants_1.CANVAS_STATUS),
     createdAt: zod_1.z.date(),
     updatedAt: zod_1.z.date(),
 });

package/build/models/index.js

@@ -66,6 +66,8 @@ __exportStar(require("./tool-group.schema"), exports);
 __exportStar(require("./tool.schema"), exports);
 __exportStar(require("./unlocked-by-subscription.schema"), exports);
 __exportStar(require("./unregistered-user.schema"), exports);
+__exportStar(require("./update-post.schema"), exports);
+__exportStar(require("./update-post-translation.schema"), exports);
 __exportStar(require("./user-task.schema"), exports);
 __exportStar(require("./user-to-product.schema"), exports);
 __exportStar(require("./user-to-subscription.schema"), exports);

package/build/models/post.schema.js

@@ -7,7 +7,7 @@ exports.PostSchema = zod_1.z.object({
     uuid: zod_1.z.string().uuid(),
     title: zod_1.z.string(),
     alias: zod_1.z.string(),
-    image: zod_1.z.string(),
+    image: zod_1.z.nullable(zod_1.z.string()),
     content: zod_1.z.string(),
     author: zod_1.z.string(),
     contentPreview: zod_1.z.nullable(zod_1.z.string()),

package/build/models/tools/marketplace-card/index.js

@@ -15,4 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./marketplace-card-config.schema"), exports);
+__exportStar(require("./marketplace-card-description-generation.schema"), exports);
 __exportStar(require("./marketplace-card-job.schema"), exports);

package/build/models/tools/marketplace-card/marketplace-card-description-generation.schema.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarketplaceCardDescriptionGenerationSchema = void 0;
+const constants_1 = require("../../../constants");
+const zod_1 = require("zod");
+exports.MarketplaceCardDescriptionGenerationSchema = zod_1.z.object({
+    uuid: zod_1.z.string().uuid(),
+    status: zod_1.z.nativeEnum(constants_1.TOOL_JOB_STATUS),
+    title: zod_1.z.string().nullable(),
+    subtitle: zod_1.z.string().nullable(),
+    advantages: zod_1.z.array(zod_1.z.string()),
+    tags: zod_1.z.array(zod_1.z.string()),
+    backgroundDescription: zod_1.z.string().nullable(),
+    price: zod_1.z.number(),
+});

package/build/models/tools/video/video-job.schema.js

@@ -22,6 +22,7 @@ exports.VideoJobSchema = tool_job_schema_1.ToolJobSchema.extend({
     title: zod_1.z.string(),
     prompt: zod_1.z.string(),
     reaction: zod_1.z.nativeEnum(constants_1.USER_REACTION).nullable(),
+    publishModerationStatus: zod_1.z.nativeEnum(constants_1.VIDEO_PUBLISH_MODERATION_STATUS),
     videoUrl: zod_1.z.string().nullable(),
     video: zod_1.z
         .object({

package/build/models/update-post-translation.schema.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdatePostTranslationSchema = void 0;
+const rugpt_lib_common_1 = require("@purpleschool/rugpt-lib-common");
+const zod_1 = require("zod");
+exports.UpdatePostTranslationSchema = zod_1.z.object({
+    uuid: zod_1.z.string().uuid(),
+    updatePostId: zod_1.z.string().uuid(),
+    locale: zod_1.z.nativeEnum(rugpt_lib_common_1.LOCALE),
+    title: zod_1.z.string(),
+    description: zod_1.z.string(),
+    image: zod_1.z.string(),
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+});

package/build/models/update-post.schema.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdatePostSchema = void 0;
+const zod_1 = require("zod");
+exports.UpdatePostSchema = zod_1.z.object({
+    uuid: zod_1.z.string().uuid(),
+    slug: zod_1.z.string(),
+    title: zod_1.z.string(),
+    description: zod_1.z.string(),
+    image: zod_1.z.string(),
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+});

package/commands/{canvas → ai-studio/canvas}/create-canvas.command.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { CanvasSchema } from '../../models';
+import { CanvasSchema } from '../../../models';
 
 export namespace CreateCanvasCommand {
     export const RequestSchema = z.object({

package/commands/{canvas → ai-studio/canvas}/delete-canvas.command.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { CanvasSchema } from '../../models';
+import { CanvasSchema } from '../../../models';
 
 export namespace DeleteCanvasCommand {
     export const RequestSchema = CanvasSchema.pick({

package/commands/ai-studio/canvas/execute-graph-by-node.command.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { CanvasNodeSchema, CanvasSchema } from '../../../models';
+
+export namespace ExecuteGraphByNodeCommand {
+    export const RequestParamSchema = CanvasSchema.pick({
+        uuid: true,
+    });
+
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const RequestSchema = z.object({
+        executableNodeId: z.string().uuid(),
+    });
+
+    export const ResponseSchema = z.object({
+        data: CanvasNodeSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/{canvas → ai-studio/canvas}/find-canvas-by-uuid-with-relations.query.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { CanvasEdgeSchema, CanvasNodeSchema, CanvasSchema } from '../../models';
+import { CanvasEdgeSchema, CanvasNodeSchema, CanvasSchema } from '../../../models';
 
 export namespace FindCanvasByUuidWithRelationsQuery {
     export const RequestSchema = CanvasSchema.pick({

package/commands/{canvas → ai-studio/canvas}/find-canvas-by-uuid.query.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { CanvasSchema } from '../../models';
+import { CanvasSchema } from '../../../models';
 
 export namespace FindCanvasByUuidQuery {
     export const RequestSchema = CanvasSchema.pick({

package/commands/{canvas → ai-studio/canvas}/find-canvases-by-user.query.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { CanvasSchema } from '../../models';
+import { CanvasSchema } from '../../../models';
 
 export namespace FindCanvasesByUserQuery {
     export const RequestSchema = z.object({
@@ -11,7 +11,7 @@ export namespace FindCanvasesByUserQuery {
     export type Request = z.infer<typeof RequestSchema>;
 
     export const ResponseSchema = z.object({
-        data: z.array(CanvasSchema),
+        data: z.array(CanvasSchema.extend({ countOfNodes: z.number() })),
         page: z.number(),
         totalPages: z.number(),
     });

package/commands/ai-studio/canvas/get-price.query.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { CANVAS_NODE_TYPE, TOOL_CONTENT_TYPE } from '../../../constants';
+import { CanvasSchema } from '../../../models';
+
+export namespace PriceCanvasQuery {
+    export const RequestParamSchema = CanvasSchema.pick({
+        uuid: true,
+    });
+
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const QueryParamsSchema = z.object({
+        executableNodeId: z.string().uuid().optional(),
+    });
+
+    export type QueryParams = z.infer<typeof QueryParamsSchema>;
+
+    export const NodePriceSchema = z.object({
+        nodeId: z.string().uuid(),
+        nodeType: z.nativeEnum(CANVAS_NODE_TYPE),
+        toolType: z.nativeEnum(TOOL_CONTENT_TYPE).nullable(),
+        price: z.number(),
+        charSunlinPriceIncrease: z.number().nullable().optional(),
+        charSunlinPriceDecrease: z.number().nullable().optional(),
+        forecasted: z.boolean(),
+        static: z.boolean(),
+    });
+
+    export type NodePrice = z.infer<typeof NodePriceSchema>;
+
+    export const ResponseSchema = z.object({
+        price: z.number(),
+        nodes: z.array(NodePriceSchema),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/{canvas → ai-studio/canvas}/index.ts

@@ -6,3 +6,5 @@ export * from './find-canvases-by-user.query';
 export * from './run-canvas.command';
 export * from './save-canvas.command';
 export * from './update-canvas.command';
+export * from './execute-graph-by-node.command';
+export * from './get-price.query';

package/commands/{canvas → ai-studio/canvas}/run-canvas.command.ts

@@ -1,6 +1,5 @@
 import { z } from 'zod';
-import { CanvasEdgeSchema, CanvasNodeSchema, CanvasSchema } from '../../models';
-import { SaveCanvasCommand } from './save-canvas.command';
+import { CanvasEdgeSchema, CanvasNodeSchema, CanvasSchema } from '../../../models';
 
 export namespace RunCanvasCommand {
     export const RequestParamSchema = CanvasSchema.pick({
@@ -9,17 +8,6 @@ export namespace RunCanvasCommand {
 
     export type RequestParam = z.infer<typeof RequestParamSchema>;
 
-    export const RequestSchema = z.object({
-        updatedAt: z.preprocess(
-            (value) => (typeof value === 'string' ? new Date(value) : value),
-            z.date(),
-        ),
-        nodes: z.array(SaveCanvasCommand.CanvasNodePayloadSchema),
-        edges: z.array(SaveCanvasCommand.CanvasEdgePayloadSchema),
-    });
-
-    export type Request = z.infer<typeof RequestSchema>;
-
     export const ResponseSchema = z.object({
         data: CanvasSchema.extend({
             nodes: z.array(CanvasNodeSchema),

package/commands/{canvas → ai-studio/canvas}/save-canvas.command.ts

@@ -1,12 +1,12 @@
 import { z } from 'zod';
-import { CANVAS_NODE_TYPE, INPUT_OUTPUT_TYPE } from '../../constants';
+import { CANVAS_NODE_TYPE, INPUT_OUTPUT_TYPE } from '../../../constants';
 import {
     CanvasEdgeSchema,
-    CanvasNodeParamsSchema,
     CanvasNodePositionSchema,
     CanvasNodeSchema,
     CanvasSchema,
-} from '../../models';
+    validateCanvasNodeParamsByType,
+} from '../../../models';
 
 export namespace SaveCanvasCommand {
     export const RequestParamSchema = CanvasSchema.pick({
@@ -15,17 +15,22 @@ export namespace SaveCanvasCommand {
 
     export type RequestParam = z.infer<typeof RequestParamSchema>;
 
-    export const CanvasNodePayloadSchema = z.object({
-        uuid: z.string().uuid(),
-        nodeDefinitionId: z.nativeEnum(CANVAS_NODE_TYPE),
-        position: CanvasNodePositionSchema,
-        params: CanvasNodeParamsSchema.nullable().optional(),
-    });
+    export const CanvasNodePayloadSchema = z
+        .object({
+            uuid: z.string().uuid(),
+            nodeDefinitionId: z.nativeEnum(CANVAS_NODE_TYPE),
+            position: CanvasNodePositionSchema,
+            params: z.unknown().nullable().optional(),
+        })
+        .superRefine((node, ctx) => {
+            validateCanvasNodeParamsByType(node.nodeDefinitionId, node.params, ctx);
+        });
 
     export const CanvasEdgePayloadSchema = z.object({
         sourceId: z.string().uuid(),
         targetId: z.string().uuid(),
-        handle: z.nativeEnum(INPUT_OUTPUT_TYPE),
+        sourceHandle: z.nativeEnum(INPUT_OUTPUT_TYPE),
+        targetHandle: z.nativeEnum(INPUT_OUTPUT_TYPE),
     });
 
     export const RequestSchema = z.object({

package/commands/{canvas → ai-studio/canvas}/update-canvas.command.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { CanvasSchema } from '../../models';
+import { CanvasSchema } from '../../../models';
 
 export namespace UpdateCanvasCommand {
     export const RequestParamSchema = CanvasSchema.pick({

package/commands/{canvas-edge → ai-studio/canvas-edge}/create-canvas-edge.command.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { INPUT_OUTPUT_TYPE } from '../../constants';
-import { CanvasEdgeSchema } from '../../models';
+import { INPUT_OUTPUT_TYPE } from '../../../constants';
+import { CanvasEdgeSchema } from '../../../models';
 
 export namespace CreateCanvasEdgeCommand {
     export const RequestParamSchema = z.object({
@@ -12,7 +12,8 @@ export namespace CreateCanvasEdgeCommand {
     export const RequestSchema = z.object({
         sourceId: z.string().uuid(),
         targetId: z.string().uuid(),
-        handle: z.nativeEnum(INPUT_OUTPUT_TYPE),
+        sourceHandle: z.nativeEnum(INPUT_OUTPUT_TYPE),
+        targetHandle: z.nativeEnum(INPUT_OUTPUT_TYPE),
     });
 
     export type Request = z.infer<typeof RequestSchema>;

package/commands/{canvas-edge → ai-studio/canvas-edge}/find-canvas-edge-by-source-and-target.query.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { CanvasEdgeSchema } from '../../models';
+import { CanvasEdgeSchema } from '../../../models';
 
 export namespace FindCanvasEdgeBySourceAndTargetQuery {
     export const RequestParamSchema = z.object({

package/commands/{canvas-edge → ai-studio/canvas-edge}/find-canvas-edges-by-canvas.query.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { CanvasEdgeSchema } from '../../models';
+import { CanvasEdgeSchema } from '../../../models';
 
 export namespace FindCanvasEdgesByCanvasQuery {
     export const RequestParamSchema = z.object({

package/commands/ai-studio/canvas-node/count-canvas-nodes-by-canvas.query.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+
+export namespace CountCanvasNodesByCanvasQuery {
+    export const RequestSchema = z.object({
+        canvasIds: z.array(z.string().uuid()),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(
+            z.object({
+                canvasId: z.string().uuid(),
+                countOfNodes: z.number(),
+            }),
+        ),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/ai-studio/canvas-node/create-canvas-node.command.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { CANVAS_NODE_TYPE } from '../../../constants';
+import {
+    CanvasNodePositionSchema,
+    CanvasNodeSchema,
+    validateCanvasNodeParamsByType,
+} from '../../../models';
+
+export namespace CreateCanvasNodeCommand {
+    export const RequestParamSchema = z.object({
+        canvasId: z.string().uuid(),
+    });
+
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const RequestSchema = z
+        .object({
+            nodeDefinitionId: z.nativeEnum(CANVAS_NODE_TYPE),
+            position: CanvasNodePositionSchema,
+            params: z.unknown().nullable(),
+        })
+        .superRefine((request, ctx) => {
+            validateCanvasNodeParamsByType(request.nodeDefinitionId, request.params, ctx);
+        });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: CanvasNodeSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/{canvas-node → ai-studio/canvas-node}/delete-canvas-node.command.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
-import { CanvasNodeSchema } from '../../models';
+import { CanvasNodeBaseSchema } from '../../../models';
 
 export namespace DeleteCanvasNodeCommand {
-    export const RequestParamSchema = CanvasNodeSchema.pick({
+    export const RequestParamSchema = CanvasNodeBaseSchema.pick({
         canvasId: true,
         uuid: true,
     });

package/commands/{canvas-node → ai-studio/canvas-node}/find-canvas-node-by-uuid.query.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
-import { CanvasNodeSchema } from '../../models';
+import { CanvasNodeBaseSchema, CanvasNodeSchema } from '../../../models';
 
 export namespace FindCanvasNodeByUuidQuery {
-    export const RequestParamSchema = CanvasNodeSchema.pick({
+    export const RequestParamSchema = CanvasNodeBaseSchema.pick({
         canvasId: true,
         uuid: true,
     });

package/commands/{canvas-node → ai-studio/canvas-node}/find-canvas-node-definitions-with-configs.query.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { CanvasNodeDefinitionsWithConfigsSchema } from '../../models';
+import { CanvasNodeDefinitionsWithConfigsSchema } from '../../../models';
 
 export namespace FindCanvasNodeDefinitionsWithConfigsQuery {
     export const ResponseSchema = z.object({

package/commands/{canvas-node → ai-studio/canvas-node}/find-canvas-nodes-by-canvas.query.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { CanvasNodeSchema } from '../../models';
+import { CanvasNodeSchema } from '../../../models';
 
 export namespace FindCanvasNodesByCanvasQuery {
     export const RequestParamSchema = z.object({

package/commands/{canvas-node → ai-studio/canvas-node}/index.ts

@@ -1,3 +1,4 @@
+export * from './count-canvas-nodes-by-canvas.query';
 export * from './create-canvas-node.command';
 export * from './delete-canvas-node.command';
 export * from './find-canvas-node-by-uuid.query';

package/commands/ai-studio/canvas-node/update-canvas-node.command.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { CANVAS_NODE_TYPE } from '../../../constants';
+import {
+    CanvasNodeBaseSchema,
+    CanvasNodePositionSchema,
+    CanvasNodeSchema,
+    validateCanvasNodeOutputByType,
+    validateCanvasNodeParamsByType,
+} from '../../../models';
+
+export namespace UpdateCanvasNodeCommand {
+    export const RequestParamSchema = CanvasNodeBaseSchema.pick({
+        canvasId: true,
+        uuid: true,
+    });
+
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const RequestSchema = z
+        .object({
+            nodeDefinitionId: z.nativeEnum(CANVAS_NODE_TYPE).optional(),
+            position: CanvasNodePositionSchema.optional(),
+            params: z.unknown().nullable().optional(),
+            output: z.unknown().nullable().optional(),
+        })
+        .superRefine((request, ctx) => {
+            if (request.nodeDefinitionId !== undefined) {
+                validateCanvasNodeParamsByType(request.nodeDefinitionId, request.params, ctx);
+                validateCanvasNodeOutputByType(request.nodeDefinitionId, request.output, ctx);
+            }
+        });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: CanvasNodeSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/ai-studio/canvas-template/create-canvas-from-generated-template.command.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import {
+    CanvasEdgeSchema,
+    CanvasNodeSchema,
+    CanvasNodePositionSchema,
+    CanvasSchema,
+    CanvasTemplateTagSchema,
+} from '../../../models';
+import { CANVAS_NODE_TYPE, INPUT_OUTPUT_TYPE } from '../../../constants';
+
+export namespace CreateCanvasFromGeneratedTemplateCommand {
+    const GeneratedTemplateInputSchema = z.object({
+        name: z.string().trim().min(1),
+        description: z.string().trim().min(1),
+        previewImageUrl: z.string().url().nullable(),
+        tags: z.array(CanvasTemplateTagSchema),
+        graph: z.object({
+            nodes: z.array(
+                z.object({
+                    uuid: z.string().trim().min(1),
+                    nodeDefinitionId: z.nativeEnum(CANVAS_NODE_TYPE),
+                    position: CanvasNodePositionSchema,
+                    params: z
+                        .object({
+                            prompt: z.string().trim().min(1),
+                            modelId: z.string().trim().min(1).optional(),
+                            modelName: z.string().trim().min(1).optional(),
+                        })
+                        .catchall(z.unknown()),
+                }),
+            ),
+            edges: z.array(
+                z.object({
+                    sourceId: z.string().trim().min(1),
+                    targetId: z.string().trim().min(1),
+                    sourceHandle: z.nativeEnum(INPUT_OUTPUT_TYPE),
+                    targetHandle: z.nativeEnum(INPUT_OUTPUT_TYPE),
+                }),
+            ),
+        }),
+    });
+
+    export const RequestSchema = z.object({
+        data: GeneratedTemplateInputSchema,
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: CanvasSchema.extend({
+            nodes: z.array(CanvasNodeSchema),
+            edges: z.array(CanvasEdgeSchema),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/{canvas-template → ai-studio/canvas-template}/create-canvas-from-template.command.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { CanvasEdgeSchema, CanvasNodeSchema, CanvasSchema } from '../../models';
+import { CanvasEdgeSchema, CanvasNodeSchema, CanvasSchema } from '../../../models';
 
 export namespace CreateCanvasFromTemplateCommand {
     export const RequestParamSchema = z.object({

package/commands/{canvas-template → ai-studio/canvas-template}/create-canvas-template.command.ts

@@ -1,12 +1,17 @@
 import { z } from 'zod';
-import { CanvasTemplateSchema, CanvasTemplateGraphSchema } from '../../models';
+import {
+    CanvasTemplateGraphSchema,
+    CanvasTemplateSchema,
+    CanvasTemplateTagSchema,
+} from '../../../models';
 
 export namespace CreateCanvasTemplateCommand {
     export const RequestSchema = z.object({
         name: z.string().trim().min(1),
         description: z.string().trim().min(1).optional().nullable(),
+        isPopular: z.boolean().optional().default(false),
         previewImageUrl: z.string().url().optional().nullable(),
-        tags: z.array(z.string().trim().min(1)).default([]),
+        tags: z.array(CanvasTemplateTagSchema).default([]),
         graph: CanvasTemplateGraphSchema,
     });
 

package/commands/{canvas-template → ai-studio/canvas-template}/delete-canvas-template.command.ts

@@ -1,8 +1,9 @@
 import { z } from 'zod';
+import { CanvasTemplateSchema } from '../../../models';
 
 export namespace DeleteCanvasTemplateCommand {
-    export const RequestParamSchema = z.object({
-        uuid: z.string().uuid(),
+    export const RequestParamSchema = CanvasTemplateSchema.pick({
+        uuid: true,
     });
 
     export type RequestParam = z.infer<typeof RequestParamSchema>;

package/commands/{canvas-template → ai-studio/canvas-template}/find-canvas-template-by-uuid.query.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { CanvasTemplateSchema } from '../../models';
+import { CanvasTemplateSchema } from '../../../models';
 
 export namespace FindCanvasTemplateByUuidQuery {
     export const RequestSchema = CanvasTemplateSchema.pick({