@purpleschool/gptbot 0.13.23 → 0.14.2-stage-2

package/commands/b2b-compatible/anthropic-models.command.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { AnthropicErrorResponseSchema, AnthropicHeadersSchema } from './common.schemas';
+
+export namespace AnthropicModelsCommand {
+    export const HeadersSchema = AnthropicHeadersSchema;
+
+    export const ModelSchema = z
+        .object({
+            id: z.string(),
+            type: z.literal('model'),
+            display_name: z.string(),
+            created_at: z.string().datetime(),
+        })
+        .strict();
+
+    export const ResponseSchema = z
+        .object({
+            data: z.array(ModelSchema),
+            first_id: z.string().nullable(),
+            last_id: z.string().nullable(),
+            has_more: z.boolean(),
+        })
+        .strict();
+
+    export const ErrorResponseSchema = AnthropicErrorResponseSchema;
+
+    export type Headers = z.infer<typeof HeadersSchema>;
+    export type Model = z.infer<typeof ModelSchema>;
+    export type Response = z.infer<typeof ResponseSchema>;
+    export type ErrorResponse = z.infer<typeof ErrorResponseSchema>;
+}

package/commands/b2b-compatible/common.schemas.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+
+export const NullableStringSchema = z.string().nullable();
+
+export const OpenAIHeadersSchema = z
+    .object({
+        authorization: z.string(),
+    })
+    .strict();
+
+export const AnthropicHeadersSchema = z
+    .object({
+        'x-api-key': z.string(),
+        'anthropic-version': z.string().optional(),
+    })
+    .strict();
+
+export const OpenAIErrorResponseSchema = z
+    .object({
+        error: z
+            .object({
+                message: z.string(),
+                type: z.string(),
+                param: NullableStringSchema,
+                code: NullableStringSchema,
+            })
+            .strict(),
+    })
+    .strict();
+
+export const AnthropicErrorResponseSchema = z
+    .object({
+        type: z.literal('error'),
+        error: z
+            .object({
+                type: z.string(),
+                message: z.string(),
+            })
+            .strict(),
+    })
+    .strict();
+
+export const CompatibleFileUploadMetadataSchema = z
+    .object({
+        filename: z.string(),
+        mimetype: z.string(),
+        size: z.number().int().nonnegative(),
+    })
+    .strict();
+
+export type OpenAIHeaders = z.infer<typeof OpenAIHeadersSchema>;
+export type AnthropicHeaders = z.infer<typeof AnthropicHeadersSchema>;
+export type OpenAIErrorResponse = z.infer<typeof OpenAIErrorResponseSchema>;
+export type AnthropicErrorResponse = z.infer<typeof AnthropicErrorResponseSchema>;
+export type CompatibleFileUploadMetadata = z.infer<typeof CompatibleFileUploadMetadataSchema>;

package/commands/b2b-compatible/index.ts

@@ -0,0 +1,7 @@
+export * from './anthropic-files.command';
+export * from './anthropic-messages.command';
+export * from './anthropic-models.command';
+export * from './common.schemas';
+export * from './openai-files.command';
+export * from './openai-models.command';
+export * from './openai-responses.command';

package/commands/b2b-compatible/openai-files.command.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import {
+    CompatibleFileUploadMetadataSchema,
+    OpenAIErrorResponseSchema,
+    OpenAIHeadersSchema,
+} from './common.schemas';
+
+export namespace OpenAIFilesCommand {
+    export const HeadersSchema = OpenAIHeadersSchema;
+
+    export const BodySchema = z
+        .object({
+            purpose: z.enum(['assistants', 'batch', 'fine-tune', 'vision', 'user_data', 'evals']),
+        })
+        .strict();
+
+    export const FileMetadataSchema = CompatibleFileUploadMetadataSchema;
+
+    export const ResponseSchema = z
+        .object({
+            id: z.string().uuid(),
+            object: z.literal('file'),
+            bytes: z.number().int().nonnegative(),
+            created_at: z.number().int(),
+            filename: z.string(),
+            purpose: BodySchema.shape.purpose,
+        })
+        .strict();
+
+    export const ErrorResponseSchema = OpenAIErrorResponseSchema;
+
+    export type Headers = z.infer<typeof HeadersSchema>;
+    export type Body = z.infer<typeof BodySchema>;
+    export type FileMetadata = z.infer<typeof FileMetadataSchema>;
+    export type Response = z.infer<typeof ResponseSchema>;
+    export type ErrorResponse = z.infer<typeof ErrorResponseSchema>;
+}

