@m5kdev/backend 0.1.4 → 0.2.0

package/src/modules/ai/ai.service.ts

@@ -1,310 +0,0 @@
-import {
-  type AiEmbeddingModel,
-  type AiModel,
-  OPENAI_TEXT_EMBEDDING_3_SMALL,
-} from "@m5kdev/commons/modules/ai/ai.constants";
-import { arrayToPseudoXML } from "@m5kdev/commons/modules/ai/ai.utils";
-import type { Mastra } from "@mastra/core";
-import { RequestContext } from "@mastra/core/request-context";
-import type { FullOutput, MastraModelOutput } from "@mastra/core/stream";
-import { MDocument } from "@mastra/rag";
-import type { OpenRouterProvider } from "@openrouter/ai-sdk-provider";
-import { embed, embedMany, generateObject, generateText } from "ai";
-import { err, ok } from "neverthrow";
-import type Replicate from "replicate";
-import type { ZodType, z } from "zod";
-import type { AiUsageRepository, AiUsageRow } from "#modules/ai/ai.repository";
-import type {
-  IdeogramV3GenerateInput,
-  IdeogramV3GenerateOutput,
-} from "#modules/ai/ideogram/ideogram.dto";
-import type { IdeogramService } from "#modules/ai/ideogram/ideogram.service";
-import type { User } from "#modules/auth/auth.lib";
-import type { ServerResultAsync } from "#modules/base/base.dto";
-import { BaseService } from "#modules/base/base.service";
-
-type MastraAgent = ReturnType<Mastra["getAgent"]>;
-type MastraAgentGenerateOptions = Parameters<MastraAgent["generate"]>[1];
-type MessageListInput = { role: "user" | "assistant" | "system"; content: string }[];
-
-export class AIService<MastraInstance extends Mastra> extends BaseService<
-  { aiUsage?: AiUsageRepository },
-  { ideogram?: IdeogramService }
-> {
-  helpers = {
-    arrayToPseudoXML,
-  };
-
-  mastra?: MastraInstance;
-  openrouter?: OpenRouterProvider;
-  replicate?: Replicate;
-
-  constructor(
-    repositories: { aiUsage?: AiUsageRepository },
-    services: { ideogram?: IdeogramService },
-    libs: { mastra?: MastraInstance; openrouter?: OpenRouterProvider; replicate?: Replicate }
-  ) {
-    super(repositories, services);
-    this.mastra = libs.mastra;
-    this.openrouter = libs.openrouter;
-    this.replicate = libs.replicate;
-  }
-
-  getMastra(): MastraInstance {
-    if (!this.mastra) {
-      throw new Error("Mastra is not available");
-    }
-    return this.mastra;
-  }
-
-  prepareModel(model: AiModel): any {
-    if (!this.openrouter) {
-      throw new Error("OpenRouter is not configured");
-    }
-    const openrouterModel = this.openrouter.chat(model);
-    return openrouterModel;
-  }
-
-  prepareEmbeddingModel(model: AiEmbeddingModel): any {
-    if (!this.openrouter) {
-      throw new Error("OpenRouter is not configured");
-    }
-    const openrouterModel = this.openrouter.textEmbeddingModel(model);
-    return openrouterModel;
-  }
-
-  async agentUse(
-    agent: string,
-    options: MastraAgentGenerateOptions & { prompt?: string; messages?: MessageListInput },
-    ctx?: { user: User; model?: string }
-  ): ServerResultAsync<Awaited<ReturnType<MastraModelOutput<any>["getFullOutput"]>>> {
-    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 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 as any, {
-        ...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 as any)?.cost ?? 0,
-        });
-        if (createUsageResult.isErr()) return err(createUsageResult.error);
-      }
-      this.logger.info("AGENT USE CREATED USAGE");
-      return ok(result);
-    });
-  }
-
-  async agentText(
-    agent: string,
-    options: MastraAgentGenerateOptions & { prompt?: string; messages?: MessageListInput },
-    ctx?: { user: User; model?: string }
-  ): ServerResultAsync<string> {
-    const result = await this.agentUse(agent, options, ctx);
-    if (result.isErr())
-      return this.error("SERVICE_UNAVAILABLE", "AI: Agent text failed", { cause: result.error });
-    return ok(result.value.text);
-  }
-
-  async agentTextResult(
-    agent: string,
-    options: MastraAgentGenerateOptions & { prompt?: string; messages?: MessageListInput },
-    ctx?: { user: User; model?: string }
-  ): ServerResultAsync<FullOutput<any>> {
-    const result = await this.agentUse(agent, options, ctx);
-    if (result.isErr()) return err(result.error);
-    return ok(result.value);
-  }
-
-  async agentObject<T extends ZodType<any>>(
-    agent: string,
-    options: MastraAgentGenerateOptions & {
-      schema: T;
-      prompt?: string;
-      messages?: MessageListInput;
-    },
-    ctx?: { user: User; model?: string }
-  ): ServerResultAsync<z.infer<T>> {
-    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 ok(result.value.object as z.infer<T>);
-  }
-
-  async agentObjectResult<T extends ZodType<any>>(
-    agent: string,
-    options: MastraAgentGenerateOptions & {
-      schema: T;
-      prompt?: string;
-      messages?: MessageListInput;
-    },
-    ctx?: { user: User; model?: string }
-  ): ServerResultAsync<FullOutput<any> & { object: z.infer<T> }> {
-    this.logger.info("AGENT OBJECT RESULT");
-    const { schema, ...rest } = options;
-    const result = await this.agentUse(agent, { ...rest, structuredOutput: { schema } }, ctx);
-    if (result.isErr()) return err(result.error);
-    this.logger.info("AGENT OBJECT RESULT DONE");
-    return ok({ ...result.value, object: result.value.object as z.infer<T> });
-  }
-
-  async embedDocument(
-    value: string,
-    options?: Parameters<ReturnType<typeof MDocument.fromText>["chunk"]>[0],
-    type: "text" | "markdown" | "html" | "json" = "text",
-    model: AiEmbeddingModel = OPENAI_TEXT_EMBEDDING_3_SMALL
-  ): ServerResultAsync<{ embeddings: number[][]; chunks: { text: string }[] }> {
-    return this.throwableAsync(async () => {
-      if (type === "text") {
-        const doc = 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 err(embeddings.error);
-        return ok({ embeddings: embeddings.value.embeddings, chunks });
-      }
-      return this.error("BAD_REQUEST", "Unsupported document type");
-    });
-  }
-
-  async embed(
-    text: string,
-    model: AiEmbeddingModel = OPENAI_TEXT_EMBEDDING_3_SMALL
-  ): ServerResultAsync<{ embedding: number[] }> {
-    return this.throwableAsync(async () => {
-      const result = await embed({
-        model: this.prepareEmbeddingModel(model),
-        value: text,
-      });
-      return ok(result);
-    });
-  }
-
-  async embedMany(
-    chunks: { text: string }[],
-    model: AiEmbeddingModel = OPENAI_TEXT_EMBEDDING_3_SMALL
-  ): ServerResultAsync<{ embeddings: number[][] }> {
-    return this.throwableAsync(async () => {
-      const result = await embedMany({
-        model: this.prepareEmbeddingModel(model),
-        values: chunks.map((chunk) => chunk.text),
-      });
-      return ok(result);
-    });
-  }
-
-  async generateText(
-    params: Omit<Parameters<typeof generateText>[0], "model"> & {
-      model: AiModel;
-      removeMDash?: boolean;
-    }
-  ): ServerResultAsync<string> {
-    return this.throwableAsync(async () => {
-      const { removeMDash = true, model, ...rest } = params;
-      const result = await generateText({ ...rest, model: this.prepareModel(model) });
-      return ok(removeMDash ? result.text.replace(/\u2013|\u2014/g, "-") : result.text);
-    });
-  }
-
-  async generateObject<T extends ZodType>(
-    params: Omit<Parameters<typeof generateObject<T>>[0], "model" | "schema"> & {
-      model: AiModel;
-      schema: T;
-    }
-  ): ServerResultAsync<z.infer<T>> {
-    return this.throwableAsync(async () => {
-      const model = this.prepareModel(params.model);
-      const result = await generateObject({
-        ...params,
-        model,
-        schema: params.schema,
-      });
-      return ok(result.object as z.infer<T>);
-    });
-  }
-
-  async generateReplicate(
-    model: Parameters<Replicate["run"]>[0],
-    options: Parameters<Replicate["run"]>[1]
-  ): ServerResultAsync<object> {
-    return this.throwableAsync(async () => {
-      if (!this.replicate) {
-        return this.error("INTERNAL_SERVER_ERROR", "Replicate is not configured");
-      }
-      try {
-        return ok(await this.replicate.run(model, options));
-      } catch (error) {
-        return this.error("INTERNAL_SERVER_ERROR", undefined, { cause: error });
-      }
-    });
-  }
-
-  async generateTranscript(
-    file_url: string
-  ): ServerResultAsync<{ text: string; metadata: unknown }> {
-    const output = await this.generateReplicate(
-      "thomasmol/whisper-diarization:1495a9cddc83b2203b0d8d3516e38b80fd1572ebc4bc5700ac1da56a9b3ed886",
-      {
-        input: {
-          file_url,
-        },
-      }
-    );
-
-    if (output.isErr()) return err(output.error);
-
-    try {
-      const { segments } = output.value as { segments: { text: string }[] };
-      return ok({ text: segments.map((segment) => segment.text).join(""), metadata: segments });
-    } catch (error) {
-      return this.error("INTERNAL_SERVER_ERROR", undefined, { cause: error });
-    }
-  }
-
-  async generateIdeogram(
-    input: IdeogramV3GenerateInput
-  ): ServerResultAsync<IdeogramV3GenerateOutput> {
-    if (!this.service.ideogram) {
-      return this.error("INTERNAL_SERVER_ERROR", "Ideogram service is not available");
-    }
-    return this.service.ideogram.generate(input);
-  }
-
-  async getUsage(
-    userId: string
-  ): ServerResultAsync<Pick<AiUsageRow, "inputTokens" | "outputTokens" | "totalTokens" | "cost">> {
-    if (!this.repository.aiUsage) {
-      return this.error("INTERNAL_SERVER_ERROR", "AI usage repository is not available");
-    }
-    return this.repository.aiUsage.getUsage(userId);
-  }
-}

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

