@purpleschool/gptbot 0.13.5 → 0.13.6

package/commands/agents/agent-tool/connect-agent-tool.command.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { AGENT_TOOL_TYPE } from '../../../constants/agents/enums';
+import { AgentToolCredentialsSchema } from '../../../models/agents/agent-tool-credentials.schema';
+import { AgentToolSchema } from '../../../models/agents/agent-tool.schema';
+
+export namespace ConnectAgentToolCommand {
+    export const RequestParamsSchema = z.object({
+        agentId: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestBodySchema = z.object({
+        toolType: z.nativeEnum(AGENT_TOOL_TYPE),
+        credentials: AgentToolCredentialsSchema.nullable().optional(),
+    });
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentToolSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-tool/disconnect-agent-tool.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+export namespace DisconnectAgentToolCommand {
+    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-tool/find-agent-tools-catalog.command.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { AGENT_TOOL_TYPE } from '../../../constants/agents/enums';
+import { AgentToolCatalogSchema } from '../../../models/agents/agent-tool-catalog.schema';
+
+export namespace FindAgentToolsCatalogCommand {
+    export const RequestQuerySchema = z.object({
+        type: z.nativeEnum(AGENT_TOOL_TYPE).optional(),
+    });
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(AgentToolCatalogSchema),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-tool/find-agent-tools.command.ts

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

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

@@ -0,0 +1,5 @@
+export * from './find-agent-tools-catalog.command';
+export * from './find-agent-tools.command';
+export * from './connect-agent-tool.command';
+export * from './update-agent-tool.command';
+export * from './disconnect-agent-tool.command';

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

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { AGENT_TOOL_STATUS } from '../../../constants/agents/enums';
+import { AgentToolCredentialsSchema } from '../../../models/agents/agent-tool-credentials.schema';
+import { AgentToolSchema } from '../../../models/agents/agent-tool.schema';
+
+export namespace UpdateAgentToolCommand {
+    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: AgentToolCredentialsSchema.nullable().optional(),
+        status: z.nativeEnum(AGENT_TOOL_STATUS).optional(),
+    });
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentToolSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { AGENT_INTERACTION_MODE } from '../../../constants/agents/enums/agent-interaction-mode.enum';
+import { AgentSchema } from '../../../models/agents/agent.schema';
+
+export namespace CreateAgentCommand {
+    export const RequestBodySchema = z.object({
+        templateId: z.string().uuid().nullable().optional(),
+        name: z.string(),
+        icon: z.string().nullable().optional(),
+        avatar: z.string().nullable().optional(),
+        greetingPhrase: z.string().nullable().optional(),
+        instructions: z.string().nullable().optional(),
+        aiModelId: z.string().uuid(),
+        interactionMode: z.nativeEnum(AGENT_INTERACTION_MODE).optional(),
+        isHumanHelp: z.boolean().optional(),
+        useDocuments: z.boolean().optional(),
+    });
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+export namespace DeleteAgentCommand {
+    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/agents/find-agents.command.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { AgentSchema } from '../../../models/agents/agent.schema';
+
+export namespace FindAgentsCommand {
+    export const RequestQuerySchema = z.object({
+        id: z.string().uuid().optional(),
+        name: z.string().optional(),
+        isHumanHelp: z.coerce.boolean().optional(),
+        page: z.coerce.number().optional(),
+        limit: z.coerce.number().optional(),
+    });
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(AgentSchema),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

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

package/commands/agents/agents/get-agent-public-info.command.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+
+export const AgentPublicInfoSchema = z.object({
+    greetingPhrase: z.string().nullable(),
+    activity: z.boolean(),
+    icon: z.string().nullable(),
+    avatar: z.string().nullable(),
+});
+
+export type AgentPublicInfo = z.infer<typeof AgentPublicInfoSchema>;
+
+export namespace GetAgentPublicInfoCommand {
+    export const RequestParamsSchema = z.object({
+        id: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentPublicInfoSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agents/index.ts

@@ -0,0 +1,6 @@
+export * from './create-agent.command';
+export * from './delete-agent.command';
+export * from './find-agents.command';
+export * from './get-agent-by-id.command';
+export * from './get-agent-public-info.command';
+export * from './update-agent.command';

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

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { AGENT_INTERACTION_MODE } from '../../../constants/agents/enums/agent-interaction-mode.enum';
+import { AGENT_STATUS } from '../../../constants/agents/enums/agent-status.enum';
+import { AgentSchema } from '../../../models/agents/agent.schema';
+
+export namespace UpdateAgentCommand {
+    export const RequestParamsSchema = z.object({
+        id: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestBodySchema = z.object({
+        templateId: z.string().uuid().nullable().optional(),
+        name: z.string().optional(),
+        description: z.string().optional(),
+        icon: z.string().nullable().optional(),
+        avatar: z.string().nullable().optional(),
+        greetingPhrase: z.string().nullable().optional(),
+        instructions: z.string().nullable().optional(),
+        aiModelId: z.string().uuid().optional(),
+        isHumanHelp: z.boolean().optional(),
+        useDocuments: z.boolean().optional(),
+        interactionMode: z.nativeEnum(AGENT_INTERACTION_MODE).optional(),
+        status: z.nativeEnum(AGENT_STATUS).optional(),
+    });
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/index.ts

@@ -0,0 +1,9 @@
+export * from './agent-ai-model';
+export * from './agent-channel';
+export * from './agent-dialog';
+export * from './agent-lead-form';
+export * from './agent-lead';
+export * from './agent-tool';
+export * from './agent-document';
+export * from './agent-template';
+export * from './agents';

package/commands/index.ts

@@ -1,4 +1,5 @@
 export * from './account-merge';
+export * from './agents';
 export * from './ai-model';
 export * from './ai-vendor';
 export * from './auth';

package/constants/agents/enums/agent-channel-status.enum.ts

@@ -0,0 +1,5 @@
+export enum AGENT_CHANNEL_STATUS {
+    ACTIVE = 'active',
+    ERROR = 'error',
+    PENDING = 'pending',
+}

package/constants/agents/enums/agent-channel-type.enum.ts

@@ -0,0 +1,5 @@
+export enum AGENT_CHANNEL_TYPE {
+    TELEGRAM = 'telegram',
+    WEB = 'web',
+    AVITO = 'avito',
+}

package/constants/agents/enums/agent-document-status.enum.ts

@@ -0,0 +1,5 @@
+export enum AGENT_DOCUMENT_STATUS {
+    INDEXING = 'indexing',
+    UPLOADED = 'uploaded',
+    ERROR = 'error',
+}

package/constants/agents/enums/agent-interaction-mode.enum.ts

@@ -0,0 +1,4 @@
+export enum AGENT_INTERACTION_MODE {
+    EXTERNAL_ONLY = 'external_only',
+    INTERNAL_ONLY = 'internal_only',
+}

package/constants/agents/enums/agent-status.enum.ts

@@ -0,0 +1,5 @@
+export enum AGENT_STATUS {
+    ACTIVE = 'active',
+    STOPPED = 'stopped',
+    DRAFT = 'draft',
+}

package/constants/agents/enums/agent-tool-status.enum.ts

@@ -0,0 +1,5 @@
+export enum AGENT_TOOL_STATUS {
+    ACTIVE = 'active',
+    DISABLED = 'disabled',
+    ERROR = 'error',
+}

package/constants/agents/enums/agent-tool-type.enum.ts

@@ -0,0 +1,5 @@
+export enum AGENT_TOOL_TYPE {
+    BITRIX_LEAD = 'BITRIX_LEAD',
+    AMO_LEAD = 'AMO_LEAD',
+    EMAIL_LEAD = 'EMAIL_LEAD',
+}

package/constants/agents/enums/dialog-status.enum.ts

@@ -0,0 +1,7 @@
+export enum DIALOG_STATUS {
+    IN_PROGRESS = 'inProgress',
+    TRANSFERRED_TO_HUMAN = 'transferredToHuman',
+    GATHERED_LEAD = 'gatheredLead',
+    BANNED = 'banned',
+    CLOSED = 'closed',
+}

package/constants/agents/enums/index.ts

@@ -0,0 +1,8 @@
+export * from './agent-channel-status.enum';
+export * from './agent-channel-type.enum';
+export * from './agent-interaction-mode.enum';
+export * from './agent-status.enum';
+export * from './agent-tool-type.enum';
+export * from './agent-tool-status.enum';
+export * from './agent-document-status.enum';
+export * from './dialog-status.enum';

package/constants/agents/index.ts

@@ -0,0 +1 @@
+export * from './enums';

package/constants/index.ts

@@ -1,4 +1,5 @@
 export * from './ai-model';
+export * from './agents';
 export * from './blog';
 export * from './billing';
 export * from './category';

package/models/agents/agent-ai-model.schema.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+export const AgentAiModelSchema = z.object({
+    id: z.string().uuid(),
+    model: z.string(),
+    name: z.string(),
+    icon: z.string().nullable(),
+    isActive: z.boolean(),
+    order: z.number(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type AgentAiModel = z.infer<typeof AgentAiModelSchema>;

package/models/agents/agent-channel-credentials.schema.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { AGENT_CHANNEL_TYPE } from '../../constants/agents/enums';
+
+export const TelegramChannelCredentialsSchema = z.object({
+    type: z.literal(AGENT_CHANNEL_TYPE.TELEGRAM),
+    token: z.string().min(1),
+});
+
+export type TelegramChannelCredentials = z.infer<typeof TelegramChannelCredentialsSchema>;
+
+export const WebChannelCredentialsSchema = z.object({
+    type: z.literal(AGENT_CHANNEL_TYPE.WEB),
+    domain: z.string().url().optional(),
+});
+
+export type WebChannelCredentials = z.infer<typeof WebChannelCredentialsSchema>;
+
+export const AvitoChannelCredentialsSchema = z.object({
+    type: z.literal(AGENT_CHANNEL_TYPE.AVITO),
+    clientId: z.string().min(1),
+    clientSecret: z.string().min(1),
+});
+
+export type AvitoChannelCredentials = z.infer<typeof AvitoChannelCredentialsSchema>;
+
+export const AgentChannelCredentialsSchema = z.discriminatedUnion('type', [
+    TelegramChannelCredentialsSchema,
+    WebChannelCredentialsSchema,
+    AvitoChannelCredentialsSchema,
+]);
+
+export type AgentChannelCredentials = z.infer<typeof AgentChannelCredentialsSchema>;

package/models/agents/agent-channel.schema.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { AGENT_CHANNEL_STATUS, AGENT_CHANNEL_TYPE } from '../../constants/agents/enums';
+import { AgentChannelCredentialsSchema } from './agent-channel-credentials.schema';
+
+export const AgentChannelSchema = z.object({
+    id: z.string().uuid(),
+    agentId: z.string().uuid(),
+    channelType: z.nativeEnum(AGENT_CHANNEL_TYPE),
+    status: z.nativeEnum(AGENT_CHANNEL_STATUS),
+    credentials: AgentChannelCredentialsSchema,
+    lastCheckedAt: z.date().nullable(),
+    lastError: z.string().nullable(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type AgentChannel = z.infer<typeof AgentChannelSchema>;

package/models/agents/agent-dialog-lead.schema.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+export const AgentDialogLeadSchema = z.object({
+    id: z.string().uuid(),
+    dialogId: z.string().uuid(),
+    leadFormId: z.string().uuid(),
+    data: z.record(z.string(), z.string()),
+    isDeleted: z.boolean(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type AgentDialogLead = z.infer<typeof AgentDialogLeadSchema>;

package/models/agents/agent-dialog-message.schema.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+export const AgentDialogMessageSchema = z.object({
+    id: z.string().uuid(),
+    text: z.string().optional(),
+    images: z.array(z.string()),
+    attachments: z.array(z.string()),
+    tokensUsed: z.number().optional(),
+    isFromUser: z.boolean(),
+    createdAt: z.date(),
+});
+
+export type AgentDialogMessage = z.infer<typeof AgentDialogMessageSchema>;

package/models/agents/agent-document-chunk.schema.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+
+export const AgentDocumentChunkSchema = z.object({
+    id: z.string().uuid(),
+    documentId: z.string().uuid(),
+    content: z.string(),
+    chunkIndex: z.number(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    similarity: z.number().optional(),
+    isDeleted: z.boolean(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type AgentDocumentChunk = z.infer<typeof AgentDocumentChunkSchema>;

package/models/agents/agent-document-find-result.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { AgentDocumentSchema } from './agent-document.schema';
+
+export const AgentDocumentFindResultSchema = z.object({
+    data: z.array(AgentDocumentSchema),
+    total: z.number(),
+    limit: z.number(),
+    offset: z.number(),
+});
+
+export type AgentDocumentFindResult = z.infer<typeof AgentDocumentFindResultSchema>;

package/models/agents/agent-document-search-result.schema.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { AgentDocumentChunkSchema } from './agent-document-chunk.schema';
+
+export const AgentDocumentSearchResultItemSchema = z.object({
+    chunk: AgentDocumentChunkSchema,
+    similarity: z.number(),
+});
+
+export type AgentDocumentSearchResultItem = z.infer<typeof AgentDocumentSearchResultItemSchema>;
+
+export const AgentDocumentSearchResultSchema = z.object({
+    results: z.array(AgentDocumentSearchResultItemSchema),
+    context: z.string(),
+});
+
+export type AgentDocumentSearchResult = z.infer<typeof AgentDocumentSearchResultSchema>;

package/models/agents/agent-document.schema.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { AGENT_DOCUMENT_STATUS } from '../../constants/agents/enums';
+
+export const AgentDocumentSchema = z.object({
+    id: z.string().uuid(),
+    agentId: z.string().uuid(),
+    filename: z.string(),
+    originalUrl: z.string().optional(),
+    fileSize: z.number().optional(),
+    contentType: z.string(),
+    status: z.nativeEnum(AGENT_DOCUMENT_STATUS),
+    chunksCount: z.number().optional(),
+    isDeleted: z.boolean(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type AgentDocument = z.infer<typeof AgentDocumentSchema>;

package/models/agents/agent-lead-find-result.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { AgentLeadSchema } from './agent-lead.schema';
+
+export const AgentLeadFindResultSchema = z.object({
+    data: z.array(AgentLeadSchema),
+    total: z.number(),
+    limit: z.number(),
+    offset: z.number(),
+});
+
+export type AgentLeadFindResult = z.infer<typeof AgentLeadFindResultSchema>;

package/models/agents/agent-lead-form-field.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+
+export const AgentLeadFormFieldSchema = z.object({
+    key: z.string(),
+    name: z.string(),
+    integrationName: z.string().optional(),
+    required: z.boolean().optional(),
+});
+
+export type AgentLeadFormField = z.infer<typeof AgentLeadFormFieldSchema>;

package/models/agents/agent-lead-form.schema.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { AgentLeadFormFieldSchema } from './agent-lead-form-field.schema';
+
+export const AgentLeadFormSchema = z.object({
+    id: z.string().uuid(),
+    agentId: z.string().uuid(),
+    fields: z.array(AgentLeadFormFieldSchema),
+    collectionTrigger: z.string().nullable().optional(),
+    isDeleted: z.boolean(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type AgentLeadForm = z.infer<typeof AgentLeadFormSchema>;

package/models/agents/agent-lead.schema.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+export const AgentLeadSchema = z.object({
+    id: z.string().uuid(),
+    dialogId: z.string().uuid(),
+    leadFormId: z.string().uuid(),
+    data: z.record(z.string(), z.string()),
+    isDeleted: z.boolean(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type AgentLead = z.infer<typeof AgentLeadSchema>;

package/models/agents/agent-template-catalog.schema.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { AgentTemplateCategorySchema } from './agent-template-category.schema';
+import { AgentTemplateInstructionSchema } from './agent-template-instruction.schema';
+import { AgentTemplateSchema } from './agent-template.schema';
+
+export const CatalogAgentTemplateSchema = AgentTemplateSchema.extend({
+    instructions: z.array(AgentTemplateInstructionSchema),
+});
+
+export type CatalogAgentTemplate = z.infer<typeof CatalogAgentTemplateSchema>;
+
+export const CatalogAgentTemplateCategorySchema = AgentTemplateCategorySchema.extend({
+    templates: z.array(CatalogAgentTemplateSchema),
+});
+
+export type CatalogAgentTemplateCategory = z.infer<typeof CatalogAgentTemplateCategorySchema>;
+
+export const AgentTemplateCatalogSchema = z.object({
+    categories: z.array(CatalogAgentTemplateCategorySchema),
+});
+
+export type AgentTemplateCatalog = z.infer<typeof AgentTemplateCatalogSchema>;

package/models/agents/agent-template-category.schema.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+export const AgentTemplateCategorySchema = z.object({
+    id: z.string().uuid(),
+    slug: z.string(),
+    name: z.string(),
+    description: z.string(),
+    order: z.number(),
+    isActive: z.boolean(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type AgentTemplateCategory = z.infer<typeof AgentTemplateCategorySchema>;

package/models/agents/agent-template-instruction.schema.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+
+export const AgentTemplateInstructionSchema = z.object({
+    id: z.string().uuid(),
+    templateId: z.string().uuid(),
+    title: z.string(),
+    description: z.string(),
+    prompt: z.string(),
+    order: z.number(),
+    isActive: z.boolean(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type AgentTemplateInstruction = z.infer<typeof AgentTemplateInstructionSchema>;

package/models/agents/agent-template.schema.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { AGENT_INTERACTION_MODE } from '../../constants/agents/enums/agent-interaction-mode.enum';
+
+export const AgentTemplateSchema = z.object({
+    id: z.string().uuid(),
+    categoryId: z.string().uuid(),
+    name: z.string(),
+    description: z.string(),
+    iconUrl: z.string().nullable(),
+    systemPrompt: z.string().nullable(),
+    interactionMode: z.nativeEnum(AGENT_INTERACTION_MODE),
+    order: z.number(),
+    isActive: z.boolean(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type AgentTemplate = z.infer<typeof AgentTemplateSchema>;

package/models/agents/agent-tool-catalog.schema.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { AGENT_TOOL_TYPE } from '../../constants/agents/enums';
+
+export const AgentToolCatalogSchema = z.object({
+    type: z.nativeEnum(AGENT_TOOL_TYPE),
+    name: z.string(),
+    displayName: z.string(),
+    description: z.string().nullable().optional(),
+    icon: z.string(),
+    connectionInstruction: z.string().nullable().optional(),
+    order: z.number(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type AgentToolCatalog = z.infer<typeof AgentToolCatalogSchema>;