@purpleschool/gptbot-tools 0.0.55 → 0.0.56-presentation

package/video-editor/models/video-editor-model.schema.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { IconVariantsSchema, TOOL_MODEL_STATUS } from '../../common';
+import { VIDEO_EDITOR_MODEL_STRATEGY } from '../enums';
+
+export const VideoEditorModelSchema = z.object({
+    uuid: z.string(),
+    title: z.string(),
+    description: z.string(),
+    aiModel: z.string(),
+    pricePerSecond: z.number(),
+    order: z.number(),
+    status: z.nativeEnum(TOOL_MODEL_STATUS),
+    icons: IconVariantsSchema,
+    strategy: z.nativeEnum(VIDEO_EDITOR_MODEL_STRATEGY),
+    maxPromptLength: z.number(),
+    maxInputVideoSizeBytes: z.number(),
+    maxInputVideoDurationInSeconds: z.number(),
+    supportedFormats: z.array(z.string()),
+    needsTranslation: z.boolean(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+export type VideoEditorModel = z.infer<typeof VideoEditorModelSchema>;

package/video-editor/queries/find-video-editor-job-by-id.query.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { VideoEditorJobSchema } from '../models/video-editor-job.schema';
+
+export namespace FindVideoEditorJobByIdQuery {
+    export const RequestSchema = z
+        .object({
+            uuid: z.string(),
+            userId: z.string().uuid().nullable().optional(),
+            unregisteredUserId: z.string().uuid().nullable().optional(),
+        })
+        .refine((data) => data.userId || data.unregisteredUserId, {
+            message: 'Either userId or unregisteredUserId must be provided',
+        });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(VideoEditorJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/video-editor/queries/find-video-editor-jobs.query.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { VideoEditorJobSchema } from '../models/video-editor-job.schema';
+
+export namespace FindVideoEditorJobsQuery {
+    export const RequestSchema = z
+        .object({
+            userId: z.string().uuid().optional(),
+            unregisteredUserId: z.string().uuid().optional(),
+            title: z.string().optional(),
+            limit: z.coerce.number().min(1).optional(),
+            offset: z.coerce.number().min(0).default(0).optional(),
+        })
+        .refine(
+            (data) => {
+                return Boolean(data.userId) !== Boolean(data.unregisteredUserId);
+            },
+            {
+                message: 'At least userId or unregisteredUserId must be present',
+                path: ['userId', 'unregisteredUserId'],
+            },
+        );
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(
+        z.object({
+            data: z.array(VideoEditorJobSchema),
+            page: z.number(),
+            totalPages: z.number(),
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/video-editor/queries/get-video-editor-config.query.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { VideoEditorConfigSchema } from '../models';
+
+export namespace GetVideoEditorConfigQuery {
+    export const RequestSchema = z.object({});
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(VideoEditorConfigSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/video-editor/queries/index.ts

@@ -0,0 +1,3 @@
+export * from './find-video-editor-job-by-id.query';
+export * from './find-video-editor-jobs.query';
+export * from './get-video-editor-config.query';

package/video-editor/routes/index.ts

@@ -0,0 +1,2 @@
+export * from './video-editor.amqp.routes';
+export * from './video-editor.http.routes';

package/video-editor/routes/video-editor.amqp.routes.ts

@@ -0,0 +1,11 @@
+export const VIDEO_EDITOR_AMQP_ROUTES = {
+    EXECUTE: 'tools.video-editor.execute.rpc',
+    CONFIG: 'tools.video-editor.config.rpc',
+    GET_JOB: 'tools.video-editor.jobs.get.rpc',
+    LIST_JOBS: 'tools.video-editor.jobs.list.rpc',
+    SET_REACTION: 'tools.video-editor.jobs.set-reaction.rpc',
+    UPDATE_TITLE: 'tools.video-editor.jobs.update-title.rpc',
+    SOFT_DELETE: 'tools.video-editor.jobs.soft-delete.rpc',
+    SOFT_DELETE_ALL: 'tools.video-editor.jobs.soft-delete-all.rpc',
+    RETRY: 'tools.video-editor.jobs.retry.rpc',
+} as const;

package/video-editor/routes/video-editor.http.routes.ts

@@ -0,0 +1,6 @@
+export const VIDEO_EDITOR_CONTROLLER = 'video-editor';
+
+export const VIDEO_EDITOR_ROUTES = {
+    KIE_ALEPH_CALLBACK: 'kie/aleph/callback',
+    KIE_LUMA_CALLBACK: 'kie/luma/callback',
+};

package/video-editor/utils/calculate-video-editing-price.ts

@@ -0,0 +1,12 @@
+export function calculateVideoEditingPrice({
+    duration,
+    pricePerSecond,
+}: {
+    duration: number;
+    pricePerSecond: number;
+}): number {
+    if (duration <= 0) throw new Error('Duration must be positive');
+    if (pricePerSecond < 0) throw new Error('Price per second cannot be negative');
+
+    return Math.ceil(duration * pricePerSecond);
+}

package/video-editor/utils/index.ts

@@ -0,0 +1 @@
+export * from './calculate-video-editing-price';

package/writer/commands/generate-document-contents.command.ts

@@ -8,6 +8,7 @@ export namespace GenerateWriterDocumentContentsCommand {
         userId: z.string().uuid().nullable().optional(),
         unregisteredUserId: z.string().uuid().nullable().optional(),
         userBalance: z.number(),
+        modelId: z.string(),
     });
     export type Request = z.infer<typeof RequestSchema>;
 

package/writer/enums/index.ts

@@ -3,3 +3,4 @@ export * from './writer-ai-action-pricing-type.enum';
 export * from './writer-ai-action-type.enum';
 export * from './writer-document-section-type.enum';
 export * from './writer-document-stage.enum';
+export * from './writer-content-generation-strategy.enum';

package/writer/enums/writer-content-generation-strategy.enum.ts

@@ -0,0 +1,4 @@
+export enum WRITER_CONTENT_GENERATION_STRATEGY {
+    OPENAI = 'openai',
+    PERPLEXITY = 'perplexity',
+}

package/writer/index.ts

@@ -4,3 +4,4 @@ export * from './queries';
 export * from './enums';
 export * from './routes';
 export * from './utils';
+export * from './models';

package/writer/models/index.ts

@@ -1,3 +1,4 @@
+export * from './writer-model.schema';
 export * from './writer-config.schema';
 export * from './writer-ai-action.schema';
 export * from './writer-document-outline.schema';

package/writer/models/writer-config.schema.ts

@@ -1,10 +1,12 @@
 import { z } from 'zod';
 import { WriterDocumentTypeSchema } from './writer-document-type.schema';
 import { WriterAiActionSchema } from './writer-ai-action.schema';
+import { WriterModelSchema } from './writer-model.schema';
 
 export const WriterConfigSchema = z.object({
     maxPromptLength: z.number(),
     documentTypes: z.array(WriterDocumentTypeSchema),
     aiActions: z.array(WriterAiActionSchema),
+    models: z.array(WriterModelSchema),
 });
 export type WriterConfig = z.infer<typeof WriterConfigSchema>;

package/writer/models/writer-document-type.schema.ts

@@ -10,6 +10,7 @@ export const WriterDocumentTypeSchema = z.object({
     maxPages: z.number(),
     pageRange: z.array(z.number()),
     needsTableOfContents: z.boolean(),
+    needsCitations: z.boolean(),
     createdAt: z.date(),
     updatedAt: z.date(),
 });

package/writer/models/writer-document.schema.ts

@@ -14,6 +14,7 @@ export const WriterDocumentSchema = z.object({
     finalMd: z.string().nullable(),
     userId: z.string().nullable(),
     unregisteredUserId: z.string().nullable(),
+    modelId: z.string().nullable(),
     reaction: z.nativeEnum(USER_REACTION).nullable(),
     pages: z.number(),
     isDeleted: z.boolean(),

package/writer/models/writer-model.schema.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { TOOL_MODEL_STATUS } from '../../common';
+import { IconVariantsSchema } from '../../common';
+import { WRITER_CONTENT_GENERATION_STRATEGY } from '../enums/writer-content-generation-strategy.enum';
+
+export const WriterModelSchema = z.object({
+    uuid: z.string(),
+    title: z.string(),
+    description: z.string(),
+    aiModel: z.string(),
+    pricePerPage: z.number(),
+    order: z.number(),
+    status: z.nativeEnum(TOOL_MODEL_STATUS),
+    icons: IconVariantsSchema,
+    strategy: z.nativeEnum(WRITER_CONTENT_GENERATION_STRATEGY),
+    maxInputLength: z.number(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type WriterModel = z.infer<typeof WriterModelSchema>;

package/writer/utils/calculate-writer-content-generation-price.util.ts

@@ -1,3 +1,5 @@
-export function calculateWriterContentGenerationPrice(pages: number): number {
-    return Math.max(1, pages);
+import { WriterModel } from '../models';
+
+export function calculateWriterContentGenerationPrice(pages: number, model: WriterModel): number {
+    return Math.max(1, pages * model.pricePerPage);
 }