@@ -1,22 +0,0 @@
-import type { Mastra } from "@mastra/core";
-import { z } from "zod";
-import type { AIService } from "#modules/ai/ai.service";
-import { adminProcedure, handleTRPCResult, router } from "#trpc";
-
-export function createAITRPC<MastraInstance extends Mastra>(aiService: AIService<MastraInstance>) {
-  return router({
-    getUserUsage: adminProcedure
-      .input(z.object({ userId: z.string() }))
-      .output(
-        z.object({
-          inputTokens: z.number().nullable(),
-          outputTokens: z.number().nullable(),
-          totalTokens: z.number().nullable(),
-          cost: z.number().nullable(),
-        })
-      )
-      .query(async ({ input }) => {
-        return handleTRPCResult(await aiService.getUsage(input.userId));
-      }),
-  });
-}

package/src/modules/ai/ideogram/ideogram.constants.ts

@@ -1,170 +0,0 @@
-export const ideogramStyleTypes = ["AUTO", "GENERAL", "REALISTIC", "DESIGN", "FICTION"] as const;
-
-export const 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",
-] as const;
-
-export const 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",
-] as const;
-
-export const ideogramAspectRatios = [
-  "1x3",
-  "3x1",
-  "1x2",
-  "2x1",
-  "9x16",
-  "16x9",
-  "10x16",
-  "16x10",
-  "2x3",
-  "3x2",
-  "3x4",
-  "4x3",
-  "4x5",
-  "5x4",
-  "1x1",
-] as const;
-
-export const ideogramRenderingSpeed = ["FLASH", "TURBO", "DEFAULT", "QUALITY"] as const;
-
-export const ideogramMagicPrompt = ["AUTO", "ON", "OFF"] as const;
-
-export const ideogramColorPalettePreset = [
-  "EMBER",
-  "FRESH",
-  "JUNGLE",
-  "MAGIC",
-  "MELON",
-  "MOSAIC",
-  "PASTEL",
-  "ULTRAMARINE",
-] as const;

