@m5kdev/backend 0.1.1 → 0.1.3

package/dist/src/modules/ai/ai.service.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIService = void 0;
+const ai_constants_1 = require("@m5kdev/commons/modules/ai/ai.constants");
+const ai_utils_1 = require("@m5kdev/commons/modules/ai/ai.utils");
+const request_context_1 = require("@mastra/core/request-context");
+const rag_1 = require("@mastra/rag");
+const ai_1 = require("ai");
+const neverthrow_1 = require("neverthrow");
+const base_service_1 = require("#modules/base/base.service");
+class AIService extends base_service_1.BaseService {
+    helpers = {
+        arrayToPseudoXML: ai_utils_1.arrayToPseudoXML,
+    };
+    mastra;
+    openrouter;
+    replicate;
+    constructor(repositories, services, libs) {
+        super(repositories, services);
+        this.mastra = libs.mastra;
+        this.openrouter = libs.openrouter;
+        this.replicate = libs.replicate;
+    }
+    getMastra() {
+        if (!this.mastra) {
+            throw new Error("Mastra is not available");
+        }
+        return this.mastra;
+    }
+    prepareModel(model) {
+        if (!this.openrouter) {
+            throw new Error("OpenRouter is not configured");
+        }
+        const openrouterModel = this.openrouter.chat(model);
+        return openrouterModel;
+    }
+    prepareEmbeddingModel(model) {
+        if (!this.openrouter) {
+            throw new Error("OpenRouter is not configured");
+        }
+        const openrouterModel = this.openrouter.textEmbeddingModel(model);
+        return openrouterModel;
+    }
+    async agentUse(agent, options, ctx) {
+        return this.throwableAsync(async () => {
+            this.logger.info("AGENT USE");
+            const { prompt, messages, ...rest } = options;
+            const payload = messages || prompt;
+            if (!payload)
+                return this.error("BAD_REQUEST", "No prompt or messages provided");
+            const requestContext = options.requestContext ?? new request_context_1.RequestContext();
+            if (ctx?.user) {
+                requestContext.set("userId", ctx.user.id);
+            }
+            if (ctx?.model) {
+                requestContext.set("model", ctx.model);
+            }
+            const mAgent = this.getMastra().getAgent(agent);
+            const result = await mAgent.generate(payload, {
+                ...rest,
+                requestContext: rest.requestContext ?? requestContext,
+            });
+            this.logger.info("AGENT USE DONE");
+            if (this.repository.aiUsage) {
+                const createUsageResult = await this.repository.aiUsage.create({
+                    userId: ctx?.user?.id,
+                    model: ctx?.model ?? "unknown",
+                    provider: "openrouter",
+                    feature: agent,
+                    traceId: result.traceId,
+                    inputTokens: result.usage.inputTokens,
+                    outputTokens: result.usage.outputTokens,
+                    totalTokens: result.usage.totalTokens,
+                    cost: result?.providerMetadata?.openrouter?.usage?.cost ?? 0,
+                });
+                if (createUsageResult.isErr())
+                    return (0, neverthrow_1.err)(createUsageResult.error);
+            }
+            this.logger.info("AGENT USE CREATED USAGE");
+            return (0, neverthrow_1.ok)(result);
+        });
+    }
+    async agentText(agent, options, ctx) {
+        const result = await this.agentUse(agent, options, ctx);
+        if (result.isErr())
+            return this.error("SERVICE_UNAVAILABLE", "AI: Agent text failed", { cause: result.error });
+        return (0, neverthrow_1.ok)(result.value.text);
+    }
+    async agentTextResult(agent, options, ctx) {
+        const result = await this.agentUse(agent, options, ctx);
+        if (result.isErr())
+            return (0, neverthrow_1.err)(result.error);
+        return (0, neverthrow_1.ok)(result.value);
+    }
+    async agentObject(agent, options, ctx) {
+        const { schema, ...rest } = options;
+        const result = await this.agentUse(agent, { ...rest, structuredOutput: { schema } }, ctx);
+        if (result.isErr())
+            return this.error("SERVICE_UNAVAILABLE", "AI: Agent object failed", { cause: result.error });
+        return (0, neverthrow_1.ok)(result.value.object);
+    }
+    async agentObjectResult(agent, options, ctx) {
+        this.logger.info("AGENT OBJECT RESULT");
+        const { schema, ...rest } = options;
+        const result = await this.agentUse(agent, { ...rest, structuredOutput: { schema } }, ctx);
+        if (result.isErr())
+            return (0, neverthrow_1.err)(result.error);
+        this.logger.info("AGENT OBJECT RESULT DONE");
+        return (0, neverthrow_1.ok)({ ...result.value, object: result.value.object });
+    }
+    async embedDocument(value, options, type = "text", model = ai_constants_1.OPENAI_TEXT_EMBEDDING_3_SMALL) {
+        return this.throwableAsync(async () => {
+            if (type === "text") {
+                const doc = rag_1.MDocument.fromText(value);
+                const chunks = await doc.chunk(options ?? {
+                    strategy: "recursive",
+                    maxSize: 512,
+                    overlap: 50,
+                    separators: ["\n"],
+                });
+                const embeddings = await this.embedMany(chunks, model);
+                if (embeddings.isErr())
+                    return (0, neverthrow_1.err)(embeddings.error);
+                return (0, neverthrow_1.ok)({ embeddings: embeddings.value.embeddings, chunks });
+            }
+            return this.error("BAD_REQUEST", "Unsupported document type");
+        });
+    }
+    async embed(text, model = ai_constants_1.OPENAI_TEXT_EMBEDDING_3_SMALL) {
+        return this.throwableAsync(async () => {
+            const result = await (0, ai_1.embed)({
+                model: this.prepareEmbeddingModel(model),
+                value: text,
+            });
+            return (0, neverthrow_1.ok)(result);
+        });
+    }
+    async embedMany(chunks, model = ai_constants_1.OPENAI_TEXT_EMBEDDING_3_SMALL) {
+        return this.throwableAsync(async () => {
+            const result = await (0, ai_1.embedMany)({
+                model: this.prepareEmbeddingModel(model),
+                values: chunks.map((chunk) => chunk.text),
+            });
+            return (0, neverthrow_1.ok)(result);
+        });
+    }
+    async generateText(params) {
+        return this.throwableAsync(async () => {
+            const { removeMDash = true, model, ...rest } = params;
+            const result = await (0, ai_1.generateText)({ ...rest, model: this.prepareModel(model) });
+            return (0, neverthrow_1.ok)(removeMDash ? result.text.replace(/\u2013|\u2014/g, "-") : result.text);
+        });
+    }
+    async generateObject(params) {
+        return this.throwableAsync(async () => {
+            const model = this.prepareModel(params.model);
+            const result = await (0, ai_1.generateObject)({
+                ...params,
+                model,
+                schema: params.schema,
+            });
+            return (0, neverthrow_1.ok)(result.object);
+        });
+    }
+    async generateReplicate(model, options) {
+        return this.throwableAsync(async () => {
+            if (!this.replicate) {
+                return this.error("INTERNAL_SERVER_ERROR", "Replicate is not configured");
+            }
+            try {
+                return (0, neverthrow_1.ok)(await this.replicate.run(model, options));
+            }
+            catch (error) {
+                return this.error("INTERNAL_SERVER_ERROR", undefined, { cause: error });
+            }
+        });
+    }
+    async generateTranscript(file_url) {
+        const output = await this.generateReplicate("thomasmol/whisper-diarization:1495a9cddc83b2203b0d8d3516e38b80fd1572ebc4bc5700ac1da56a9b3ed886", {
+            input: {
+                file_url,
+            },
+        });
+        if (output.isErr())
+            return (0, neverthrow_1.err)(output.error);
+        try {
+            const { segments } = output.value;
+            return (0, neverthrow_1.ok)({ text: segments.map((segment) => segment.text).join(""), metadata: segments });
+        }
+        catch (error) {
+            return this.error("INTERNAL_SERVER_ERROR", undefined, { cause: error });
+        }
+    }
+    async generateIdeogram(input) {
+        if (!this.service.ideogram) {
+            return this.error("INTERNAL_SERVER_ERROR", "Ideogram service is not available");
+        }
+        return this.service.ideogram.generate(input);
+    }
+    async getUsage(userId) {
+        if (!this.repository.aiUsage) {
+            return this.error("INTERNAL_SERVER_ERROR", "AI usage repository is not available");
+        }
+        return this.repository.aiUsage.getUsage(userId);
+    }
+}
+exports.AIService = AIService;

