@purpleschool/gptbot-tools 0.1.5 → 0.1.7

package/build/spell-corrector/models/spell-corrector-model.schema.js

@@ -6,7 +6,9 @@ const common_1 = require("../../common");
 exports.SpellCorrectorModelSchema = zod_1.z.object({
     uuid: zod_1.z.string(),
     title: zod_1.z.string(),
+    description: zod_1.z.string(),
     icon: zod_1.z.string(),
+    icons: common_1.IconVariantsSchema,
     price: zod_1.z.number(),
     aiModel: zod_1.z.string(),
     reasoningEffort: zod_1.z.nativeEnum(common_1.REASONING_EFFORT).nullable().optional(),

package/build/video-editor/commands/edit-video.command.js

@@ -16,6 +16,7 @@ var EditVideoCommand;
         modelId: zod_1.z.string().uuid(),
         tokenReservationId: zod_1.z.string().uuid(),
         precalculatedPrice: zod_1.z.number(),
+        params: models_1.VideoEditorJobParamsSchema.optional(),
     });
     EditVideoCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.VideoEditorJobSchema);
 })(EditVideoCommand || (exports.EditVideoCommand = EditVideoCommand = {}));

package/build/video-editor/commands/get-video-editor-price.command.js

@@ -3,10 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GetVideoEditorPriceCommand = void 0;
 const zod_1 = require("zod");
 const command_response_schema_1 = require("../../common/models/command-response.schema");
+const models_1 = require("../models");
 var GetVideoEditorPriceCommand;
 (function (GetVideoEditorPriceCommand) {
     GetVideoEditorPriceCommand.RequestSchema = zod_1.z.object({
         modelId: zod_1.z.string(),
+        params: models_1.VideoEditorPricingRequestParamsSchema,
     });
     GetVideoEditorPriceCommand.ResponseDataSchema = zod_1.z.object({
         price: zod_1.z.number(),

package/build/video-editor/commands/retry-video-editor-job.command.js

@@ -17,6 +17,7 @@ var RetryVideoEditorJobCommand;
         modelId: zod_1.z.string().uuid().optional(),
         tokenReservationId: zod_1.z.string().uuid(),
         precalculatedPrice: zod_1.z.number(),
+        params: video_editor_job_schema_1.VideoEditorJobParamsSchema.optional(),
     });
     RetryVideoEditorJobCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(video_editor_job_schema_1.VideoEditorJobSchema);
 })(RetryVideoEditorJobCommand || (exports.RetryVideoEditorJobCommand = RetryVideoEditorJobCommand = {}));

package/build/video-editor/enums/index.js

@@ -15,4 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./video-editor-model-limitation.enum"), exports);
+__exportStar(require("./video-editor-pricing-rule-type.enum"), exports);
 __exportStar(require("./video-editor-model-strategy.enum"), exports);

package/build/video-editor/enums/video-editor-pricing-rule-type.enum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VIDEO_EDITOR_PRICING_RULE_TYPE = void 0;
+var VIDEO_EDITOR_PRICING_RULE_TYPE;
+(function (VIDEO_EDITOR_PRICING_RULE_TYPE) {
+    VIDEO_EDITOR_PRICING_RULE_TYPE["FLAT"] = "flat";
+    VIDEO_EDITOR_PRICING_RULE_TYPE["PER_SECOND"] = "per_second";
+})(VIDEO_EDITOR_PRICING_RULE_TYPE || (exports.VIDEO_EDITOR_PRICING_RULE_TYPE = VIDEO_EDITOR_PRICING_RULE_TYPE = {}));

package/build/video-editor/models/video-editor-job.schema.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VideoEditorJobSchema = void 0;
+exports.VideoEditorJobSchema = exports.VideoEditorJobParamsSchema = void 0;
 const zod_1 = require("zod");
 const tools_1 = require("../../tools");
 const common_1 = require("../../common");