package/src/modules/ai/ideogram/ideogram.dto.ts

@@ -1,64 +0,0 @@
-import { z } from "zod";
-import {
-  ideogramAspectRatios,
-  ideogramColorPalettePreset,
-  ideogramMagicPrompt,
-  ideogramRenderingSpeed,
-  ideogramResolutions,
-  ideogramStylePresets,
-  ideogramStyleTypes,
-} from "#modules/ai/ideogram/ideogram.constants";
-
-export const ideogramAISchema = z.object({
-  prompt: z.string().describe("Create a prompt for the image generation."),
-  style_type: z.enum(ideogramStyleTypes).describe("Choose a style type for the image generation."),
-  // style_preset: z
-  //   .enum(ideogramStylePresets)
-  //   .describe("Choose a style preset for the image generation."),
-});
-
-export const ideogramV3GenerateInputSchema = z.object({
-  prompt: z.string(),
-  seed: z.number().optional(),
-  resolution: z.enum(ideogramResolutions).optional(),
-  rendering_speed: z.enum(ideogramRenderingSpeed).optional(),
-  magic_prompt: z.enum(ideogramMagicPrompt).optional(),
-  negative_prompt: z.string().optional(),
-  num_images: z.number().optional(),
-  color_palette: z
-    .object({
-      ColorPaletteWithPresetName: z.object({ name: z.enum(ideogramColorPalettePreset) }).optional(),
-      ColorPaletteWithMembers: z
-        .object({
-          members: z.array(
-            z.object({ color_hex: z.string(), color_weight: z.number().min(0.05).max(1) })
-          ),
-        })
-        .optional(),
-    })
-    .optional(),
-  style_codes: z.array(z.string()).optional(),
-  aspect_ratio: z.enum(ideogramAspectRatios).optional(),
-  style_type: z.enum(ideogramStyleTypes).optional(),
-  style_preset: z.enum(ideogramStylePresets).optional(),
-  style_reference_images: z.array(z.file()).optional(),
-  character_reference_images: z.array(z.file()).optional(),
-  character_reference_images_mask: z.file().optional(),
-});
-
-export const ideogramV3GenerateOutputSchema = z.object({
-  created: z.string(),
-  data: z.array(
-    z.object({
-      prompt: z.string(),
-      resolution: z.string(),
-      is_image_safe: z.boolean(),
-      seed: z.number(),
-      url: z.url(),
-      style_type: z.enum(ideogramStyleTypes),
-    })
-  ),
-});
-
-export type IdeogramV3GenerateInput = z.infer<typeof ideogramV3GenerateInputSchema>;
-export type IdeogramV3GenerateOutput = z.infer<typeof ideogramV3GenerateOutputSchema>;