@purpleschool/gptbot 0.11.4 → 0.11.6

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

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { SpellCorrectorToolJobSchema } from '../../../models';
+import { USER_REACTION } from '../../../constants';
+
+export namespace SetReactionToSpellCorrectorJobCommand {
+    export const RequestSchema = z
+        .object({
+            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 RequestParamsSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        data: SpellCorrectorToolJobSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { ToolJobSchema } from '../../../models';
+
+export namespace SpellCorrectorCommand {
+    export const RequestSchema = z.object({
+        modelId: z.string().uuid(),
+        prompt: z.string().min(1).max(100000),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: ToolJobSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { SpellCorrectorToolJobSchema } from '../../../models';
+
+export namespace UpdateSpellCorrectorJobTitleCommand {
+    export const RequestSchema = z.object({
+        title: z.string().min(1).max(40).trim(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const RequestParamsSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        data: SpellCorrectorToolJobSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -6,6 +6,8 @@ export namespace EditVideoCommand {
         modelId: z.string().uuid(),
         prompt: z.string(),
         fileId: z.string().uuid(),
+        resolution: z.string().optional(),
+        duration: z.number().optional(),
     });
 
     export type Request = z.infer<typeof RequestSchema>;

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

@@ -12,6 +12,8 @@ export namespace RetryVideoEditorJobCommand {
         modelId: z.string().uuid().optional(),
         prompt: z.string().optional(),
         fileId: z.string().uuid().optional(),
+        resolution: z.string().optional(),
+        duration: z.number().optional(),
     });
     export type RequestBody = z.infer<typeof RequestBodySchema>;
 

package/commands/unregistered-user/index.ts

@@ -1 +1,2 @@
 export * from './create-unregistered-user.command';
+export * from './patch-locale.command';

package/commands/unregistered-user/patch-locale.command.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { LOCALE } from '../../constants';
+
+export namespace PatchUnregisteredUserLocaleCommand {
+    export const RequestSchema = z.object({
+        locale: z.nativeEnum(LOCALE),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            locale: z.nativeEnum(LOCALE),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/user/get-me.command.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { ROLE, SIGNUP_METHOD, USER_STATUS } from '../../constants';
+import { LOCALE, ROLE, SIGNUP_METHOD, USER_STATUS } from '../../constants';
 import { UserProfileResponseSchema } from '../../models';
 
 export namespace GetMeCommand {
@@ -17,6 +17,7 @@ export namespace GetMeCommand {
             telegramId: z.number().nullable(),
             telegramUserName: z.string().nullable(),
             webmasterId: z.string().uuid().nullable(),
+            locale: z.nativeEnum(LOCALE),
             profile: UserProfileResponseSchema,
         }),
     });

package/commands/user/index.ts

@@ -1,6 +1,7 @@
 export * from './check-email.command';
 export * from './find-user-by-uuid.command';
 export * from './get-me.command';
+export * from './patch-locale.command';
 export * from './up-token-bonus-balance.command';
 export * from './find-users-by-criteria.command';
 export * from './get-user-balance.command';

package/commands/user/patch-locale.command.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { LOCALE } from '../../constants';
+
+export namespace PatchUserLocaleCommand {
+    export const RequestSchema = z.object({
+        locale: z.nativeEnum(LOCALE),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            locale: z.nativeEnum(LOCALE),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/constants/ai-model/enums/ai-model-strategy.enum.ts

@@ -10,6 +10,7 @@ export enum AI_MODEL_STRATEGY {
     STABLE_DIFFUSION_IMAGE_GENERATION = 'stable_diffusion_image_generation',
     LLAMA_TEXT_GENERATION = 'llama_text_generation',
     QWEN_TEXT_GENERATION = 'qwen_text_generation',
+    KIE_OPENAI_TEXT_GENERATION = 'kie_openai_text_generation',
     GROK_IMAGE_GENERATION = 'grok_image_generation',
     GEMINI_TEXT_GENERATION = 'gemini_text_generation',
     GEMINI_IMAGE_GENERATION = 'gemini_image_generation',

package/constants/model/enums/unified-model-content-type.enum.ts

@@ -15,4 +15,6 @@ export enum UNIFIED_MODEL_CONTENT_TYPE {
     IMAGE_GENERATION = 'IMAGE_GENERATION',
     INTERIOR_DESIGN = 'INTERIOR_DESIGN',
     MARKETPLACE_CARD = 'MARKETPLACE_CARD',
+    SOLVING_EDU_TASK = 'SOLVING_EDU_TASK',
+    SPELL_CORRECTOR = 'SPELL_CORRECTOR',
 }

package/constants/subscription/enums/subscription-feature-type.enum.ts

@@ -25,6 +25,12 @@ export enum SUBSCRIPTION_FEATURE_TYPE {
     IMAGE_EDITOR_MODEL_ACCESS = 'image_editor_model_access',
     INTERIOR_DESIGN_QUOTA = 'interior_design_quota',
     INTERIOR_DESIGN_MODEL_ACCESS = 'interior_design_model_access',
+    SPELL_CORRECTOR_QUOTA = 'spell_corrector_quota',
+    SPELL_CORRECTOR_MODEL_ACCESS = 'spell_corrector_model_access',
+    PARAPHRASE_TYPE_ACCESS = 'paraphrase_type_access',
+    MARKETPLACE_CARD_MODEL_ACCESS = 'marketplace_card_model_access',
+    EDU_TASK_MODEL_ACCESS = 'edu_task_model_access',
+    VIDEO_EDITOR_MODEL_ACCESS = 'video_editor_model_access',
 }
 
 export enum SUBSCRIPTION_FEATURE_KIND {
@@ -33,7 +39,6 @@ export enum SUBSCRIPTION_FEATURE_KIND {
     IMAGE_GENERATION = 'image_generation',
     TTS = 'tts',
     STT = 'stt',
-    PRESENTATIONS = 'presentations',
     VIDEO = 'video',
     PRESENTATION = 'presentation',
     BASE = 'base',
@@ -41,4 +46,9 @@ export enum SUBSCRIPTION_FEATURE_KIND {
     WRITER = 'writer',
     IMAGE_EDITOR = 'image_editor',
     INTERIOR_DESIGN = 'interior_design',
+    SPELL_CORRECTOR = 'spell_corrector',
+    PARAPHRASE = 'paraphrase',
+    MARKETPLACE_CARD = 'marketplace_card',
+    EDU_TASK = 'edu_task',
+    VIDEO_EDITOR = 'video_editor',
 }

package/constants/tool-video-editor/enums/index.ts

@@ -1 +1,2 @@
 export * from './video-editor-model-strategy.enum';
+export * from './video-editor-pricing-rule-type.enum';

package/constants/tool-video-editor/enums/video-editor-pricing-rule-type.enum.ts

@@ -0,0 +1,4 @@
+export enum VIDEO_EDITOR_PRICING_RULE_TYPE {
+    FLAT = 'flat',
+    PER_SECOND = 'per_second',
+}

package/constants/user/enums/index.ts

@@ -2,3 +2,4 @@ export * from './singup-method.enum';
 export * from './user-status';
 export * from './user-sort-by.enum';
 export * from './sort-order.enum';
+export * from './locale.enum';

package/constants/user/enums/locale.enum.ts

@@ -0,0 +1,4 @@
+export enum LOCALE {
+    RU = 'ru',
+    EN = 'en',
+}

package/helpers/video-editor/calculate-video-editing-price.helper.ts

@@ -1,3 +1,53 @@
-export function calculateVideoEditingPrice({ pricePerCall }: { pricePerCall: number }) {
-    return pricePerCall;
+import { VIDEO_EDITOR_PRICING_RULE_TYPE } from '../../constants';
+import {
+    VideoEditorModelPricingRuleCondition,
+    VideoEditorModelPricingRules,
+    VideoEditorPricingRequestParams,
+} from '../../models';
+
+function matchesCondition(
+    condition: VideoEditorModelPricingRuleCondition,
+    params: VideoEditorPricingRequestParams,
+): boolean {
+    const keys = Object.keys(condition) as (keyof VideoEditorModelPricingRuleCondition)[];
+
+    return keys.every((key) => {
+        const expected = condition[key];
+        if (expected === undefined || expected === null || expected === '') {
+            return true;
+        }
+
+        const value = params[key];
+        if (value === undefined || value === null) {
+            return false;
+        }
+
+        return value === expected;
+    });
+}
+
+export function calculateVideoEditingPrice({
+    pricePerCall,
+    params,
+    rules,
+}: {
+    pricePerCall: number;
+    params: VideoEditorPricingRequestParams;
+    rules: VideoEditorModelPricingRules;
+}): number {
+    const perSecondRule = rules
+        .filter((r) => r.type === VIDEO_EDITOR_PRICING_RULE_TYPE.PER_SECOND)
+        .find((r) => matchesCondition(r.condition, params));
+
+    const base = perSecondRule ? perSecondRule.value * params.duration : pricePerCall;
+
+    const flatMarkup = rules.reduce((sum, r) => {
+        if (r.type !== VIDEO_EDITOR_PRICING_RULE_TYPE.FLAT) {
+            return sum;
+        }
+
+        return matchesCondition(r.condition, params) ? sum + r.value : sum;
+    }, 0);
+
+    return Math.ceil(base + flatMarkup);
 }

package/models/subscription-feature.schema.ts

@@ -214,6 +214,57 @@ export type InteriorDesignModelAccessFeature = z.infer<
     typeof InteriorDesignModelAccessFeatureSchema
 >;
 
+export const SpellCorrectorQuotaFeatureSchema = SubscriptionFeatureBaseSchema.extend({
+    kind: z.literal(SUBSCRIPTION_FEATURE_KIND.SPELL_CORRECTOR),
+    type: z.literal(SUBSCRIPTION_FEATURE_TYPE.SPELL_CORRECTOR_QUOTA),
+    value: z.number(),
+});
+export type SpellCorrectorQuotaFeature = z.infer<typeof SpellCorrectorQuotaFeatureSchema>;
+
+export const SpellCorrectorModelAccessFeatureSchema = SubscriptionFeatureBaseSchema.extend({
+    kind: z.literal(SUBSCRIPTION_FEATURE_KIND.SPELL_CORRECTOR),
+    type: z.literal(SUBSCRIPTION_FEATURE_TYPE.SPELL_CORRECTOR_MODEL_ACCESS),
+    isAvailable: z.boolean(),
+    modelId: z.string(),
+});
+export type SpellCorrectorModelAccessFeature = z.infer<
+    typeof SpellCorrectorModelAccessFeatureSchema
+>;
+
+export const ParaphraseTypeAccessFeatureSchema = SubscriptionFeatureBaseSchema.extend({
+    kind: z.literal(SUBSCRIPTION_FEATURE_KIND.PARAPHRASE),
+    type: z.literal(SUBSCRIPTION_FEATURE_TYPE.PARAPHRASE_TYPE_ACCESS),
+    isAvailable: z.boolean(),
+    modelId: z.string(),
+});
+export type ParaphraseTypeAccessFeature = z.infer<typeof ParaphraseTypeAccessFeatureSchema>;
+
+export const MarketplaceCardModelAccessFeatureSchema = SubscriptionFeatureBaseSchema.extend({
+    kind: z.literal(SUBSCRIPTION_FEATURE_KIND.MARKETPLACE_CARD),
+    type: z.literal(SUBSCRIPTION_FEATURE_TYPE.MARKETPLACE_CARD_MODEL_ACCESS),
+    isAvailable: z.boolean(),
+    modelId: z.string(),
+});
+export type MarketplaceCardModelAccessFeature = z.infer<
+    typeof MarketplaceCardModelAccessFeatureSchema
+>;
+
+export const EduTaskModelAccessFeatureSchema = SubscriptionFeatureBaseSchema.extend({
+    kind: z.literal(SUBSCRIPTION_FEATURE_KIND.EDU_TASK),
+    type: z.literal(SUBSCRIPTION_FEATURE_TYPE.EDU_TASK_MODEL_ACCESS),
+    isAvailable: z.boolean(),
+    modelId: z.string(),
+});
+export type EduTaskModelAccessFeature = z.infer<typeof EduTaskModelAccessFeatureSchema>;
+
+export const VideoEditorModelAccessFeatureSchema = SubscriptionFeatureBaseSchema.extend({
+    kind: z.literal(SUBSCRIPTION_FEATURE_KIND.VIDEO_EDITOR),
+    type: z.literal(SUBSCRIPTION_FEATURE_TYPE.VIDEO_EDITOR_MODEL_ACCESS),
+    isAvailable: z.boolean(),
+    modelId: z.string(),
+});
+export type VideoEditorModelAccessFeature = z.infer<typeof VideoEditorModelAccessFeatureSchema>;
+
 export const SubscriptionFeatureSchema = z.union([
     AiModelAccessFeatureSchema,
     RequestsQuotaFeatureSchema,
@@ -240,6 +291,12 @@ export const SubscriptionFeatureSchema = z.union([
     InteriorDesignQuotaFeatureSchema,
     InteriorDesignModelAccessFeatureSchema,
     ImageGenerationAccessFeatureSchema,
+    SpellCorrectorQuotaFeatureSchema,
+    SpellCorrectorModelAccessFeatureSchema,
+    ParaphraseTypeAccessFeatureSchema,
+    MarketplaceCardModelAccessFeatureSchema,
+    EduTaskModelAccessFeatureSchema,
+    VideoEditorModelAccessFeatureSchema,
 ]);
 
 export type SubscriptionFeature = z.infer<typeof SubscriptionFeatureSchema>;

package/models/subscription.schema.ts

@@ -58,3 +58,14 @@ export const SubscriptionWithSubTypesSchema = z.intersection(
 export const SubscriptionWithFeaturesSchema = SubscriptionSchema.extend({
     features: z.array(SubscriptionFeatureSchema),
 });
+
+export const SubscriptionWithoutFeaturesSchema = SubscriptionSchema.omit({
+    features: true,
+});
+
+export const SubscriptionWithSubTypesWithoutFeaturesSchema = z.intersection(
+    SubscriptionWithoutFeaturesSchema,
+    z.object({
+        subTypes: z.array(SubscriptionWithoutFeaturesSchema),
+    }),
+);

package/models/team-account/team-account-invite.schema.ts

@@ -16,3 +16,7 @@ export const TeamAccountInviteSchema = z.object({
     createdAt: z.date(),
     updatedAt: z.date(),
 });
+
+export const TeamAccountInviteResponseSchema = TeamAccountInviteSchema.omit({
+    tokenHash: true,
+});

package/models/tools/image-editor/image-editor-model.schema.ts

@@ -40,6 +40,8 @@ export const ImageEditorModelSchema = z.object({
     uuid: z.string(),
     title: z.string(),
     description: z.string(),
+    isNew: z.boolean(),
+    tierLabel: z.string(),
     pricePerImage: z.number(),
     order: z.number(),
     icons: IconVariantsSchema,

package/models/tools/image-generation/image-generation-model.schema.ts

@@ -43,6 +43,7 @@ export const ImageGenerationModelSchema = z.object({
     order: z.number(),
     status: z.string(),
     price: z.number(),
+    isNew: z.boolean(),
     params: ImageGenerationModelParamsSchema,
     supportsImageAttachment: z.boolean(),
     maxAttachedImages: z.number(),

package/models/tools/index.ts

@@ -13,3 +13,4 @@ export * from './image-generation';
 export * from './marketplace-card';
 export * from './interior-design';
 export * from './solving-edu-task';
+export * from './spell-corrector';

package/models/tools/spell-corrector/index.ts

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

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

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

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

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { ToolJobSchema } from '../../tool-job.schema';
+import { USER_REACTION } from '../../../constants';
+
+export const SpellCorrectorToolJobSchema = ToolJobSchema.extend({
+    modelId: z.string().uuid().nullable().optional(),
+    userInput: z.string(),
+    aiOutput: z.string().nullable().optional(),
+    title: z.string(),
+    reaction: z.nativeEnum(USER_REACTION).nullable(),
+});

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

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { IconVariantsSchema } from '../../icon-variants.schema';
+import { UnlockedBySchema } from '../../unlocked-by-subscription.schema';
+
+export const SpellCorrectorModelSchema = z.object({
+    uuid: z.string().uuid(),
+    title: z.string(),
+    description: z.string(),
+    icon: z.string(),
+    price: z.number(),
+    order: z.number(),
+    canUse: z.boolean(),
+    icons: IconVariantsSchema,
+    unlockedBy: UnlockedBySchema.nullable(),
+});

package/models/tools/stt/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/models/tools/video/video-config.schema.ts

@@ -1,6 +1,19 @@
 import { z } from 'zod';
 import { VideoModelSchema } from './video-model.schema';
+import { IconVariantsSchema } from '../../icon-variants.schema';
 
-export const VideoConfigSchema = z.object({
+export const VideoVendorSchema = z.object({
+    uuid: z.string().uuid(),
+    title: z.string(),
+    order: z.number(),
+    icons: IconVariantsSchema,
     models: z.array(VideoModelSchema),
 });
+
+export type VideoVendor = z.infer<typeof VideoVendorSchema>;
+
+export const VideoConfigSchema = z.object({
+    vendors: z.array(VideoVendorSchema),
+});
+
+export type VideoConfig = z.infer<typeof VideoConfigSchema>;

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

@@ -2,6 +2,13 @@ import { z } from 'zod';
 import { USER_REACTION } from '../../../constants';
 import { ToolJobSchema } from '../../tool-job.schema';
 
+export const VideoEditorJobParamsSchema = z.object({
+    duration: z.number().optional(),
+    resolution: z.string().optional(),
+});
+
+export type VideoEditorJobParams = z.infer<typeof VideoEditorJobParamsSchema>;
+
 export const VideoEditorJobSchema = ToolJobSchema.extend({
     title: z.string(),
     prompt: z.string(),
@@ -21,6 +28,7 @@ export const VideoEditorJobSchema = ToolJobSchema.extend({
             url: z.string(),
         })
         .nullable(),
+    params: VideoEditorJobParamsSchema.optional(),
     modelId: z.string(),
     isPublished: z.boolean(),
     postId: z.string().nullable(),

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

@@ -1,11 +1,44 @@
 import { z } from 'zod';
 import { VIDEO_EDITOR_MODEL_LIMITATION } from '../../../constants/tool-video-editor/enums/video-editor-model-limitation.enum';
+import { VIDEO_EDITOR_PRICING_RULE_TYPE } from '../../../constants/tool-video-editor/enums/video-editor-pricing-rule-type.enum';
 import { IconVariantsSchema } from '../../icon-variants.schema';
 import { UnlockedBySchema } from '../../unlocked-by-subscription.schema';
 
 export const VideoEditorModelParamsSchema = z.object({
-    supportedFormats: z.array(z.string()),
+    duration: z
+        .object({
+            options: z.array(z.number()),
+        })
+        .optional(),
+    resolution: z
+        .object({
+            options: z.array(z.string()),
+        })
+        .optional(),
+});
+
+export const VideoEditorPricingRequestParamsSchema = z.object({
+    duration: z.number(),
+    resolution: z.string().optional(),
 });
+export type VideoEditorPricingRequestParams = z.infer<typeof VideoEditorPricingRequestParamsSchema>;
+
+export const VideoEditorModelPricingRuleConditionSchema = z.object({
+    duration: z.number().optional(),
+    resolution: z.string().optional(),
+});
+export type VideoEditorModelPricingRuleCondition = z.infer<
+    typeof VideoEditorModelPricingRuleConditionSchema
+>;
+
+export const VideoEditorModelPricingRulesSchema = z.array(
+    z.object({
+        type: z.nativeEnum(VIDEO_EDITOR_PRICING_RULE_TYPE),
+        condition: VideoEditorModelPricingRuleConditionSchema,
+        value: z.number(),
+    }),
+);
+export type VideoEditorModelPricingRules = z.infer<typeof VideoEditorModelPricingRulesSchema>;
 
 export const VideoEditorModelSchema = z.object({
     uuid: z.string(),
@@ -19,6 +52,8 @@ export const VideoEditorModelSchema = z.object({
     maxInputVideoSizeBytes: z.number(),
     maxInputVideoDurationInSeconds: z.number(),
     supportedFormats: z.array(z.string()),
+    params: VideoEditorModelParamsSchema,
+    pricingRules: VideoEditorModelPricingRulesSchema,
     createdAt: z.date(),
     updatedAt: z.date(),
     unlockedBy: UnlockedBySchema.nullable(),

package/models/user.schema.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { UserToSubscriptionSchema } from './user-to-subscription.schema';
 import { UserToProductSchema } from './user-to-product.schema';
+import { LOCALE } from '../constants';
 
 export const UserSchema = z.object({
     uuid: z.string().uuid(),
@@ -13,6 +14,7 @@ export const UserSchema = z.object({
     restoreTokenHash: z.string(),
     tokenBonusBalance: z.number(),
     role: z.string(),
+    locale: z.nativeEnum(LOCALE),
 
     createdAt: z.date(),
     updatedAt: z.date(),

package/package.json

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