package/commands/b2b-compatible/openai-models.command.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { OpenAIErrorResponseSchema, OpenAIHeadersSchema } from './common.schemas';
+
+export namespace OpenAIModelsCommand {
+    export const HeadersSchema = OpenAIHeadersSchema;
+
+    export const ModelSchema = z
+        .object({
+            id: z.string(),
+            object: z.literal('model'),
+            created: z.number().int(),
+            owned_by: z.literal('rugpt'),
+        })
+        .strict();
+
+    export const ResponseSchema = z
+        .object({
+            object: z.literal('list'),
+            data: z.array(ModelSchema),
+        })
+        .strict();
+
+    export const ErrorResponseSchema = OpenAIErrorResponseSchema;
+
+    export type Headers = z.infer<typeof HeadersSchema>;
+    export type Model = z.infer<typeof ModelSchema>;
+    export type Response = z.infer<typeof ResponseSchema>;
+    export type ErrorResponse = z.infer<typeof ErrorResponseSchema>;
+}

package/commands/b2b-compatible/openai-responses.command.ts

@@ -0,0 +1,191 @@
+import { z } from 'zod';
+import { OpenAIErrorResponseSchema, OpenAIHeadersSchema } from './common.schemas';
+
+const OpenAIInputTextContentPartSchema = z
+    .object({
+        type: z.enum(['input_text', 'text', 'output_text']),
+        text: z.string(),
+    })
+    .passthrough();
+
+const OpenAIInputImageContentPartSchema = z
+    .object({
+        type: z.literal('input_image'),
+        image_url: z.string().optional(),
+        file_id: z.string().optional(),
+        detail: z.enum(['auto', 'low', 'high']).optional(),
+    })
+    .passthrough();
+
+const OpenAIInputFileContentPartSchema = z
+    .object({
+        type: z.literal('input_file'),
+        file_id: z.string().optional(),
+        file_data: z.string().optional(),
+        file_url: z.string().optional(),
+        filename: z.string().optional(),
+        mime_type: z.string().optional(),
+    })
+    .passthrough();
+
+export const OpenAIResponseInputContentPartSchema = z.discriminatedUnion('type', [
+    OpenAIInputTextContentPartSchema,
+    OpenAIInputImageContentPartSchema,
+    OpenAIInputFileContentPartSchema,
+]);
+
+export const OpenAIResponseInputMessageSchema = z
+    .object({
+        type: z.literal('message').optional(),
+        role: z.enum(['system', 'developer', 'user', 'assistant']),
+        content: z.union([z.string(), z.array(OpenAIResponseInputContentPartSchema)]),
+    })
+    .passthrough();
+
+const OpenAIAnyToolSchema = z
+    .object({
+        type: z.string(),
+    })
+    .passthrough();
+
+const OpenAIResponseMetadataSchema = z.record(z.string(), z.unknown());
+
+const OpenAIResponseReasoningSchema = z
+    .object({
+        effort: z.string().optional(),
+        summary: z.string().nullable().optional(),
+    })
+    .passthrough();
+
+const OpenAIResponseTextOptionsSchema = z
+    .object({
+        format: z.unknown().optional(),
+        verbosity: z.string().optional(),
+    })
+    .passthrough();
+
+const OpenAIResponseUsageSchema = z
+    .object({
+        input_tokens: z.number().int().nonnegative(),
+        output_tokens: z.number().int().nonnegative(),
+        total_tokens: z.number().int().nonnegative(),
+        input_tokens_details: z
+            .object({
+                cached_tokens: z.number().int().nonnegative().optional(),
+            })
+            .strict()
+            .optional(),
+    })
+    .strict();
+
+const OpenAIResponseOutputTextSchema = z
+    .object({
+        type: z.literal('output_text'),
+        text: z.string(),
+        annotations: z.array(z.unknown()),
+    })
+    .strict();
+
+const OpenAIResponseOutputMessageSchema = z
+    .object({
+        id: z.string(),
+        type: z.literal('message'),
+        status: z.literal('completed'),
+        role: z.literal('assistant'),
+        content: z.array(OpenAIResponseOutputTextSchema),
+    })
+    .strict();
+
+export namespace OpenAIResponsesCommand {
+    export const HeadersSchema = OpenAIHeadersSchema;
+
+    export const BodySchema = z
+        .object({
+            model: z.string(),
+            input: z.union([z.string(), z.array(OpenAIResponseInputMessageSchema).min(1)]),
+            instructions: z.string().optional(),
+            stream: z.boolean().optional(),
+            max_output_tokens: z.number().int().positive().optional(),
+            tools: z.array(OpenAIAnyToolSchema).optional(),
+            background: z.boolean().optional(),
+            include: z.array(z.string()).optional(),
+            max_tool_calls: z.number().int().positive().optional(),
+            metadata: OpenAIResponseMetadataSchema.nullable().optional(),
+            parallel_tool_calls: z.boolean().optional(),
+            previous_response_id: z.string().nullable().optional(),
+            prompt: z.unknown().optional(),
+            reasoning: OpenAIResponseReasoningSchema.nullable().optional(),
+            safety_identifier: z.string().optional(),
+            service_tier: z.string().optional(),
+            store: z.boolean().nullable().optional(),
+            stream_options: z.unknown().optional(),
+            temperature: z.number().optional(),
+            text: OpenAIResponseTextOptionsSchema.optional(),
+            tool_choice: z.unknown().optional(),
+            top_p: z.number().optional(),
+            truncation: z.string().optional(),
+            user: z.string().optional(),
+        })
+        .passthrough();
+
+    export const UsageSchema = OpenAIResponseUsageSchema;
+
+    export const ResponseSchema = z
+        .object({
+            id: z.string(),
+            object: z.literal('response'),
+            created_at: z.number().int(),
+            status: z.literal('completed'),
+            model: z.string(),
+            output: z.array(OpenAIResponseOutputMessageSchema),
+            output_text: z.string(),
+            usage: UsageSchema,
+        })
+        .strict();
+
+    export const StreamEventSchema = z.union([
+        z
+            .object({
+                type: z.literal('response.created'),
+                response: ResponseSchema.omit({ status: true }).extend({
+                    status: z.literal('in_progress'),
+                    output: z.array(z.never()),
+                    output_text: z.literal(''),
+                }),
+            })
+            .strict(),
+        z
+            .object({
+                type: z.literal('response.output_text.delta'),
+                response_id: z.string(),
+                output_index: z.number().int(),
+                content_index: z.number().int(),
+                delta: z.string(),
+            })
+            .strict(),
+        z
+            .object({
+                type: z.literal('response.output_text.done'),
+                response_id: z.string(),
+                output_index: z.number().int(),
+                content_index: z.number().int(),
+                text: z.string(),
+            })
+            .strict(),
+        z
+            .object({
+                type: z.literal('response.completed'),
+                response: ResponseSchema,
+            })
+            .strict(),
+        OpenAIErrorResponseSchema,
+    ]);
+
+    export const ErrorResponseSchema = OpenAIErrorResponseSchema;
+
+    export type Headers = z.infer<typeof HeadersSchema>;
+    export type Body = z.infer<typeof BodySchema>;
+    export type Response = z.infer<typeof ResponseSchema>;
+    export type StreamEvent = z.infer<typeof StreamEventSchema>;
+    export type ErrorResponse = z.infer<typeof ErrorResponseSchema>;
+}

