@purpleschool/gptbot-tools 0.1.133 → 0.2.0-stage

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

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { MarketplaceCardJobSchema } from '../../marketplace-card';
+import { TOOL_TYPE } from '../../tools';
+import { VideoJobSchema } from '../../video';
+
+export const ToolWorkspaceJobSchema = z.discriminatedUnion('type', [
+    z.object({
+        type: z.literal(TOOL_TYPE.MARKETPLACE_CARD_GENERATION),
+        job: MarketplaceCardJobSchema,
+    }),
+    z.object({
+        type: z.literal(TOOL_TYPE.VIDEO),
+        job: VideoJobSchema,
+    }),
+]);
+
+export type ToolWorkspaceJob = z.infer<typeof ToolWorkspaceJobSchema>;

package/tool-workspace/models/tool-workspace.schema.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { TOOL_CONTENT_TYPE } from '../../tools';
+import { TOOL_WORKSPACE_STATUS } from '../enums';
+
+export const ToolWorkspaceSchema = z.object({
+    uuid: z.string().uuid(),
+    toolType: z.nativeEnum(TOOL_CONTENT_TYPE),
+    title: z.string(),
+    coverUrl: z.string().nullable(),
+    status: z.nativeEnum(TOOL_WORKSPACE_STATUS),
+    userId: z.string().uuid().nullable().optional(),
+    unregisteredUserId: z.string().uuid().nullable().optional(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type ToolWorkspace = z.infer<typeof ToolWorkspaceSchema>;

package/tool-workspace/queries/find-tool-workspace-by-uuid.query.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { ToolWorkspaceContentsSchema } from '../models';
+
+export namespace FindToolWorkspaceByUuidQuery {
+    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(ToolWorkspaceContentsSchema.nullable());
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/tool-workspace/queries/find-tool-workspaces.query.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { TOOL_CONTENT_TYPE } from '../../tools';
+import { ToolWorkspaceSchema } from '../models';
+
+export namespace FindToolWorkspacesQuery {
+    export const RequestSchema = z
+        .object({
+            toolType: z.nativeEnum(TOOL_CONTENT_TYPE).optional(),
+            title: z.string().optional(),
+            userId: z.string().uuid().optional(),
+            unregisteredUserId: z.string().uuid().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(ToolWorkspaceSchema),
+            page: z.number(),
+            totalPages: z.number(),
+        }),
+    );
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/tool-workspace/queries/index.ts

@@ -0,0 +1,2 @@
+export * from './find-tool-workspaces.query';
+export * from './find-tool-workspace-by-uuid.query';

package/tool-workspace/routes/index.ts

@@ -0,0 +1 @@
+export * from './tool-workspace.amqp.routes';

package/tool-workspace/routes/tool-workspace.amqp.routes.ts

@@ -0,0 +1,6 @@
+export const TOOL_WORKSPACE_AMQP_ROUTES = {
+    UPDATE: 'tools.workspace.update.rpc',
+    SOFT_DELETE: 'tools.workspace.soft-delete.rpc',
+    GET: 'tools.workspace.get.rpc',
+    LIST: 'tools.workspace.list.rpc',
+} as const;

package/tools/enums/tool-content-type.enum.ts

@@ -11,4 +11,7 @@ export enum TOOL_CONTENT_TYPE {
     MUSIC = 'MUSIC',
     INTERIOR_DESIGN = 'INTERIOR_DESIGN',
     NONE = 'NONE',
+    MARKETPLACE_CARD_GENERATION = 'MARKETPLACE_CARD',
+    SOLVING_EDU_TASK = 'SOLVING_EDU_TASK',
+    SPELL_CORRECTOR = 'SPELL_CORRECTOR',
 }

package/tools/enums/tool-type.enum.ts

@@ -12,5 +12,8 @@ export enum TOOL_TYPE {
     MUSIC = 'MUSIC',
     MUSIC_ACTION = 'MUSIC_ACTION',
     IMAGE_GENERATION = 'IMAGE_GENERATION',
+    MARKETPLACE_CARD_GENERATION = 'MARKETPLACE_CARD_GENERATION',
     INTERIOR_DESIGN = 'INTERIOR_DESIGN',
+    SPELL_CORRECTOR = 'SPELL_CORRECTOR',
+    SOLVING_EDU_TASK = 'SOLVING_EDU_TASK',
 }

package/tools/models/global-tools-config.schema.ts

@@ -10,7 +10,10 @@ import { PresentationConfigSchema } from '../../presentation';
 import { VideoEditorConfigSchema } from '../../video-editor';
 import { TTSConfigSchema } from '../../tts';
 import { STTConfigSchema } from '../../stt';
+import { MarketplaceCardConfigSchema } from '../../marketplace-card/models';
 import { InteriorDesignConfigSchema } from '../../interior-design';
+import { SolvingEduTaskConfigSchema } from '../../solving-edu-task';
+import { SpellCorrectorToolConfigSchema } from '../../spell-corrector';
 
 export const GlobalToolsConfigSchema = z.object({
     [TOOL_CONTENT_TYPE.VIDEO]: VideoConfigSchema,
@@ -23,7 +26,10 @@ export const GlobalToolsConfigSchema = z.object({
     [TOOL_CONTENT_TYPE.VIDEO_EDITOR]: VideoEditorConfigSchema,
     [TOOL_CONTENT_TYPE.TEXT_TO_SPEECH]: TTSConfigSchema,
     [TOOL_CONTENT_TYPE.SPEECH_TO_TEXT]: STTConfigSchema,
+    [TOOL_CONTENT_TYPE.MARKETPLACE_CARD_GENERATION]: MarketplaceCardConfigSchema,
     [TOOL_CONTENT_TYPE.INTERIOR_DESIGN]: InteriorDesignConfigSchema,
+    [TOOL_CONTENT_TYPE.SOLVING_EDU_TASK]: SolvingEduTaskConfigSchema,
+    [TOOL_CONTENT_TYPE.SPELL_CORRECTOR]: SpellCorrectorToolConfigSchema,
 });
 
 export type GlobalToolsConfig = z.infer<typeof GlobalToolsConfigSchema>;

package/tools/models/tools-with-configs.schema.ts

@@ -10,8 +10,11 @@ import { PresentationConfigSchema } from '../../presentation';
 import { VideoEditorConfigSchema } from '../../video-editor';
 import { TTSConfigSchema } from '../../tts';
 import { STTConfigSchema } from '../../stt';
+import { MarketplaceCardConfigSchema } from '../../marketplace-card/models';
 import { ToolSchema } from './tool.schema';
 import { InteriorDesignConfigSchema } from '../../interior-design';
+import { SolvingEduTaskConfigSchema } from '../../solving-edu-task';
+import { SpellCorrectorToolConfigSchema } from '../../spell-corrector';
 
 // Discriminated union array: Tools with their configs
 export const ToolWithConfigSchema = z.discriminatedUnion('contentType', [
@@ -75,12 +78,30 @@ export const ToolWithConfigSchema = z.discriminatedUnion('contentType', [
             config: STTConfigSchema,
         }),
     ),
+    ToolSchema.merge(
+        z.object({
+            contentType: z.literal(TOOL_CONTENT_TYPE.MARKETPLACE_CARD_GENERATION),
+            config: MarketplaceCardConfigSchema,
+        }),
+    ),
     ToolSchema.merge(
         z.object({
             contentType: z.literal(TOOL_CONTENT_TYPE.INTERIOR_DESIGN),
             config: InteriorDesignConfigSchema,
         }),
     ),
+    ToolSchema.merge(
+        z.object({
+            contentType: z.literal(TOOL_CONTENT_TYPE.SOLVING_EDU_TASK),
+            config: SolvingEduTaskConfigSchema,
+        }),
+    ),
+    ToolSchema.merge(
+        z.object({
+            contentType: z.literal(TOOL_CONTENT_TYPE.SPELL_CORRECTOR),
+            config: SpellCorrectorToolConfigSchema,
+        }),
+    ),
 ]);
 
 export type ToolWithConfig = z.infer<typeof ToolWithConfigSchema>;

package/video/commands/video.command.ts

@@ -1,5 +1,7 @@
 import { z } from 'zod';
 import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { TOOL_WORKSPACE_ITEM_SLOT } from '../../tool-workspace';
+import { TOOL_CONTENT_TYPE } from '../../tools';
 import { VideoJobSchema } from '../models/video-job.schema';
 import { VideoGenerationRequestParamsSchema } from '../models';
 
@@ -7,6 +9,11 @@ export namespace VideoCommand {
     export const RequestSchema = z.object({
         userId: z.string().uuid().nullable().optional(),
         unregisteredUserId: z.string().uuid().nullable().optional(),
+        workspaceId: z.string().uuid().nullable().optional(),
+        workspaceItemId: z.string().uuid().nullable().optional(),
+        workspaceToolType: z.nativeEnum(TOOL_CONTENT_TYPE).nullable().optional(),
+        workspaceSlot: z.nativeEnum(TOOL_WORKSPACE_ITEM_SLOT).optional(),
+        workspaceOrder: z.number().int().min(0).optional(),
         prompt: z.string(),
         modelId: z.string(),
         params: VideoGenerationRequestParamsSchema,

package/video/const/videoMaxDuration.ts

@@ -1 +1 @@
-export const videoMaxDuration = 8;
+export const videoMaxDuration = 15;

package/video/enums/video-resolution.enum.ts

@@ -1,4 +1,5 @@
 export enum VIDEO_RESOLUTION {
+    LOW = '480p',
     STANDART = '720p',
     HIGH = '1080p',
 }

package/video/enums/video-strategy.enum.ts

@@ -8,4 +8,5 @@ export enum VIDEO_GENERATION_STRATEGY {
     SEEDANCE_VIDEO_GENERATION_CALLBACK = 'SEEDANCE_VIDEO_GENERATION_CALLBACK',
     KLING_VIDEO_GENERATION_CALLBACK = 'KLING_VIDEO_GENERATION_CALLBACK',
     WAN_2_6_VIDEO_GENERATION_CALLBACK = 'WAN_2_6_VIDEO_GENERATION_CALLBACK',
+    GROK_VIDEO_GENERATION_CALLBACK = 'GROK_VIDEO_GENERATION_CALLBACK',
 }

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

@@ -1,7 +1,9 @@
 import { z } from 'zod';
 import { VideoModelSchema } from './video-model.schema';
+import { AiVendorSchema } from '../../ai-vendor';
 
 export const VideoConfigSchema = z.object({
+    vendors: z.array(AiVendorSchema),
     models: z.array(VideoModelSchema),
 });
 

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

@@ -83,6 +83,7 @@ export const VideoModelSchema = z.object({
     params: VideoModelParamsSchema,
     pricingRules: VideoModelPricingRulesSchema,
     limitations: z.array(z.nativeEnum(VIDEO_GENERATION_MODEL_LIMITATION)),
+    vendorId: z.string().uuid(),
     createdAt: z.date(),
     updatedAt: z.date(),
 });

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(),
@@ -17,6 +24,8 @@ export const VideoEditorJobSchema = z.object({
     inputVideoId: z.string().nullable(),
     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);
 }

package/writer/commands/collect-sources.command.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { WriterDocumentSchema } from '../models';
+
+export namespace CollectWriterDocumentSourcesCommand {
+    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(WriterDocumentSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/writer/commands/confirm-source-citation-metadata.command.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { WriterSourceSchema } from '../models/writer-source.schema';
+import { WriterSourceBibliographicMetadataSchema } from '../models/writer-source-bibliographic-metadata.schema';
+
+export namespace ConfirmSourceCitationMetadataCommand {
+    export const RequestSchema = z.object({
+        documentId: z.string().uuid(),
+        sourceId: z.string().uuid(),
+        bibliographicMetadata: WriterSourceBibliographicMetadataSchema,
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(WriterSourceSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/writer/commands/discard-writer-source.command.ts

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

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

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

package/writer/commands/index.ts

@@ -6,6 +6,7 @@ export * from './update-writer-document-title-page.command';
 export * from './toggle-writer-document-title-page.command';
 export * from './export-writer-document-as-docx.command';
 export * from './generate-document-contents.command';
+export * from './generate-document-outline.command';
 export * from './get-writer-content-generation-price.command';
 export * from './writer-paraphrase.command';
 export * from './writer-extend-text.command';
@@ -14,3 +15,7 @@ export * from './writer-fix-errors.command';
 export * from './writer-generate-text.command';
 export * from './update-writer-document-contents.command';
 export * from './set-reaction-writer-document.command';
+export * from './collect-sources.command';
+export * from './upload-writer-source.command';
+export * from './confirm-source-citation-metadata.command';
+export * from './discard-writer-source.command';

package/writer/commands/update-writer-document-outline.command.ts

@@ -8,6 +8,7 @@ export namespace UpdateWriterDocumentOutlineCommand {
         unregisteredUserId: z.string().uuid().nullable().optional(),
         documentId: z.string().uuid(),
         data: WriterDocumentOutlineSchema,
+        modelId: z.string().uuid().nullable().optional(),
     });
     export type Request = z.infer<typeof RequestSchema>;
 

package/writer/commands/upload-writer-source.command.ts

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

package/writer/enums/index.ts

@@ -4,3 +4,6 @@ export * from './writer-ai-action-type.enum';
 export * from './writer-document-section-type.enum';
 export * from './writer-document-stage.enum';
 export * from './writer-content-generation-strategy.enum';
+export * from './writer-source-type.enum';
+export * from './writer-source-origin.enum';
+export * from './writer-source-status.enum';

package/writer/enums/writer-document-stage.enum.ts

@@ -1,10 +1,18 @@
 export enum WRITER_DOCUMENT_STAGE {
     CREATED = 'CREATED',
 
+    ANALYZING_TOPIC = 'ANALYZING_TOPIC',
+    TOPIC_ANALYZED = 'TOPIC_ANALYZED',
+    TOPIC_ANALYSIS_FAILED = 'TOPIC_ANALYSIS_FAILED',
+
     GENERATING_OUTLINE = 'GENERATING_OUTLINE',
     OUTLINE_GENERATED = 'OUTLINE_GENERATED',
     OUTLINE_GENERATION_FAILED = 'OUTLINE_GENERATION_FAILED',
 
+    COLLECTING_SOURCES = 'COLLECTING_SOURCES',
+    SOURCES_COLLECTED = 'SOURCES_COLLECTED',
+    SOURCES_COLLECTION_FAILED = 'SOURCES_COLLECTION_FAILED',
+
     GENERATING_CONTENT = 'GENERATING_CONTENT',
     CONTENT_GENERATED = 'CONTENT_GENERATED',
     CONTENT_GENERATION_FAILED = 'CONTENT_GENERATION_FAILED',

package/writer/enums/writer-source-origin.enum.ts

@@ -0,0 +1,4 @@
+export enum WRITER_SOURCE_ORIGIN {
+    WEB_SEARCH = 'WEB_SEARCH',
+    USER_UPLOAD = 'USER_UPLOAD',
+}

package/writer/enums/writer-source-status.enum.ts

@@ -0,0 +1,5 @@
+export enum WRITER_SOURCE_STATUS {
+    READY = 'READY',
+    REQUIRES_CITATION_METADATA_CONFIRMATION = 'REQUIRES_CITATION_METADATA_CONFIRMATION',
+    DISCARDED = 'DISCARDED',
+}

package/writer/enums/writer-source-type.enum.ts

@@ -0,0 +1,4 @@
+export enum WRITER_SOURCE_TYPE {
+    JOURNAL_ARTICLE = 'JOURNAL_ARTICLE',
+    BOOK = 'BOOK',
+}

package/writer/models/index.ts

@@ -5,3 +5,5 @@ export * from './writer-document-outline.schema';
 export * from './writer-document-title-page.schema';
 export * from './writer-document.schema';
 export * from './writer-document-type.schema';
+export * from './writer-source.schema';
+export * from './writer-source-bibliographic-metadata.schema';

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

@@ -8,9 +8,9 @@ export const WriterDocumentTypeSchema = z.object({
     order: z.number(),
     minPages: z.number(),
     maxPages: z.number(),
+    skipSources: z.boolean(),
     pageRange: z.array(z.number()),
     needsTableOfContents: z.boolean(),
-    needsCitations: z.boolean(),
     createdAt: z.date(),
     updatedAt: z.date(),
 });

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

@@ -20,6 +20,9 @@ export const WriterDocumentSchema = z.object({
     modelId: z.string().nullable(),
     reaction: z.nativeEnum(USER_REACTION).nullable(),
     dislikeReason: z.string().nullable(),
+    description: z.string().nullable(),
+    internalError: z.string().nullable(),
+    skipSources: z.boolean(),
     pages: z.number(),
     isDeleted: z.boolean(),
     tokenReservationId: z.string().nullable().optional(),