@purpleschool/gptbot 0.13.4 → 0.13.6

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>;

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

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { AGENT_TOOL_TYPE } from '../../constants/agents/enums';
+
+export const BitrixLeadAgentToolCredentialsSchema = z.object({
+    type: z.literal(AGENT_TOOL_TYPE.BITRIX_LEAD),
+    webhookUrl: z.string().min(1),
+    sourceId: z.string().min(1).optional(),
+});
+
+export type BitrixLeadAgentToolCredentials = z.infer<typeof BitrixLeadAgentToolCredentialsSchema>;
+
+export const AmoLeadAgentToolCredentialsSchema = z.object({
+    type: z.literal(AGENT_TOOL_TYPE.AMO_LEAD),
+    subdomain: z.string().min(1),
+    accessToken: z.string().min(1),
+});
+
+export type AmoLeadAgentToolCredentials = z.infer<typeof AmoLeadAgentToolCredentialsSchema>;
+
+export const EmailLeadAgentToolCredentialsSchema = z.object({
+    type: z.literal(AGENT_TOOL_TYPE.EMAIL_LEAD),
+    email: z.string().email(),
+});
+
+export type EmailLeadAgentToolCredentials = z.infer<typeof EmailLeadAgentToolCredentialsSchema>;
+
+export const AgentToolCredentialsSchema = z.discriminatedUnion('type', [
+    BitrixLeadAgentToolCredentialsSchema,
+    AmoLeadAgentToolCredentialsSchema,
+    EmailLeadAgentToolCredentialsSchema,
+]);
+
+export type AgentToolCredentials = z.infer<typeof AgentToolCredentialsSchema>;

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

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { AGENT_TOOL_STATUS, AGENT_TOOL_TYPE } from '../../constants/agents/enums';
+import { AgentToolCredentialsSchema } from './agent-tool-credentials.schema';
+
+export const AgentToolSchema = z.object({
+    id: z.string().uuid(),
+    agentId: z.string().uuid(),
+    toolType: z.nativeEnum(AGENT_TOOL_TYPE),
+    status: z.nativeEnum(AGENT_TOOL_STATUS),
+    credentials: AgentToolCredentialsSchema,
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type AgentTool = z.infer<typeof AgentToolSchema>;

package/models/agents/agent.schema.ts

@@ -0,0 +1,25 @@
+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';
+
+export const AgentSchema = z.object({
+    id: z.string().uuid(),
+    teamAccountId: z.string().uuid(),
+    templateId: z.string().uuid().nullable(),
+    name: z.string(),
+    description: z.string(),
+    icon: z.string().nullable(),
+    avatar: z.string().nullable(),
+    greetingPhrase: z.string().nullable(),
+    instructions: z.string().nullable(),
+    aiModelId: z.string().uuid(),
+    status: z.nativeEnum(AGENT_STATUS),
+    interactionMode: z.nativeEnum(AGENT_INTERACTION_MODE),
+    isHumanHelp: z.boolean(),
+    useDocuments: z.boolean(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+    dialogsCount: z.number().optional(),
+});
+
+export type Agent = z.infer<typeof AgentSchema>;

package/models/agents/channel.schema.ts

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

package/models/agents/dialog-find-result.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { DialogSchema } from './dialog.schema';
+
+export const DialogFindResultSchema = z.object({
+    data: z.array(DialogSchema),
+    total: z.number(),
+});
+
+export type DialogFindResult = z.infer<typeof DialogFindResultSchema>;

package/models/agents/dialog-with-messages.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { AgentDialogMessageSchema } from './agent-dialog-message.schema';
+import { DialogSchema } from './dialog.schema';
+
+export const DialogWithMessagesSchema = DialogSchema.extend({
+    messages: z.array(AgentDialogMessageSchema),
+});
+
+export type DialogWithMessages = z.infer<typeof DialogWithMessagesSchema>;

package/models/agents/dialog.schema.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { DIALOG_STATUS } from '../../constants/agents/enums/dialog-status.enum';
+import { AgentDialogLeadSchema } from './agent-dialog-lead.schema';
+
+export const DialogSchema = z.object({
+    id: z.string().uuid(),
+    agentId: z.string().uuid(),
+    userId: z.string().uuid().optional(),
+    userName: z.string(),
+    source: z.string().optional(),
+    utm_campaign: z.string().optional(),
+    utm_term: z.string().optional(),
+    utm_source: z.string().optional(),
+    utm_content: z.string().optional(),
+    utm_medium: z.string().optional(),
+    yclid: z.string().optional(),
+    referrer: z.string().optional(),
+    _ym_uid: z.string().optional(),
+    roistat_visit: z.string().optional(),
+    externalId: z.string().optional(),
+    userMeta: z.record(z.string(), z.unknown()).optional(),
+    status: z.nativeEnum(DIALOG_STATUS),
+    title: z.string(),
+    createdAt: z.date(),
+    lastMessageAt: z.date().optional(),
+    lastUserMessageAt: z.date().optional(),
+    updatedAt: z.date(),
+    messageCount: z.number().optional(),
+    lead: AgentDialogLeadSchema.optional(),
+});
+
+export type Dialog = z.infer<typeof DialogSchema>;

package/models/agents/index.ts

@@ -0,0 +1,25 @@
+export * from './agent-channel.schema';
+export * from './agent-ai-model.schema';
+export * from './agent-channel-credentials.schema';
+export * from './agent-lead-form-field.schema';
+export * from './agent-lead-form.schema';
+export * from './agent-lead.schema';
+export * from './agent-lead-find-result.schema';
+export * from './agent-dialog-lead.schema';
+export * from './agent-dialog-message.schema';
+export * from './dialog-find-result.schema';
+export * from './dialog-with-messages.schema';
+export * from './dialog.schema';
+export * from './agent-template-catalog.schema';
+export * from './agent-template-category.schema';
+export * from './agent-template-instruction.schema';
+export * from './agent-template.schema';
+export * from './agent-tool-credentials.schema';
+export * from './agent-tool-catalog.schema';
+export * from './agent-tool.schema';
+export * from './agent-document.schema';
+export * from './agent-document-find-result.schema';
+export * from './agent-document-chunk.schema';
+export * from './agent-document-search-result.schema';
+export * from './agent.schema';
+export * from './channel.schema';

package/models/index.ts

@@ -1,3 +1,4 @@
+export * from './agents';
 export * from './tools';
 export * from './ai-model-config.schema';
 export * from './ai-model-formatted.schema';
@@ -44,6 +45,7 @@ export * from './subscription-feature.schema';
 export * from './team-subscription-feature.schema';
 export * from './subscription-upgrade-schema';
 export * from './subscription.schema';
+export * from './support-feedback.schema';
 export * from './telegram-user-data.schema';
 export * from './tool-job.schema';
 export * from './tool-group.schema';

package/models/support-feedback.schema.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+
+export const SupportFeedbackSchema = z.object({
+    uuid: z.string().uuid(),
+    supportDialogId: z.string().min(1),
+    userId: z.string().uuid().nullable().optional(),
+    unregisteredUserId: z.string().uuid().nullable().optional(),
+    rating: z.number().int().min(1).max(5),
+    comment: z.string().nullable().optional(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purpleschool/gptbot",
-  "version": "0.13.4",
+  "version": "0.13.6",
   "description": "",
   "main": "build/index.js",
   "types": "build/index.d.ts",