@purpleschool/gptbot-tools 0.1.134 → 0.2.0-stage

package/solving-edu-task/commands/index.ts

@@ -0,0 +1,7 @@
+export * from './delete-all-solving-edu-task-jobs.command';
+export * from './delete-solving-edu-task-job-by-uuid.command';
+export * from './get-solving-edu-task-price.command';
+export * from './retry-solving-edu-task-job.command';
+export * from './set-reaction-to-solving-edu-task-job.command';
+export * from './solving-edu-task.command';
+export * from './update-solving-edu-task-job-title.command';

package/solving-edu-task/commands/retry-solving-edu-task-job.command.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { SolvingEduTaskJobSchema } from '../models';
+import { AttachedFileSchema } from '../../common';
+
+export namespace RetrySolvingEduTaskJobCommand {
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+        tokenReservationId: z.string().uuid().optional(),
+        precalculatedPrice: z.number().optional(),
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        prompt: z.string().optional(),
+        modelId: z.string().uuid().optional(),
+        params: z
+            .object({
+                attachedFiles: z.array(AttachedFileSchema),
+            })
+            .optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(SolvingEduTaskJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/solving-edu-task/commands/set-reaction-to-solving-edu-task-job.command.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { USER_REACTION } from '../../common';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { SolvingEduTaskJobSchema } from '../models';
+
+export namespace SetReactionToSolvingEduTaskJobCommand {
+    export const RequestSchema = z
+        .object({
+            userId: z.string().uuid().nullable().optional(),
+            unregisteredUserId: z.string().uuid().nullable().optional(),
+            uuid: z.string().uuid(),
+            reaction: z.nativeEnum(USER_REACTION).nullable(),
+            dislikeReason: z.string().nullable().default(null),
+        })
+        .refine(
+            (data) => {
+                if (data.reaction !== USER_REACTION.DISLIKED && data.dislikeReason) {
+                    return false;
+                }
+                return true;
+            },
+            {
+                message: 'Dislike reason is not allowed when reaction is not disliked',
+            },
+        );
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(SolvingEduTaskJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/solving-edu-task/commands/solving-edu-task.command.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { SolvingEduTaskJobSchema } from '../models';
+import { AttachedFileSchema } from '../../common';
+
+export namespace SolvingEduTaskCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        prompt: z.string(),
+        modelId: z.string().uuid(),
+        params: z.object({
+            attachedFiles: z.array(AttachedFileSchema),
+        }),
+        tokenReservationId: z.string().uuid().optional(),
+        precalculatedPrice: z.number().optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(SolvingEduTaskJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/solving-edu-task/commands/update-solving-edu-task-job-title.command.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { SolvingEduTaskJobSchema } from '../models';
+import { ICommandResponseSchema } from '../../common';
+
+export namespace UpdateSolvingEduTaskJobTitleCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        uuid: z.string().uuid(),
+        title: z.string(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(SolvingEduTaskJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/solving-edu-task/index.ts

@@ -0,0 +1,4 @@
+export * from './commands';
+export * from './models';
+export * from './queries';
+export * from './routes';

package/solving-edu-task/models/index.ts

@@ -0,0 +1,3 @@
+export * from './solving-edu-task-config.schema';
+export * from './solving-edu-task-job.schema';
+export * from './solving-edu-task-model.schema';

package/solving-edu-task/models/solving-edu-task-config.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { SolvingEduTaskModelSchema } from './solving-edu-task-model.schema';
+
+export const SolvingEduTaskConfigSchema = z.object({
+    models: z.array(SolvingEduTaskModelSchema),
+});
+
+export type SolvingEduTaskConfig = z.infer<typeof SolvingEduTaskConfigSchema>;

package/solving-edu-task/models/solving-edu-task-job.schema.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { JOB_STATUS } from '../../tools';
+import { AttachedFileSchema, USER_REACTION } from '../../common';
+
+export const SolvingEduTaskJobParamsSchema = z.object({
+    attachedFiles: z.array(AttachedFileSchema),
+});
+
+export type SolvingEduTaskJobParams = z.infer<typeof SolvingEduTaskJobParamsSchema>;
+
+export const SolvingEduTaskJobSchema = z.object({
+    uuid: z.string(),
+    prompt: z.string(),
+    aiOutput: z.string().nullable().optional(),
+    reaction: z.nativeEnum(USER_REACTION).nullable(),
+    dislikeReason: z.string().nullable(),
+    externalId: z.string().nullable(),
+    title: z.string(),
+    status: z.nativeEnum(JOB_STATUS),
+    error: z.string().nullable(),
+    internalError: z.string().nullable().optional(),
+    modelId: z.string(),
+    price: z.number(),
+    params: SolvingEduTaskJobParamsSchema,
+    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(),
+    updatedAt: z.date(),
+});
+
+export type SolvingEduTaskJob = z.infer<typeof SolvingEduTaskJobSchema>;

package/solving-edu-task/models/solving-edu-task-model.schema.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { IconVariantsSchema, TOOL_MODEL_STATUS } from '../../common';
+
+export const SolvingEduTaskModelParamsSchema = z.object({
+    imageAttachment: z.object({
+        supported: z.boolean(),
+        maxImages: z.number(),
+        acceptedTypes: z.array(z.string()),
+    }),
+});
+
+export type SolvingEduTaskModelParams = z.infer<typeof SolvingEduTaskModelParamsSchema>;
+
+export const SolvingEduTaskModelSchema = z.object({
+    uuid: z.string(),
+    title: z.string(),
+    description: z.string(),
+    aiModel: z.string(),
+    price: z.number(),
+    order: z.number(),
+    status: z.nativeEnum(TOOL_MODEL_STATUS),
+    icons: IconVariantsSchema,
+    strategy: z.string(),
+    maxPromptLength: z.number(),
+    params: SolvingEduTaskModelParamsSchema,
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type SolvingEduTaskModel = z.infer<typeof SolvingEduTaskModelSchema>;

package/solving-edu-task/queries/find-solving-edu-task-job-by-id.query.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common';
+import { SolvingEduTaskJobSchema } from '../models';
+
+export namespace FindSolvingEduTaskJobByIdQuery {
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(SolvingEduTaskJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/solving-edu-task/queries/find-solving-edu-task-jobs.query.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { SolvingEduTaskJobSchema } from '../models';
+
+export namespace FindSolvingEduTaskJobsQuery {
+    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 !(data.userId && data.unregisteredUserId);
+            },
+            {
+                message: 'userId and unregisteredUserId cannot be used together',
+                path: ['userId', 'unregisteredUserId'],
+            },
+        );
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(
+        z.object({
+            data: z.array(SolvingEduTaskJobSchema),
+            page: z.number(),
+            totalPages: z.number(),
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/solving-edu-task/queries/get-solving-edu-task-config.query.ts

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

package/solving-edu-task/queries/index.ts

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

package/solving-edu-task/routes/index.ts

@@ -0,0 +1 @@
+export * from './solving-edu-task.amqp.routes';

package/solving-edu-task/routes/solving-edu-task.amqp.routes.ts

@@ -0,0 +1,12 @@
+export const SOLVING_EDU_TASK_AMQP_ROUTES = {
+    EXECUTE: 'tools.solving-edu-task.execute.rpc',
+    GET_PRICE: 'tools.solving-edu-task.get-price.rpc',
+    CONFIG: 'tools.solving-edu-task.config.rpc',
+    GET_JOB: 'tools.solving-edu-task.jobs.get.rpc',
+    LIST_JOBS: 'tools.solving-edu-task.jobs.list.rpc',
+    SET_REACTION: 'tools.solving-edu-task.jobs.set-reaction.rpc',
+    UPDATE_TITLE: 'tools.solving-edu-task.jobs.update-title.rpc',
+    SOFT_DELETE: 'tools.solving-edu-task.jobs.soft-delete.rpc',
+    SOFT_DELETE_ALL: 'tools.solving-edu-task.jobs.soft-delete-all.rpc',
+    RETRY: 'tools.solving-edu-task.jobs.retry.rpc',
+} as const;

package/spell-corrector/commands/delete-all-spell-corrector-jobs.command.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace DeleteAllSpellCorrectorJobsCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(z.boolean());
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/spell-corrector/commands/delete-spell-corrector-job-by-uuid.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace DeleteSpellCorrectorJobByUuidCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        uuid: z.string(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(z.boolean());
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/spell-corrector/commands/get-spell-corrector-price.command.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace GetSpellCorrectorPriceCommand {
+    export const RequestSchema = z.object({
+        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/spell-corrector/commands/index.ts

@@ -0,0 +1,7 @@
+export * from './spell-corrector.command';
+export * from './get-spell-corrector-price.command';
+export * from './retry-spell-corrector-job.command';
+export * from './set-reaction-to-spell-corrector-job.command';
+export * from './update-spell-corrector-job-title.command';
+export * from './delete-all-spell-corrector-jobs.command';
+export * from './delete-spell-corrector-job-by-uuid.command';

package/spell-corrector/commands/retry-spell-corrector-job.command.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { SpellCorrectorJobSchema } from '../models';
+
+export namespace RetrySpellCorrectorJobCommand {
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+        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>;
+
+    export const ResponseSchema = ICommandResponseSchema(SpellCorrectorJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/spell-corrector/commands/set-reaction-to-spell-corrector-job.command.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { SpellCorrectorJobSchema } from '../models';
+import { USER_REACTION } from '../../common';
+
+export namespace SetReactionToSpellCorrectorJobCommand {
+    export const RequestSchema = z
+        .object({
+            userId: z.string().uuid().nullable().optional(),
+            unregisteredUserId: z.string().uuid().nullable().optional(),
+            uuid: z.string().uuid(),
+            reaction: z.nativeEnum(USER_REACTION).nullable(),
+            dislikeReason: z.string().nullable().default(null),
+        })
+        .refine(
+            (data) => {
+                if (data.reaction !== USER_REACTION.DISLIKED && data.dislikeReason) {
+                    return false;
+                }
+                return true;
+            },
+            {
+                message: 'Dislike reason is not allowed when reaction is not disliked',
+            },
+        );
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(SpellCorrectorJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/spell-corrector/commands/spell-corrector.command.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { SpellCorrectorJobSchema } from '../models';
+
+export namespace SpellCorrectorCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        prompt: z.string(),
+        modelId: z.string().uuid(),
+        tokenReservationId: z.string().uuid(),
+        precalculatedPrice: z.number(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(SpellCorrectorJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/spell-corrector/commands/update-spell-corrector-job-title.command.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { SpellCorrectorJobSchema } from '../models';
+
+export namespace UpdateSpellCorrectorJobTitleCommand {
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        title: z.string().min(1).max(40),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(SpellCorrectorJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/spell-corrector/index.ts

@@ -0,0 +1,4 @@
+export * from './routes';
+export * from './commands';
+export * from './models';
+export * from './queries';

package/spell-corrector/models/index.ts

@@ -0,0 +1,3 @@
+export * from './spell-corrector-model.schema';
+export * from './spell-corrector-job.schema';
+export * from './spell-corrector-tool-config.schema';

package/spell-corrector/models/spell-corrector-job.schema.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { JOB_STATUS } from '../../tools';
+import { USER_REACTION } from '../../common';
+
+export const SpellCorrectorJobSchema = z.object({
+    uuid: z.string(),
+    userId: z.string().nullable(),
+    unregisteredUserId: z.string().nullable(),
+    userInput: z.string(),
+    aiOutput: z.string().nullable(),
+    aiTokenUsage: z.number().nullable(),
+    price: z.number(),
+    status: z.nativeEnum(JOB_STATUS),
+    title: z.string(),
+    error: z.string().nullable(),
+    reaction: z.nativeEnum(USER_REACTION).nullable(),
+    dislikeReason: z.string().nullable(),
+    modelId: z.string(),
+    tokenReservationId: z.string().nullable().optional(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+    completedAt: z.date().nullable(),
+});
+
+export type SpellCorrectorJob = z.infer<typeof SpellCorrectorJobSchema>;

package/spell-corrector/models/spell-corrector-model.schema.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { IconVariantsSchema, REASONING_EFFORT } from '../../common';
+
+export const SpellCorrectorModelSchema = z.object({
+    uuid: z.string(),
+    title: z.string(),
+    description: z.string(),
+    icon: z.string(),
+    icons: IconVariantsSchema,
+    price: z.number(),
+    aiModel: z.string(),
+    reasoningEffort: z.nativeEnum(REASONING_EFFORT).nullable().optional(),
+    order: z.number(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type SpellCorrectorModel = z.infer<typeof SpellCorrectorModelSchema>;

package/spell-corrector/models/spell-corrector-tool-config.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { SpellCorrectorModelSchema } from './spell-corrector-model.schema';
+
+export const SpellCorrectorToolConfigSchema = z.object({
+    models: z.array(SpellCorrectorModelSchema),
+    maxSymbols: z.number(),
+});
+
+export type SpellCorrectorTool = z.infer<typeof SpellCorrectorToolConfigSchema>;

package/spell-corrector/queries/find-spell-corrector-job-by-uuid.query.ts

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

package/spell-corrector/queries/find-spell-corrector-jobs.query.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { SpellCorrectorJobSchema } from '../models';
+
+export namespace FindSpellCorrectorJobsQuery {
+    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(SpellCorrectorJobSchema),
+            page: z.number(),
+            totalPages: z.number(),
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/spell-corrector/queries/get-spell-corrector-tool-config.query.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { SpellCorrectorToolConfigSchema } from '../models';
+
+export namespace GetSpellCorrectorToolConfigQuery {
+    export const ResponseSchema = ICommandResponseSchema(SpellCorrectorToolConfigSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/spell-corrector/queries/index.ts

@@ -0,0 +1,3 @@
+export * from './find-spell-corrector-job-by-uuid.query';
+export * from './get-spell-corrector-tool-config.query';
+export * from './find-spell-corrector-jobs.query';

package/spell-corrector/routes/index.ts

@@ -0,0 +1 @@
+export * from './spell-corrector.amqp.routes';

package/spell-corrector/routes/spell-corrector.amqp.routes.ts

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

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

@@ -3,6 +3,8 @@ import { z } from 'zod';
 export const STTResponseSchema = z.object({
     raw: z.object({}),
     md: z.string(),
+    txtUrl: z.string().optional(),
+    srtUrl: z.string().optional(),
 });
 
 export type STTResponse = z.infer<typeof STTResponseSchema>;

package/tool-workspace/commands/index.ts

@@ -0,0 +1,2 @@
+export * from './update-tool-workspace.command';
+export * from './soft-delete-tool-workspace.command';

package/tool-workspace/commands/soft-delete-tool-workspace.command.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace SoftDeleteToolWorkspaceCommand {
+    export const RequestSchema = z
+        .object({
+            uuid: z.string().uuid(),
+            userId: z.string().uuid().optional(),
+            unregisteredUserId: z.string().uuid().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({ success: z.boolean() }));
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/tool-workspace/commands/update-tool-workspace.command.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { TOOL_WORKSPACE_STATUS } from '../enums';
+import { ToolWorkspaceSchema } from '../models';
+
+export namespace UpdateToolWorkspaceCommand {
+    export const RequestSchema = z
+        .object({
+            uuid: z.string().uuid(),
+            title: z.string().min(1).optional(),
+            coverUrl: z.string().nullable().optional(),
+            status: z.nativeEnum(TOOL_WORKSPACE_STATUS).optional(),
+            userId: z.string().uuid().optional(),
+            unregisteredUserId: z.string().uuid().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(ToolWorkspaceSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/tool-workspace/enums/index.ts

@@ -0,0 +1,2 @@
+export * from './tool-workspace-status.enum';
+export * from './tool-workspace-item-slot.enum';