package/commands/b2b-usage-log/get-b2b-usage-statistics.command.ts

@@ -0,0 +1,128 @@
+import { z } from 'zod';
+import { B2B_STATISTICS_PERIOD } from '../../constants';
+import { B2bUsageStatisticsSchema } from '../../models/b2b';
+
+const DATE_ONLY_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+const MILLISECONDS_PER_DAY = 24 * 60 * 60 * 1000;
+
+const DateOnlySchema = z
+    .string()
+    .regex(DATE_ONLY_PATTERN)
+    .refine(
+        (value) => {
+            const [year, month, day] = value.split('-').map(Number);
+            const date = new Date(Date.UTC(year, month - 1, day));
+
+            return (
+                date.getUTCFullYear() === year &&
+                date.getUTCMonth() === month - 1 &&
+                date.getUTCDate() === day
+            );
+        },
+        { message: 'Invalid calendar date' },
+    );
+
+const formatLocalDate = (date: Date): string => {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+
+    return `${year}-${month}-${day}`;
+};
+
+const toUtcCalendarTimestamp = (value: string): number => {
+    const [year, month, day] = value.split('-').map(Number);
+    return Date.UTC(year, month - 1, day);
+};
+
+export namespace GetB2bUsageStatisticsCommand {
+    export const RequestQuerySchema = z
+        .object({
+            period: z.nativeEnum(B2B_STATISTICS_PERIOD).default(B2B_STATISTICS_PERIOD.THIRTY_DAYS),
+            dateFrom: DateOnlySchema.optional(),
+            dateTo: DateOnlySchema.optional(),
+            apiKeyId: z.string().uuid().optional(),
+        })
+        .superRefine((query, context) => {
+            const isCustom = query.period === B2B_STATISTICS_PERIOD.CUSTOM;
+
+            if (!isCustom) {
+                if (query.dateFrom !== undefined) {
+                    context.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        path: ['dateFrom'],
+                        message: 'dateFrom is only allowed for custom period',
+                    });
+                }
+                if (query.dateTo !== undefined) {
+                    context.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        path: ['dateTo'],
+                        message: 'dateTo is only allowed for custom period',
+                    });
+                }
+                return;
+            }
+
+            if (query.dateFrom === undefined) {
+                context.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: ['dateFrom'],
+                    message: 'dateFrom is required for custom period',
+                });
+            }
+            if (query.dateTo === undefined) {
+                context.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: ['dateTo'],
+                    message: 'dateTo is required for custom period',
+                });
+            }
+            if (query.dateFrom === undefined || query.dateTo === undefined) {
+                return;
+            }
+
+            const today = formatLocalDate(new Date());
+            if (query.dateFrom > today) {
+                context.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: ['dateFrom'],
+                    message: 'dateFrom cannot be in the future',
+                });
+            }
+            if (query.dateTo > today) {
+                context.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: ['dateTo'],
+                    message: 'dateTo cannot be in the future',
+                });
+            }
+            if (query.dateFrom > query.dateTo) {
+                context.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: ['dateTo'],
+                    message: 'dateTo must be on or after dateFrom',
+                });
+                return;
+            }
+
+            const inclusiveDays =
+                (toUtcCalendarTimestamp(query.dateTo) - toUtcCalendarTimestamp(query.dateFrom)) /
+                    MILLISECONDS_PER_DAY +
+                1;
+            if (inclusiveDays > 90) {
+                context.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: ['dateTo'],
+                    message: 'Custom period cannot exceed 90 calendar days',
+                });
+            }
+        });
+
+    export const ResponseSchema = z.object({
+        data: B2bUsageStatisticsSchema,
+    });
+
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/b2b-usage-log/index.ts

