@purpleschool/gptbot-tools 0.0.118 → 0.0.119-stage-2

package/paraphrase/commands/get-paraphrase-price.command.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace GetParaphrasePriceCommand {
+    export const RequestSchema = z.object({
+        typeId: z.string().uuid(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseDataSchema = z.object({
+        price: z.number(),
+    });
+
+    export const ResponseSchema = ICommandResponseSchema(ResponseDataSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/paraphrase/commands/index.ts

@@ -4,3 +4,4 @@ export * from './delete-all-paraphrase-jobs.command';
 export * from './set-reaction-to-paraphrase-job.command';
 export * from './update-paraphrase-job-title.command';
 export * from './retry-paraphrase-job.command';
+export * from './get-paraphrase-price.command';

package/paraphrase/commands/paraphrase.command.ts

@@ -7,11 +7,12 @@ export namespace ParaphraseCommand {
     export const RequestSchema = z.object({
         userId: z.string().uuid().nullable().optional(),
         unregisteredUserId: z.string().uuid().nullable().optional(),
-        userBalance: z.number(),
         prompt: z.string(),
         typeId: z.string().uuid(),
         styleId: z.string().uuid(),
         intensity: z.nativeEnum(PARAPHRASING_INTENSITY),
+        tokenReservationId: z.string().uuid(),
+        precalculatedPrice: z.number(),
     });
     export type Request = z.infer<typeof RequestSchema>;
 

package/paraphrase/commands/retry-paraphrase-job.command.ts

@@ -5,9 +5,10 @@ import { ParaphraseJobSchema } from '../models/paraphrase-job.schema';
 export namespace RetryParaphraseJobCommand {
     export const RequestSchema = z.object({
         uuid: z.string().uuid(),
-        userBalance: z.number(),
         userId: z.string().uuid().nullable().optional(),
         unregisteredUserId: z.string().uuid().nullable().optional(),
+        tokenReservationId: z.string().uuid(),
+        precalculatedPrice: z.number(),
     });
     export type Request = z.infer<typeof RequestSchema>;
 

package/paraphrase/models/paraphrase-job.schema.ts

@@ -19,6 +19,7 @@ export const ParaphraseJobSchema = z.object({
     typeId: z.string(),
     styleId: z.string(),
     intensity: z.nativeEnum(PARAPHRASING_INTENSITY),
+    tokenReservationId: z.string().nullable().optional(),
     createdAt: z.date(),
     updatedAt: z.date(),
     completedAt: z.date().nullable(),

package/paraphrase/routes/paraphrase.amqp.routes.ts

@@ -1,5 +1,6 @@
 export const PARAPHRASE_AMQP_ROUTES = {
     EXECUTE: 'tools.paraphrase.execute.rpc',
+    GET_PRICE: 'tools.paraphrase.get-price.rpc',
     CONFIG: 'tools.paraphrase.config.rpc',
     GET_JOB: 'tools.paraphrase.jobs.get.rpc',
     LIST_JOBS: 'tools.paraphrase.jobs.list.rpc',

package/presentation/commands/generate-slides.command.ts

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

package/presentation/commands/get-presentation-slides-generation-price.command.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common';
+
+export namespace GetPresentationSlidesGenerationPriceCommand {
+    export const RequestSchema = z.object({
+        slideCount: z.number().int().min(1),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseDataSchema = z.object({
+        price: z.number(),
+    });
+
+    export const ResponseSchema = ICommandResponseSchema(ResponseDataSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/presentation/commands/index.ts

@@ -7,6 +7,7 @@ export * from './generate-presentation-outline.command';
 export * from './generate-and-insert-slide.command';
 export * from './export-as-pptx.command';
 export * from './generate-slides.command';
+export * from './get-presentation-slides-generation-price.command';
 export * from './reposition-slide-outline.command';
 export * from './update-slide-outline.command';
 export * from './update-presentation.command';

package/presentation/models/presentation.schema.ts

@@ -19,6 +19,7 @@ export const PresentationSchema = z.object({
     unregisteredUserId: z.string().uuid().nullable().optional(),
     slideCount: z.number(),
     isDeleted: z.boolean(),
+    tokenReservationId: z.string().nullable().optional(),
     lastContentUpdateAt: z.date().nullable(),
     lastPptxExportedAt: z.date().nullable(),
     createdAt: z.date(),

package/presentation/routes/presentation.routes.ts

@@ -4,6 +4,7 @@ export const PRESENTATION_AMQP_ROUTES = {
     FIND_BY_UUID: 'tools.presentation.find-by-uuid.rpc',
     GENERATE_PRESENTATION_OUTLINE: 'tools.presentation.generate-outline.rpc',
     GENERATE_PRESENTATION_SLIDES: 'tools.presentation.generate-slides.rpc',
+    GET_SLIDES_GENERATION_PRICE: 'tools.presentation.slides.get-price.rpc',
     GENERATE_AND_INSERT_SLIDE: 'tools.presentation.generate-and-insert-slide.rpc',
     UPDATE_PRESENTATION_OUTLINE: 'tools.presentation.update-presentation-outline.rpc',
     LIST_PRESENTATIONS: 'tools.presentation.list-presentations.rpc',

package/stt/commands/get-stt-price.command.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace GetSTTPriceCommand {
+    export const RequestSchema = z.object({
+        modelId: z.string(),
+        durationInSeconds: z.number(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseDataSchema = z.object({
+        price: z.number(),
+    });
+
+    export const ResponseSchema = ICommandResponseSchema(ResponseDataSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/stt/commands/index.ts

@@ -3,4 +3,5 @@ export * from './delete-all-stt-jobs.command';
 export * from './retry-stt-job.command';
 export * from './set-reaction-to-stt-job.command';
 export * from './stt.command';
+export * from './get-stt-price.command';
 export * from './update-stt-job-title.command';

package/stt/commands/retry-stt-job.command.ts

@@ -5,9 +5,10 @@ import { STTJobSchema } from '../models';
 export namespace RetrySTTJobCommand {
     export const RequestSchema = z.object({
         uuid: z.string().uuid(),
-        userBalance: z.number(),
         userId: z.string().uuid().nullable().optional(),
         unregisteredUserId: z.string().uuid().nullable().optional(),
+        tokenReservationId: z.string().uuid(),
+        precalculatedPrice: z.number(),
     });
     export type Request = z.infer<typeof RequestSchema>;
 

package/stt/commands/stt.command.ts

@@ -6,12 +6,13 @@ export namespace STTCommand {
     export const RequestSchema = z.object({
         userId: z.string().uuid().nullable().optional(),
         unregisteredUserId: z.string().uuid().nullable().optional(),
-        userBalance: z.number(),
         modelId: z.string(),
         fileId: z.string(),
         fileKey: z.string(),
         fileUrl: z.string(),
         durationInSeconds: z.number(),
+        tokenReservationId: z.string().uuid(),
+        precalculatedPrice: z.number(),
     });
     export type Request = z.infer<typeof RequestSchema>;
 

package/stt/models/stt-job.schema.ts

@@ -19,6 +19,7 @@ export const STTJobSchema = z.object({
     userId: z.string().nullable(),
     unregisteredUserId: z.string().nullable(),
     price: z.number(),
+    tokenReservationId: z.string().nullable().optional(),
     isDeleted: z.boolean(),
     createdAt: z.date(),
     completedAt: z.date().nullable(),

package/stt/routes/stt.amqp.routes.ts

@@ -1,5 +1,6 @@
 export const STT_AMQP_ROUTES = {
     EXECUTE: 'tools.stt.execute.rpc',
+    GET_PRICE: 'tools.stt.get-price.rpc',
     CONFIG: 'tools.stt.config.rpc',
     GET_JOB: 'tools.stt.jobs.get.rpc',
     LIST_JOBS: 'tools.stt.jobs.list.rpc',

package/tools/enums/index.ts

@@ -1,4 +1,4 @@
 export * from './job-status.enum';
 export * from './tool-type.enum';
 export * from './tool-content-type.enum';
-export * from './job-request-origin.enum'
+export * from './job-request-origin.enum';

package/tools/enums/job-request-origin.enum.ts

@@ -1,4 +1,4 @@
 export enum JOB_REQUEST_ORIGIN {
-    API = "api",
-    B2B = "b2b"
-}
+    API = 'api',
+    B2B = 'b2b',
+}

package/tools/events/index.ts

@@ -1 +1,2 @@
 export * from './tool-job-complete.event';
+export * from './tool-job-failed.event';

package/tools/events/tool-job-failed.event.ts

@@ -0,0 +1,13 @@
+import { TOOL_TYPE } from '../enums';
+import { ToolJobSchema } from '../models';
+import { z } from 'zod';
+
+export namespace ToolJobFailedEvent {
+    export const PayloadSchema = z.object({
+        job: ToolJobSchema.extend({
+            toolType: z.nativeEnum(TOOL_TYPE),
+        }),
+    });
+
+    export type Payload = z.infer<typeof PayloadSchema>;
+}

package/tools/models/tool-job.schema.ts

@@ -5,6 +5,7 @@ export const ToolJobSchema = z.object({
     userId: z.string().nullable(),
     unregisteredUserId: z.string().nullable(),
     price: z.number(),
+    tokenReservationId: z.string().nullable().optional(),
     createdAt: z.date(),
     updatedAt: z.date(),
 });

package/tools/routes/tools.aqmp.routes.ts

@@ -1,5 +1,6 @@
 export const TOOLS_AMQP_ROUTES = {
     JOB_COMPLETED: 'tools.job.completed',
+    JOB_FAILED: 'tools.job.failed',
     FIND_ALL: 'tools.find.all.rpc',
     GET_GLOBAL_TOOLS_CONFIG: 'tools.config.rpc',
     GET_TOOLS_WITH_CONFIGS: 'tools.with-configs.rpc',

package/tts/commands/get-tts-price.command.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace GetTTSPriceCommand {
+    export const RequestSchema = z.object({
+        modelId: z.string(),
+        userInput: z.string(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseDataSchema = z.object({
+        price: z.number(),
+    });
+
+    export const ResponseSchema = ICommandResponseSchema(ResponseDataSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/tts/commands/index.ts

@@ -3,4 +3,5 @@ export * from './delete-all-tts-jobs.command';
 export * from './retry-tts-job.command';
 export * from './set-reaction-to-tts-job.command';
 export * from './tts.command';
+export * from './get-tts-price.command';
 export * from './update-tts-job-title.command';

package/tts/commands/retry-tts-job.command.ts

@@ -5,9 +5,10 @@ import { TTSJobSchema } from '../models/tts-job.schema';
 export namespace RetryTTSJobCommand {
     export const RequestSchema = z.object({
         uuid: z.string().uuid(),
-        userBalance: z.number(),
         userId: z.string().uuid().nullable().optional(),
         unregisteredUserId: z.string().uuid().nullable().optional(),
+        tokenReservationId: z.string().uuid(),
+        precalculatedPrice: z.number(),
     });
     export type Request = z.infer<typeof RequestSchema>;
 

package/tts/commands/tts.command.ts

@@ -6,7 +6,6 @@ export namespace TTSCommand {
     export const RequestSchema = z.object({
         userId: z.string().uuid().nullable().optional(),
         unregisteredUserId: z.string().uuid().nullable().optional(),
-        userBalance: z.number(),
         modelId: z.string(),
         voiceId: z.string(),
         userInput: z.string(),
@@ -18,6 +17,8 @@ export namespace TTSCommand {
                 style: z.number().optional(),
             })
             .optional(),
+        tokenReservationId: z.string().uuid(),
+        precalculatedPrice: z.number(),
     });
     export type Request = z.infer<typeof RequestSchema>;
 

package/tts/models/tts-job.schema.ts

@@ -25,6 +25,7 @@ export const TTSJobSchema = z.object({
     duration: z.number(),
     userId: z.string().nullable(),
     unregisteredUserId: z.string().nullable(),
+    tokenReservationId: z.string().nullable().optional(),
     isDeleted: z.boolean(),
     params: TTSJobParamsSchema,
     createdAt: z.date(),

package/tts/routes/tts.amqp.routes.ts

@@ -1,5 +1,6 @@
 export const TTS_AMQP_ROUTES = {
     EXECUTE: 'tools.tts.execute.rpc',
+    GET_PRICE: 'tools.tts.get-price.rpc',
     CONFIG: 'tools.tts.config.rpc',
     GET_JOB: 'tools.tts.jobs.get.rpc',
     LIST_JOBS: 'tools.tts.jobs.list.rpc',

package/video/commands/get-video-price.command.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { VideoGenerationRequestParamsSchema } from '../models';
+
+export namespace GetVideoPriceCommand {
+    export const RequestSchema = z.object({
+        modelId: z.string(),
+        params: VideoGenerationRequestParamsSchema,
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseDataSchema = z.object({
+        price: z.number(),
+    });
+
+    export const ResponseSchema = ICommandResponseSchema(ResponseDataSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/video/commands/index.ts

@@ -3,6 +3,7 @@ export * from './delete-all-video-jobs.command';
 export * from './retry-video-job.command';
 export * from './set-reaction-to-video-job.command';
 export * from './video.command';
+export * from './get-video-price.command';
 export * from './update-video-job-title.command';
 export * from './video-model';
 export * from './update-published-status-video-jobs.command';

package/video/commands/retry-video-job.command.ts

@@ -6,12 +6,13 @@ import { VideoGenerationRequestParamsSchema } from '../models';
 export namespace RetryVideoJobCommand {
     export const RequestSchema = z.object({
         uuid: z.string().uuid(),
-        userBalance: z.number(),
         userId: z.string().uuid().nullable().optional(),
         unregisteredUserId: z.string().uuid().nullable().optional(),
         prompt: z.string().optional(),
         modelId: z.string().uuid().optional(),
         params: VideoGenerationRequestParamsSchema.optional(),
+        tokenReservationId: z.string().uuid(),
+        precalculatedPrice: z.number(),
     });
     export type Request = z.infer<typeof RequestSchema>;
 

package/video/commands/update-published-status-video-jobs.command.ts

@@ -9,9 +9,15 @@ export namespace UpdatePublishedStatusVideoJobsCommand {
             userId: z.string().uuid().nullable().optional(),
             unregisteredUserId: z.string().uuid().nullable().optional(),
         }),
-        data: z.object({
-            isPublished: z.boolean(),
-        }),
+        data: z
+            .object({
+                isPublished: z.boolean(),
+                postId: z.string().nullable().optional(),
+            })
+            .refine((data) => (data.isPublished ? !!data.postId : true), {
+                message: 'Post ID is required when job is published',
+                path: ['postId'],
+            }),
     });
     export type Request = z.infer<typeof RequestSchema>;
 

package/video/commands/video.command.ts

@@ -8,9 +8,10 @@ export namespace VideoCommand {
         userId: z.string().uuid().nullable().optional(),
         unregisteredUserId: z.string().uuid().nullable().optional(),
         prompt: z.string(),
-        userBalance: z.number(),
         modelId: z.string(),
         params: VideoGenerationRequestParamsSchema,
+        tokenReservationId: z.string().uuid(),
+        precalculatedPrice: z.number(),
     });
     export type Request = z.infer<typeof RequestSchema>;
 

package/video/models/video-job.schema.ts

@@ -18,6 +18,8 @@ export const VideoJobSchema = z.object({
     uuid: z.string(),
     prompt: z.string(),
     reaction: z.nativeEnum(USER_REACTION).nullable(),
+    isPublished: z.boolean(),
+    postId: z.string().nullable(),
     dislikeReason: z.string().nullable(),
     externalId: z.string().nullable(),
     title: z.string(),
@@ -30,6 +32,7 @@ export const VideoJobSchema = z.object({
     attempts: z.array(z.any()),
     userId: z.string().nullable().optional(),
     unregisteredUserId: z.string().nullable().optional(),
+    tokenReservationId: z.string().nullable().optional(),
     isDeleted: z.boolean(),
     createdAt: z.date(),
     completedAt: z.date().nullable().optional(),

package/video/routes/video.amqp.routes.ts

@@ -1,5 +1,6 @@
 export const VIDEO_AMQP_ROUTES = {
     EXECUTE: 'tools.video.execute.rpc',
+    GET_PRICE: 'tools.video.get-price.rpc',
     CONFIG: 'tools.video.config.rpc',
     GET_JOB: 'tools.video.jobs.get.rpc',
     LIST_JOBS: 'tools.video.jobs.list.rpc',

package/video-editor/commands/edit-video.command.ts

@@ -10,8 +10,9 @@ export namespace EditVideoCommand {
         inputVideoId: z.string().uuid(),
         inputVideoUrl: z.string(),
         duration: z.number(),
-        userBalance: z.number(),
         modelId: z.string().uuid(),
+        tokenReservationId: z.string().uuid(),
+        precalculatedPrice: z.number(),
     });
     export type Request = z.infer<typeof RequestSchema>;
 

package/video-editor/commands/get-video-editor-price.command.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace GetVideoEditorPriceCommand {
+    export const RequestSchema = z.object({
+        modelId: z.string(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseDataSchema = z.object({
+        price: z.number(),
+    });
+
+    export const ResponseSchema = ICommandResponseSchema(ResponseDataSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/video-editor/commands/index.ts

@@ -5,4 +5,5 @@ export * from './set-reaction-to-video-editor-job.command';
 export * from './update-video-editor-job-title.command';
 export * from './update-published-status-video-editor-jobs.command';
 export * from './edit-video.command';
+export * from './get-video-editor-price.command';
 export * from './video-editor-model';

package/video-editor/commands/retry-video-editor-job.command.ts

@@ -5,7 +5,6 @@ import { VideoEditorJobSchema } from '../models/video-editor-job.schema';
 export namespace RetryVideoEditorJobCommand {
     export const RequestSchema = z.object({
         uuid: z.string().uuid(),
-        userBalance: z.number(),
         userId: z.string().uuid().nullable().optional(),
         unregisteredUserId: z.string().uuid().nullable().optional(),
         prompt: z.string().optional(),
@@ -13,6 +12,8 @@ export namespace RetryVideoEditorJobCommand {
         inputVideoUrl: z.string().optional(),
         duration: z.number().optional(),
         modelId: z.string().uuid().optional(),
+        tokenReservationId: z.string().uuid(),
+        precalculatedPrice: z.number(),
     });
     export type Request = z.infer<typeof RequestSchema>;
 

package/video-editor/commands/update-published-status-video-editor-jobs.command.ts

@@ -9,9 +9,15 @@ export namespace UpdatePublishedStatusVideoEditorJobsCommand {
             userId: z.string().uuid().nullable().optional(),
             unregisteredUserId: z.string().uuid().nullable().optional(),
         }),
-        data: z.object({
-            isPublished: z.boolean(),
-        }),
+        data: z
+            .object({
+                isPublished: z.boolean(),
+                postId: z.string().nullable().optional(),
+            })
+            .refine((data) => (data.isPublished ? !!data.postId : true), {
+                message: 'Post ID is required when job is published',
+                path: ['postId'],
+            }),
     });
     export type Request = z.infer<typeof RequestSchema>;
 

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

@@ -21,7 +21,9 @@ export const VideoEditorJobSchema = z.object({
     attempts: z.array(z.any()),
     userId: z.string().nullable().optional(),
     unregisteredUserId: z.string().nullable().optional(),
+    tokenReservationId: z.string().nullable().optional(),
     isPublished: z.boolean(),
+    postId: z.string().nullable(),
     isDeleted: z.boolean(),
     createdAt: z.date(),
     completedAt: z.date().nullable().optional(),

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

@@ -3,15 +3,11 @@ import { ICommandResponseSchema } from '../../common/models/command-response.sch
 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 const RequestSchema = z.object({
+        uuid: z.string(),
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+    });
     export type Request = z.infer<typeof RequestSchema>;
 
     export const ResponseSchema = ICommandResponseSchema(VideoEditorJobSchema);

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

@@ -1,5 +1,6 @@
 export const VIDEO_EDITOR_AMQP_ROUTES = {
     EXECUTE: 'tools.video-editor.execute.rpc',
+    GET_PRICE: 'tools.video-editor.get-price.rpc',
     CONFIG: 'tools.video-editor.config.rpc',
     GET_JOB: 'tools.video-editor.jobs.get.rpc',
     LIST_JOBS: 'tools.video-editor.jobs.list.rpc',

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

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

package/writer/commands/get-writer-content-generation-price.command.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common';
+
+export namespace GetWriterContentGenerationPriceCommand {
+    export const RequestSchema = z.object({
+        documentId: z.string().uuid(),
+        modelId: z.string().uuid(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseDataSchema = z.object({
+        price: z.number(),
+    });
+
+    export const ResponseSchema = ICommandResponseSchema(ResponseDataSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/writer/commands/index.ts

@@ -4,6 +4,7 @@ export * from './delete-all-user-writer-documents.command';
 export * from './update-writer-document-outline.command';
 export * from './export-writer-document-as-docx.command';
 export * from './generate-document-contents.command';
+export * from './get-writer-content-generation-price.command';
 export * from './writer-paraphrase.command';
 export * from './writer-extend-text.command';
 export * from './writer-shorten-text.command';

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

@@ -19,6 +19,7 @@ export const WriterDocumentSchema = z.object({
     dislikeReason: z.string().nullable(),
     pages: z.number(),
     isDeleted: z.boolean(),
+    tokenReservationId: z.string().nullable().optional(),
     createdAt: z.date(),
     updatedAt: z.date(),
     completedAt: z.date().nullable(),

package/writer/routes/writer.routes.ts

@@ -8,6 +8,7 @@ export const WRITER_AMQP_ROUTES = {
     UPDATE_DOCUMENT_OUTLINE: 'tools.writer.update-document-outline.rpc',
     UPDATE_DOCUMENT_CONTENTS: 'tools.writer.update-document-contents.rpc',
     GENERATE_DOCUMENT_CONTENTS: 'tools.writer.generate-document-contents.rpc',
+    GET_CONTENT_GENERATION_PRICE: 'tools.writer.content-generation.get-price.rpc',
     PARAPHRASE: 'tools.writer.actions.paraphrase.rpc',
     EXTEND_TEXT: 'tools.writer.actions.extend-text.rpc',
     SHORTEN_TEXT: 'tools.writer.actions.shorten-text.rpc',