@purpleschool/gptbot 0.13.4 → 0.13.6

package/commands/agents/agent-channel/delete-agent-channel.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+export namespace DeleteAgentChannelCommand {
+    export const RequestParamsSchema = z.object({
+        agentId: z.string().uuid(),
+        id: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        success: z.boolean(),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-channel/find-agent-channels-catalog.command.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { ChannelSchema } from '../../../models/agents/channel.schema';
+
+export namespace FindAgentChannelsCatalogCommand {
+    export const ResponseSchema = z.object({
+        data: z.array(ChannelSchema),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-channel/find-agent-channels.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { AgentChannelSchema } from '../../../models/agents/agent-channel.schema';
+
+export namespace FindAgentChannelsCommand {
+    export const RequestParamsSchema = z.object({
+        agentId: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(AgentChannelSchema),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-channel/index.ts

@@ -0,0 +1,5 @@
+export * from './create-agent-channel.command';
+export * from './delete-agent-channel.command';
+export * from './find-agent-channels.command';
+export * from './find-agent-channels-catalog.command';
+export * from './update-agent-channel.command';

package/commands/agents/agent-channel/update-agent-channel.command.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { AGENT_CHANNEL_STATUS } from '../../../constants/agents/enums';
+import { AgentChannelCredentialsSchema } from '../../../models/agents/agent-channel-credentials.schema';
+import { AgentChannelSchema } from '../../../models/agents/agent-channel.schema';
+
+export namespace UpdateAgentChannelCommand {
+    export const RequestParamsSchema = z.object({
+        agentId: z.string().uuid(),
+        id: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestBodySchema = z.object({
+        credentials: AgentChannelCredentialsSchema.optional(),
+        status: z.nativeEnum(AGENT_CHANNEL_STATUS).optional(),
+    });
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentChannelSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}
+
+export namespace ValidateAgentChannelCommand {
+    export const RequestParamsSchema = z.object({
+        agentId: z.string().uuid(),
+        id: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentChannelSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-dialog/clear-agent-dialog-history.command.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+
+export namespace ClearAgentDialogHistoryCommand {
+    export const RequestParamsSchema = z.object({
+        dialogId: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestQuerySchema = z.object({});
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const ResponseSchema = z.object({
+        success: z.boolean(),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-dialog/find-agent-dialogs.command.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { DIALOG_STATUS } from '../../../constants/agents/enums';
+import { DialogFindResultSchema } from '../../../models/agents/dialog-find-result.schema';
+
+export namespace FindAgentDialogsCommand {
+    export const RequestQuerySchema = z.object({
+        agentId: z.string().uuid().optional(),
+        status: z.nativeEnum(DIALOG_STATUS).optional(),
+        source: z.string().optional(),
+        dateFrom: z.coerce.date().optional(),
+        dateTo: z.coerce.date().optional(),
+        limit: z.coerce.number().optional(),
+        offset: z.coerce.number().optional(),
+    });
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const ResponseSchema = z.object({
+        data: DialogFindResultSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-dialog/get-agent-dialog-by-id.command.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { DialogWithMessagesSchema } from '../../../models/agents/dialog-with-messages.schema';
+
+export namespace GetAgentDialogByIdCommand {
+    export const RequestParamsSchema = z.object({
+        id: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestQuerySchema = z.object({});
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const ResponseSchema = z.object({
+        data: DialogWithMessagesSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-dialog/index.ts

@@ -0,0 +1,7 @@
+export * from './find-agent-dialogs.command';
+export * from './get-agent-dialog-by-id.command';
+export * from './update-agent-dialog-status.command';
+export * from './clear-agent-dialog-history.command';
+export * from './send-agent-dialog-admin-reply.command';
+export * from './start-cabinet-dialog.command';
+export * from './send-cabinet-message.command';

package/commands/agents/agent-dialog/send-agent-dialog-admin-reply.command.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+
+export namespace SendAgentDialogAdminReplyCommand {
+    export const RequestParamsSchema = z.object({
+        dialogId: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestQuerySchema = z.object({});
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const RequestBodySchema = z.object({
+        text: z.string().optional(),
+        images: z.array(z.string()).default([]),
+        attachments: z.array(z.string()).optional(),
+    });
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            messageId: z.string().uuid(),
+            dialogId: z.string().uuid(),
+        }),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-dialog/send-cabinet-message.command.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+
+export namespace SendCabinetMessageCommand {
+    export const RequestParamsSchema = z.object({
+        agentId: z.string().uuid(),
+        dialogId: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestBodySchema = z
+        .object({
+            text: z.string().optional(),
+            images: z.array(z.string()).optional(),
+            attachments: z.array(z.string()).optional(),
+        })
+        .refine(
+            (data) =>
+                data.text || (data.images?.length ?? 0) > 0 || (data.attachments?.length ?? 0) > 0,
+            {
+                message: 'Message must contain text, images, or attachments',
+                path: ['text'],
+            },
+        );
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            dialogId: z.string().uuid(),
+            messageId: z.string().uuid(),
+            isNewDialog: z.boolean(),
+        }),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-dialog/start-cabinet-dialog.command.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+
+export namespace StartCabinetDialogCommand {
+    export const RequestParamsSchema = z.object({
+        agentId: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestBodySchema = z.object({
+        userMeta: z.record(z.string(), z.unknown()).optional(),
+    });
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            dialogId: z.string().uuid(),
+        }),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-dialog/update-agent-dialog-status.command.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { DIALOG_STATUS } from '../../../constants/agents/enums';
+import { DialogSchema } from '../../../models/agents/dialog.schema';
+
+export namespace UpdateAgentDialogStatusCommand {
+    export const RequestParamsSchema = z.object({
+        dialogId: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestQuerySchema = z.object({});
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const RequestBodySchema = z.object({
+        status: z.nativeEnum(DIALOG_STATUS),
+    });
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: DialogSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-document/delete-agent-document.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+export namespace DeleteAgentDocumentCommand {
+    export const RequestParamsSchema = z.object({
+        agentId: z.string().uuid(),
+        documentId: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        success: z.boolean(),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-document/find-agent-documents.command.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { AgentDocumentFindResultSchema } from '../../../models/agents/agent-document-find-result.schema';
+
+export namespace FindAgentDocumentsCommand {
+    export const RequestParamsSchema = z.object({
+        agentId: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestQuerySchema = z.object({
+        limit: z.coerce.number().optional(),
+        offset: z.coerce.number().optional(),
+    });
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentDocumentFindResultSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-document/index.ts

@@ -0,0 +1,4 @@
+export * from './find-agent-documents.command';
+export * from './search-agent-documents.command';
+export * from './delete-agent-document.command';
+export * from './upload-agent-document.command';

package/commands/agents/agent-document/search-agent-documents.command.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { AgentDocumentSearchResultSchema } from '../../../models/agents/agent-document-search-result.schema';
+
+export namespace SearchAgentDocumentsCommand {
+    export const RequestParamsSchema = z.object({
+        agentId: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestBodySchema = z.object({
+        query: z.string().min(1),
+        limit: z.coerce.number().optional(),
+        threshold: z.coerce.number().optional(),
+    });
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentDocumentSearchResultSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-document/upload-agent-document.command.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { AGENT_DOCUMENT_STATUS } from '../../../constants/agents/enums';
+
+export namespace UploadAgentDocumentCommand {
+    export const RequestParamsSchema = z.object({
+        agentId: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseDataSchema = z.object({
+        documentId: z.string().uuid(),
+        filename: z.string(),
+        status: z.nativeEnum(AGENT_DOCUMENT_STATUS),
+    });
+    export type ResponseData = z.infer<typeof ResponseDataSchema>;
+
+    export const ResponseSchema = z.object({
+        data: ResponseDataSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-lead/create-agent-lead.command.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { AgentLeadSchema } from '../../../models/agents/agent-lead.schema';
+
+export namespace CreateAgentLeadCommand {
+    export const RequestBodySchema = z.object({
+        data: z.record(z.string(), z.string()),
+        dialogId: z.string().uuid(),
+        leadFormId: z.string().uuid(),
+    });
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentLeadSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-lead/delete-agent-lead.command.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+export namespace DeleteAgentLeadCommand {
+    export const RequestParamsSchema = z.object({
+        id: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        success: z.boolean(),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-lead/find-agent-leads.command.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { AgentLeadFindResultSchema } from '../../../models/agents/agent-lead-find-result.schema';
+
+export namespace FindAgentLeadsCommand {
+    export const RequestQuerySchema = z.object({
+        dialogId: z.string().uuid().optional(),
+        limit: z.coerce.number().optional(),
+        offset: z.coerce.number().optional(),
+    });
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentLeadFindResultSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-lead/get-agent-lead-by-id.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { AgentLeadSchema } from '../../../models/agents/agent-lead.schema';
+
+export namespace GetAgentLeadByIdCommand {
+    export const RequestParamsSchema = z.object({
+        id: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentLeadSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-lead/index.ts

@@ -0,0 +1,5 @@
+export * from './find-agent-leads.command';
+export * from './create-agent-lead.command';
+export * from './get-agent-lead-by-id.command';
+export * from './update-agent-lead.command';
+export * from './delete-agent-lead.command';

package/commands/agents/agent-lead/update-agent-lead.command.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { AgentLeadSchema } from '../../../models/agents/agent-lead.schema';
+
+export namespace UpdateAgentLeadCommand {
+    export const RequestParamsSchema = z.object({
+        id: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestBodySchema = z.object({
+        data: z.record(z.string(), z.string()),
+        dialogId: z.string().uuid(),
+        leadFormId: z.string().uuid(),
+    });
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentLeadSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-lead-form/delete-agent-lead-form.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+export namespace DeleteAgentLeadFormCommand {
+    export const RequestParamsSchema = z.object({
+        agentId: z.string().uuid(),
+        id: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        success: z.boolean(),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-lead-form/find-agent-lead-forms.command.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { AgentLeadFormSchema } from '../../../models/agents/agent-lead-form.schema';
+
+export namespace FindAgentLeadFormsCommand {
+    export const RequestQuerySchema = z.object({
+        agentId: z.string().uuid().optional(),
+        limit: z.coerce.number().optional(),
+        offset: z.coerce.number().optional(),
+    });
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(AgentLeadFormSchema),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-lead-form/get-agent-lead-form-by-agent.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { AgentLeadFormSchema } from '../../../models/agents/agent-lead-form.schema';
+
+export namespace GetAgentLeadFormByAgentCommand {
+    export const RequestParamsSchema = z.object({
+        agentId: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentLeadFormSchema.nullable(),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-lead-form/get-agent-lead-form-by-id.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { AgentLeadFormSchema } from '../../../models/agents/agent-lead-form.schema';
+
+export namespace GetAgentLeadFormByIdCommand {
+    export const RequestParamsSchema = z.object({
+        id: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentLeadFormSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-lead-form/index.ts

@@ -0,0 +1,5 @@
+export * from './find-agent-lead-forms.command';
+export * from './get-agent-lead-form-by-agent.command';
+export * from './get-agent-lead-form-by-id.command';
+export * from './upsert-agent-lead-form.command';
+export * from './delete-agent-lead-form.command';

package/commands/agents/agent-lead-form/upsert-agent-lead-form.command.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { AgentLeadFormFieldSchema } from '../../../models/agents/agent-lead-form-field.schema';
+import { AgentLeadFormSchema } from '../../../models/agents/agent-lead-form.schema';
+
+export namespace UpsertAgentLeadFormCommand {
+    export const RequestParamsSchema = z.object({
+        agentId: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestBodySchema = z.object({
+        fields: z.array(AgentLeadFormFieldSchema),
+        collectionTrigger: z.string().nullable(),
+    });
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentLeadFormSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-template/create-agent-template-category.command.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { AgentTemplateCategorySchema } from '../../../models/agents/agent-template-category.schema';
+
+export namespace CreateAgentTemplateCategoryCommand {
+    export const RequestBodySchema = z.object({
+        slug: z.string(),
+        name: z.string(),
+        description: z.string(),
+        order: z.number(),
+    });
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentTemplateCategorySchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-template/create-agent-template-instruction.command.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { AgentTemplateInstructionSchema } from '../../../models/agents/agent-template-instruction.schema';
+
+export namespace CreateAgentTemplateInstructionCommand {
+    export const RequestParamsSchema = z.object({
+        templateId: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestBodySchema = z.object({
+        title: z.string(),
+        description: z.string(),
+        prompt: z.string(),
+        order: z.number().optional(),
+    });
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentTemplateInstructionSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-template/create-agent-template.command.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { AGENT_INTERACTION_MODE } from '../../../constants/agents/enums/agent-interaction-mode.enum';
+import { AgentTemplateSchema } from '../../../models/agents/agent-template.schema';
+
+export namespace CreateAgentTemplateCommand {
+    export const RequestBodySchema = z.object({
+        categoryId: z.string().uuid(),
+        name: z.string(),
+        description: z.string(),
+        iconUrl: z.string().nullable().optional(),
+        systemPrompt: z.string().nullable().optional(),
+        interactionMode: z.nativeEnum(AGENT_INTERACTION_MODE).optional(),
+        order: z.number().optional(),
+    });
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentTemplateSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-template/delete-agent-template-category.command.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+export namespace DeleteAgentTemplateCategoryCommand {
+    export const RequestParamsSchema = z.object({
+        id: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        success: z.boolean(),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-template/delete-agent-template-instruction.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+export namespace DeleteAgentTemplateInstructionCommand {
+    export const RequestParamsSchema = z.object({
+        templateId: z.string().uuid(),
+        id: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        success: z.boolean(),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-template/delete-agent-template.command.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+export namespace DeleteAgentTemplateCommand {
+    export const RequestParamsSchema = z.object({
+        id: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        success: z.boolean(),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}