@@ -0,0 +1 @@
+export * from './get-b2b-usage-statistics.command';

package/commands/index.ts

@@ -18,10 +18,10 @@ export * from './form-submission';
 export * from './key-value';
 export * from './message';
 export * from './midjourney';
+export * from './model-page';
 export * from './page';
 export * from './order';
 export * from './payment';
-export * from './photo-studio';
 export * from './product';
 export * from './question';
 export * from './referral';
@@ -50,6 +50,8 @@ export * from './cabinet';
 export * from './webmaster';
 export * from './webmaster-click';
 export * from './b2b';
+export * from './b2b-usage-log';
+export * from './b2b-compatible';
 export * from './community';
 export * from './user-profile';
 export * from './team-account';

package/commands/model-page/base/create-model-page.command.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { ModelPageSchema } from '../../../models';
+import { ModelPageSourceCreateSchema } from '../common.schemas';
+
+export namespace CreateModelPageCommand {
+    export const RequestSchema = ModelPageSourceCreateSchema;
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: ModelPageSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/model-page/base/delete-model-page.command.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { ModelPageDeleteResponseSchema, ModelPageUuidParamSchema } from '../common.schemas';
+
+export namespace DeleteModelPageCommand {
+    export const RequestParamSchema = ModelPageUuidParamSchema;
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = ModelPageDeleteResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/model-page/base/find-model-page-admin.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { ModelPageSchema } from '../../../models';
+import { ModelPageUuidParamSchema } from '../common.schemas';
+
+export namespace FindModelPageAdminCommand {
+    export const RequestParamSchema = ModelPageUuidParamSchema;
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = z.object({
+        data: ModelPageSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/model-page/base/find-model-pages-admin.command.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { MODEL_PAGE_TYPE } from '../../../constants';
+import { ModelPageSchema } from '../../../models';
+import { OptionalQueryArraySchema } from '../common.schemas';
+
+export namespace FindModelPagesAdminCommand {
+    export const RequestQuerySchema = z.object({
+        vendorIds: OptionalQueryArraySchema(z.string().uuid()),
+        types: OptionalQueryArraySchema(z.nativeEnum(MODEL_PAGE_TYPE)),
+        slug: z.string().optional(),
+        limit: z.coerce.number().int().min(1).max(100).optional().default(20),
+        offset: z.coerce.number().int().min(0).optional().default(0),
+    });
+
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(ModelPageSchema),
+        page: z.number(),
+        totalPages: z.number(),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/model-page/base/index.ts

@@ -0,0 +1,5 @@
+export * from './create-model-page.command';
+export * from './delete-model-page.command';
+export * from './find-model-page-admin.command';
+export * from './find-model-pages-admin.command';
+export * from './update-model-page.command';

package/commands/model-page/base/update-model-page.command.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { MODEL_PAGE_TYPE } from '../../../constants';
+import { ModelPageSchema } from '../../../models';
+import { ModelPageUuidParamSchema } from '../common.schemas';
+
+export namespace UpdateModelPageCommand {
+    export const RequestParamSchema = ModelPageUuidParamSchema;
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const RequestSchema = z
+        .object({
+            slug: z.string().min(1).optional(),
+            type: z.nativeEnum(MODEL_PAGE_TYPE).optional(),
+            vendorId: z.string().uuid().optional(),
+            aiModelId: z.string().uuid().nullable().optional(),
+            toolModelId: z.string().uuid().nullable().optional(),
+        })
+        .superRefine((value, context) => {
+            if (value.aiModelId && value.toolModelId) {
+                context.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: 'aiModelId and toolModelId cannot both be set',
+                    path: ['toolModelId'],
+                });
+            }
+
+            if (value.type === MODEL_PAGE_TYPE.TEXT) {
+                if (value.aiModelId === null) {
+                    context.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: 'aiModelId cannot be null for TEXT',
+                        path: ['aiModelId'],
+                    });
+                }
+                if (value.toolModelId) {
+                    context.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: 'toolModelId cannot be set for TEXT',
+                        path: ['toolModelId'],
+                    });
+                }
+            }
+
+            if (value.type && value.type !== MODEL_PAGE_TYPE.TEXT) {
+                if (value.aiModelId) {
+                    context.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: 'aiModelId cannot be set for a non-text model page',
+                        path: ['aiModelId'],
+                    });
+                }
+                if (value.toolModelId === null) {
+                    context.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: 'toolModelId cannot be null for a non-text model page',
+                        path: ['toolModelId'],
+                    });
+                }
+            }
+        });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: ModelPageSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}