package/dist/src/modules/ai/ai.trpc.d.ts

@@ -5,9 +5,9 @@ export declare function createAITRPC<MastraInstance extends Mastra>(aiService: A
         session: {
             id: string;
             userId: string;
-            expiresAt: Date;
-            createdAt: Date;
             updatedAt: Date;
+            createdAt: Date;
+            expiresAt: Date;
             token: string;
             ipAddress: string | null;
             userAgent: string | null;
@@ -19,13 +19,12 @@ export declare function createAITRPC<MastraInstance extends Mastra>(aiService: A
         };
         user: {
             name: string;
-            image: string | null;
             id: string;
-            createdAt: Date;
             updatedAt: Date;
             email: string;
-            metadata: Record<string, unknown>;
             emailVerified: boolean;
+            image: string | null;
+            createdAt: Date;
             role: string | null;
             banned: boolean | null;
             banReason: string | null;
@@ -35,6 +34,7 @@ export declare function createAITRPC<MastraInstance extends Mastra>(aiService: A
             paymentPlanTier: string | null;
             paymentPlanExpiresAt: Date | null;
             preferences: string | null;
+            metadata: Record<string, unknown>;
             onboarding: number | null;
             flags: string | null;
         };

package/dist/src/modules/ai/ai.trpc.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAITRPC = createAITRPC;
+const zod_1 = require("zod");
+const _trpc_1 = require("#trpc");
+function createAITRPC(aiService) {
+    return (0, _trpc_1.router)({
+        getUserUsage: _trpc_1.adminProcedure
+            .input(zod_1.z.object({ userId: zod_1.z.string() }))
+            .output(zod_1.z.object({
+            inputTokens: zod_1.z.number().nullable(),
+            outputTokens: zod_1.z.number().nullable(),
+            totalTokens: zod_1.z.number().nullable(),
+            cost: zod_1.z.number().nullable(),
+        }))
+            .query(async ({ input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await aiService.getUsage(input.userId));
+        }),
+    });
+}

package/dist/src/modules/ai/ideogram/ideogram.constants.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ideogramColorPalettePreset = exports.ideogramMagicPrompt = exports.ideogramRenderingSpeed = exports.ideogramAspectRatios = exports.ideogramResolutions = exports.ideogramStylePresets = exports.ideogramStyleTypes = void 0;
+exports.ideogramStyleTypes = ["AUTO", "GENERAL", "REALISTIC", "DESIGN", "FICTION"];
+exports.ideogramStylePresets = [
+    "80S_ILLUSTRATION",
+    "90S_NOSTALGIA",
+    "ABSTRACT_ORGANIC",
+    "ANALOG_NOSTALGIA",
+    "ART_BRUT",
+    "ART_DECO",
+    "ART_POSTER",
+    "AURA",
+    "AVANT_GARDE",
+    "BAUHAUS",
+    "BLUEPRINT",
+    "BLURRY_MOTION",
+    "BRIGHT_ART",
+    "C4D_CARTOON",
+    "CHILDRENS_BOOK",
+    "COLLAGE",
+    "COLORING_BOOK_I",
+    "COLORING_BOOK_II",
+    "CUBISM",
+    "DARK_AURA",
+    "DOODLE",
+    "DOUBLE_EXPOSURE",
+    "DRAMATIC_CINEMA",
+    "EDITORIAL",
+    "EMOTIONAL_MINIMAL",
+    "ETHEREAL_PARTY",
+    "EXPIRED_FILM",
+    "FLAT_ART",
+    "FLAT_VECTOR",
+    "FOREST_REVERIE",
+    "GEO_MINIMALIST",
+    "GLASS_PRISM",
+    "GOLDEN_HOUR",
+    "GRAFFITI_I",
+    "GRAFFITI_II",
+    "HALFTONE_PRINT",
+    "HIGH_CONTRAST",
+    "HIPPIE_ERA",
+    "ICONIC",
+    "JAPANDI_FUSION",
+    "JAZZY",
+    "LONG_EXPOSURE",
+    "MAGAZINE_EDITORIAL",
+    "MINIMAL_ILLUSTRATION",
+    "MIXED_MEDIA",
+    "MONOCHROME",
+    "NIGHTLIFE",
+    "OIL_PAINTING",
+    "OLD_CARTOONS",
+    "PAINT_GESTURE",
+    "POP_ART",
+    "RETRO_ETCHING",
+    "RIVIERA_POP",
+    "SPOTLIGHT_80S",
+    "STYLIZED_RED",
+    "SURREAL_COLLAGE",
+    "TRAVEL_POSTER",
+    "VINTAGE_GEO",
+    "VINTAGE_POSTER",
+];
+exports.ideogramResolutions = [
+    "512x1536",
+    "576x1408",
+    "576x1472",
+    "576x1536",
+    "640x1344",
+    "640x1408",
+    "640x1472",
+    "640x1536",
+    "704x1152",
+    "704x1216",
+    "704x1280",
+    "704x1344",
+    "704x1408",
+    "704x1472",
+    "736x1312",
+    "768x1088",
+    "768x1216",
+    "768x1280",
+    "768x1344",
+    "800x1280",
+    "832x960",
+    "832x1024",
+    "832x1088",
+    "832x1152",
+    "832x1216",
+    "832x1248",
+    "864x1152",
+    "896x960",
+    "896x1024",
+    "896x1088",
+    "896x1120",
+    "896x1152",
+    "960x832",
+    "960x896",
+    "960x1024",
+    "960x1088",
+    "960x1120",
+    "960x1152",
+    "1024x832",
+    "1024x896",
+    "1024x960",
+    "1024x1024",
+    "1088x768",
+    "1088x832",
+    "1088x896",
+    "1088x960",
+    "1120x896",
+    "1152x704",
+    "1152x832",
+    "1152x864",
+    "1152x896",
+    "1216x704",
+    "1216x768",
+    "1216x832",
+    "1248x832",
+    "1280x704",
+    "1280x768",
+    "1280x800",
+    "1312x736",
+    "1344x640",
+    "1344x704",
+    "1344x768",
+    "1408x576",
+    "1408x640",
+    "1408x704",
+    "1472x576",
+    "1472x640",
+    "1472x704",
+    "1536x512",
+    "1536x576",
+    "1536x640",
+];
+exports.ideogramAspectRatios = [
+    "1x3",
+    "3x1",
+    "1x2",
+    "2x1",
+    "9x16",
+    "16x9",
+    "10x16",
+    "16x10",
+    "2x3",
+    "3x2",
+    "3x4",
+    "4x3",
+    "4x5",
+    "5x4",
+    "1x1",
+];
+exports.ideogramRenderingSpeed = ["FLASH", "TURBO", "DEFAULT", "QUALITY"];
+exports.ideogramMagicPrompt = ["AUTO", "ON", "OFF"];
+exports.ideogramColorPalettePreset = [
+    "EMBER",
+    "FRESH",
+    "JUNGLE",
+    "MAGIC",
+    "MELON",
+    "MOSAIC",
+    "PASTEL",
+    "ULTRAMARINE",
+];

package/dist/src/modules/ai/ideogram/ideogram.dto.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ideogramV3GenerateOutputSchema = exports.ideogramV3GenerateInputSchema = exports.ideogramAISchema = void 0;
+const zod_1 = require("zod");
+const ideogram_constants_1 = require("#modules/ai/ideogram/ideogram.constants");
+exports.ideogramAISchema = zod_1.z.object({
+    prompt: zod_1.z.string().describe("Create a prompt for the image generation."),
+    style_type: zod_1.z.enum(ideogram_constants_1.ideogramStyleTypes).describe("Choose a style type for the image generation."),
+    // style_preset: z
+    //   .enum(ideogramStylePresets)
+    //   .describe("Choose a style preset for the image generation."),
+});
+exports.ideogramV3GenerateInputSchema = zod_1.z.object({
+    prompt: zod_1.z.string(),
+    seed: zod_1.z.number().optional(),
+    resolution: zod_1.z.enum(ideogram_constants_1.ideogramResolutions).optional(),
+    rendering_speed: zod_1.z.enum(ideogram_constants_1.ideogramRenderingSpeed).optional(),
+    magic_prompt: zod_1.z.enum(ideogram_constants_1.ideogramMagicPrompt).optional(),
+    negative_prompt: zod_1.z.string().optional(),
+    num_images: zod_1.z.number().optional(),
+    color_palette: zod_1.z
+        .object({
+        ColorPaletteWithPresetName: zod_1.z.object({ name: zod_1.z.enum(ideogram_constants_1.ideogramColorPalettePreset) }).optional(),
+        ColorPaletteWithMembers: zod_1.z
+            .object({
+            members: zod_1.z.array(zod_1.z.object({ color_hex: zod_1.z.string(), color_weight: zod_1.z.number().min(0.05).max(1) })),
+        })
+            .optional(),
+    })
+        .optional(),
+    style_codes: zod_1.z.array(zod_1.z.string()).optional(),
+    aspect_ratio: zod_1.z.enum(ideogram_constants_1.ideogramAspectRatios).optional(),
+    style_type: zod_1.z.enum(ideogram_constants_1.ideogramStyleTypes).optional(),
+    style_preset: zod_1.z.enum(ideogram_constants_1.ideogramStylePresets).optional(),
+    style_reference_images: zod_1.z.array(zod_1.z.file()).optional(),
+    character_reference_images: zod_1.z.array(zod_1.z.file()).optional(),
+    character_reference_images_mask: zod_1.z.file().optional(),
+});
+exports.ideogramV3GenerateOutputSchema = zod_1.z.object({
+    created: zod_1.z.string(),
+    data: zod_1.z.array(zod_1.z.object({
+        prompt: zod_1.z.string(),
+        resolution: zod_1.z.string(),
+        is_image_safe: zod_1.z.boolean(),
+        seed: zod_1.z.number(),
+        url: zod_1.z.url(),
+        style_type: zod_1.z.enum(ideogram_constants_1.ideogramStyleTypes),
+    })),
+});