+exports.VideoEditorJobParamsSchema = zod_1.z.object({
+    duration: zod_1.z.number().optional(),
+    resolution: zod_1.z.string().optional(),
+});
 exports.VideoEditorJobSchema = zod_1.z.object({
     uuid: zod_1.z.string(),
     prompt: zod_1.z.string(),
@@ -20,6 +24,7 @@ exports.VideoEditorJobSchema = zod_1.z.object({
     outputVideoUrl: zod_1.z.string().nullable(),
     outputVideoId: zod_1.z.string().nullable(),
     previewUrl: zod_1.z.string().nullable(),
+    params: exports.VideoEditorJobParamsSchema.optional(),
     duration: zod_1.z.number(),
     attempts: zod_1.z.array(zod_1.z.any()),
     userId: zod_1.z.string().nullable().optional(),

package/build/video-editor/models/video-editor-model.schema.js

@@ -1,9 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VideoEditorModelSchema = void 0;
+exports.VideoEditorModelSchema = exports.VideoEditorModelPricingRulesSchema = exports.VideoEditorModelPricingRuleConditionSchema = exports.VideoEditorPricingRequestParamsSchema = exports.VideoEditorModelParamsSchema = void 0;
 const zod_1 = require("zod");
 const common_1 = require("../../common");
 const enums_1 = require("../enums");
+exports.VideoEditorModelParamsSchema = zod_1.z.object({
+    duration: zod_1.z
+        .object({
+        options: zod_1.z.array(zod_1.z.number()),
+    })
+        .optional(),
+    resolution: zod_1.z
+        .object({
+        options: zod_1.z.array(zod_1.z.string()),
+    })
+        .optional(),
+});
+exports.VideoEditorPricingRequestParamsSchema = zod_1.z.object({
+    duration: zod_1.z.number(),
+    resolution: zod_1.z.string().optional(),
+});
+exports.VideoEditorModelPricingRuleConditionSchema = zod_1.z.object({
+    duration: zod_1.z.number().optional(),
+    resolution: zod_1.z.string().optional(),
+});
+exports.VideoEditorModelPricingRulesSchema = zod_1.z.array(zod_1.z.object({
+    type: zod_1.z.nativeEnum(enums_1.VIDEO_EDITOR_PRICING_RULE_TYPE),
+    condition: exports.VideoEditorModelPricingRuleConditionSchema,
+    value: zod_1.z.number(),
+}));
 exports.VideoEditorModelSchema = zod_1.z.object({
     uuid: zod_1.z.string(),
     title: zod_1.z.string(),
@@ -17,6 +42,8 @@ exports.VideoEditorModelSchema = zod_1.z.object({
     maxInputVideoSizeBytes: zod_1.z.number(),
     maxInputVideoDurationInSeconds: zod_1.z.number(),
     supportedFormats: zod_1.z.array(zod_1.z.string()),
+    params: exports.VideoEditorModelParamsSchema,
+    pricingRules: exports.VideoEditorModelPricingRulesSchema,
     needsTranslation: zod_1.z.boolean(),
     pricePerCall: zod_1.z.number(),
     limitations: zod_1.z.array(zod_1.z.nativeEnum(enums_1.VIDEO_EDITOR_MODEL_LIMITATION)),

package/build/video-editor/utils/calculate-video-editing-price.js

@@ -1,6 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateVideoEditingPrice = calculateVideoEditingPrice;
-function calculateVideoEditingPrice({ pricePerCall }) {
-    return pricePerCall;
+const enums_1 = require("../enums");
+function matchesCondition(condition, params) {
+    const keys = Object.keys(condition);
+    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;
+    });
+}
+function calculateVideoEditingPrice({ pricePerCall, params, rules, }) {
+    const perSecondRule = rules
+        .filter((r) => r.type === enums_1.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 !== enums_1.VIDEO_EDITOR_PRICING_RULE_TYPE.FLAT)
+            return sum;
+        return matchesCondition(r.condition, params) ? sum + r.value : sum;
+    }, 0);
+    return Math.ceil(base + flatMarkup);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purpleschool/gptbot-tools",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "scripts": {

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

@@ -1,10 +1,12 @@
 import { z } from 'zod';
-import { REASONING_EFFORT } from '../../common';
+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(),

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

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { ICommandResponseSchema } from '../../common/models/command-response.schema';
-import { VideoEditorJobSchema } from '../models';
+import { VideoEditorJobSchema, VideoEditorJobParamsSchema } from '../models';
 
 export namespace EditVideoCommand {
     export const RequestSchema = z.object({
@@ -13,6 +13,7 @@ export namespace EditVideoCommand {
         modelId: z.string().uuid(),
         tokenReservationId: z.string().uuid(),
         precalculatedPrice: z.number(),
+        params: VideoEditorJobParamsSchema.optional(),
     });
     export type Request = z.infer<typeof RequestSchema>;
 

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

@@ -1,9 +1,11 @@
 import { z } from 'zod';
 import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { VideoEditorPricingRequestParamsSchema } from '../models';
 
 export namespace GetVideoEditorPriceCommand {
     export const RequestSchema = z.object({
         modelId: z.string(),
+        params: VideoEditorPricingRequestParamsSchema,
     });
     export type Request = z.infer<typeof RequestSchema>;
 

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

@@ -1,6 +1,9 @@
 import { z } from 'zod';
 import { ICommandResponseSchema } from '../../common/models/command-response.schema';
-import { VideoEditorJobSchema } from '../models/video-editor-job.schema';
+import {
+    VideoEditorJobParamsSchema,
+    VideoEditorJobSchema,
+} from '../models/video-editor-job.schema';
 
 export namespace RetryVideoEditorJobCommand {
     export const RequestSchema = z.object({
@@ -14,6 +17,7 @@ export namespace RetryVideoEditorJobCommand {
         modelId: z.string().uuid().optional(),
         tokenReservationId: z.string().uuid(),
         precalculatedPrice: z.number(),
+        params: VideoEditorJobParamsSchema.optional(),
     });
     export type Request = z.infer<typeof RequestSchema>;
 

package/video-editor/enums/index.ts

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

package/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/video-editor/models/video-editor-job.schema.ts

@@ -2,6 +2,13 @@ import { z } from 'zod';
 import { JOB_STATUS } from '../../tools';
 import { USER_REACTION } from '../../common';
 
+export const VideoEditorJobParamsSchema = z.object({
+    duration: z.number().optional(),
+    resolution: z.string().optional(),
+});
+
+export type VideoEditorJobParams = z.infer<typeof VideoEditorJobParamsSchema>;
+
 export const VideoEditorJobSchema = z.object({
     uuid: z.string(),
     prompt: z.string(),
@@ -18,6 +25,7 @@ export const VideoEditorJobSchema = z.object({
     outputVideoUrl: z.string().nullable(),
     outputVideoId: z.string().nullable(),
     previewUrl: z.string().nullable(),
+    params: VideoEditorJobParamsSchema.optional(),
     duration: z.number(),
     attempts: z.array(z.any()),
     userId: z.string().nullable().optional(),

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

@@ -1,6 +1,48 @@
 import { z } from 'zod';
 import { IconVariantsSchema, TOOL_MODEL_STATUS } from '../../common';
-import { VIDEO_EDITOR_MODEL_LIMITATION, VIDEO_EDITOR_MODEL_STRATEGY } from '../enums';
+import {
+    VIDEO_EDITOR_MODEL_LIMITATION,
+    VIDEO_EDITOR_MODEL_STRATEGY,
+    VIDEO_EDITOR_PRICING_RULE_TYPE,
+} from '../enums';
+
+export const VideoEditorModelParamsSchema = z.object({
+    duration: z
+        .object({
+            options: z.array(z.number()),
+        })
+        .optional(),
+    resolution: z
+        .object({
+            options: z.array(z.string()),
+        })
+        .optional(),
+});
+
+export type VideoEditorModelParams = z.infer<typeof VideoEditorModelParamsSchema>;
+
+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(),
@@ -15,6 +57,8 @@ export const VideoEditorModelSchema = z.object({
     maxInputVideoSizeBytes: z.number(),
     maxInputVideoDurationInSeconds: z.number(),
     supportedFormats: z.array(z.string()),
+    params: VideoEditorModelParamsSchema,
+    pricingRules: VideoEditorModelPricingRulesSchema,
     needsTranslation: z.boolean(),
     pricePerCall: z.number(),
     limitations: z.array(z.nativeEnum(VIDEO_EDITOR_MODEL_LIMITATION)),

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

@@ -1,3 +1,46 @@
-export function calculateVideoEditingPrice({ pricePerCall }: { pricePerCall: number }): number {
-    return pricePerCall;
+import { VIDEO_EDITOR_PRICING_RULE_TYPE } from '../enums';
+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);
 }