@hed-hog/core 0.0.222 → 0.0.232

package/src/ai/ai.service.ts

@@ -0,0 +1,546 @@
+import { PaginationDTO } from '@hed-hog/api-pagination';
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+  BadRequestException,
+  forwardRef,
+  Inject,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { Prisma } from '@prisma/client';
+import axios from 'axios';
+import { DeleteDTO } from '../dto/delete.dto';
+import { SettingService } from '../setting/setting.service';
+import { ChatAgentDTO } from './dto/chat-agent.dto';
+import { ChatDTO } from './dto/chat.dto';
+import { CreateAgentDTO } from './dto/create-agent.dto';
+import { UpdateAgentDTO } from './dto/update-agent.dto';
+
+type AiProvider = 'openai' | 'gemini';
+
+type AiAgentRecord = {
+  id: number;
+  slug: string;
+  provider: AiProvider;
+  model: string | null;
+  instructions: string | null;
+  external_agent_id: string | null;
+  created_at: Date;
+  updated_at: Date;
+};
+
+@Injectable()
+export class AiService {
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prismaService: PrismaService,
+    @Inject(forwardRef(() => SettingService))
+    private readonly settingService: SettingService,
+  ) {}
+
+  async chat(data: ChatDTO) {
+    const provider = data.provider || 'openai';
+
+    if (provider === 'openai') {
+      const model = data.model || 'gpt-4o-mini';
+      const content = await this.chatWithOpenAi({
+        message: data.message,
+        model,
+        systemPrompt: data.systemPrompt,
+      });
+
+      return {
+        provider,
+        model,
+        content,
+      };
+    }
+
+    const model = data.model || 'gemini-1.5-flash';
+    const content = await this.chatWithGemini({
+      message: data.message,
+      model,
+      systemPrompt: data.systemPrompt,
+    });
+
+    return {
+      provider,
+      model,
+      content,
+    };
+  }
+
+  async createAgent(data: CreateAgentDTO) {
+    const slug = data.slug.trim();
+    const provider = data.provider || 'openai';
+    const model = data.model || this.getDefaultModel(provider);
+    const instructions = data.instructions?.trim() || null;
+
+    const existing = await this.findAgentBySlug(slug);
+    if (existing) {
+      return existing;
+    }
+
+    let externalAgentId: string | null = null;
+
+    if (provider === 'openai') {
+      externalAgentId = await this.createOpenAiAssistant({
+        slug,
+        model,
+        instructions,
+      });
+    }
+
+    await this.prismaService.$executeRaw`
+      INSERT INTO ai_agent (slug, provider, model, instructions, external_agent_id)
+      VALUES (${slug}, ${provider}, ${model}, ${instructions}, ${externalAgentId})
+    `;
+
+    return this.findAgentBySlug(slug);
+  }
+
+  async listAgents(paginationParams: PaginationDTO) {
+    const page = Math.max(Number(paginationParams?.page || 1), 1);
+    const pageSize = Math.min(
+      Math.max(Number(paginationParams?.pageSize || 10), 1),
+      100,
+    );
+    const offset = (page - 1) * pageSize;
+    const search = String(paginationParams?.search || '').trim();
+
+    const whereClause = search
+      ? Prisma.sql`WHERE LOWER(slug) LIKE LOWER(${`%${search}%`})`
+      : Prisma.empty;
+
+    const data = await this.prismaService.$queryRaw<AiAgentRecord[]>(Prisma.sql`
+      SELECT id, slug, provider, model, instructions, external_agent_id, created_at, updated_at
+      FROM ai_agent
+      ${whereClause}
+      ORDER BY id DESC
+      LIMIT ${pageSize}
+      OFFSET ${offset}
+    `);
+
+    const totalResult = await this.prismaService.$queryRaw<Array<{ total: bigint | number | string }>>(Prisma.sql`
+      SELECT COUNT(*) AS total
+      FROM ai_agent
+      ${whereClause}
+    `);
+
+    const total = Number(totalResult?.[0]?.total || 0);
+
+    return {
+      data,
+      total,
+      page,
+      pageSize,
+      totalPages: Math.ceil(total / pageSize),
+    };
+  }
+
+  async getAgentById(agentId: number) {
+    const agent = await this.findAgentById(agentId);
+
+    if (!agent) {
+      throw new NotFoundException(`AI agent with id "${agentId}" was not found.`);
+    }
+
+    return agent;
+  }
+
+  async updateAgent(agentId: number, data: UpdateAgentDTO) {
+    const currentAgent = await this.findAgentById(agentId);
+
+    if (!currentAgent) {
+      throw new NotFoundException(`AI agent with id "${agentId}" was not found.`);
+    }
+
+    const slug = data.slug?.trim() ?? currentAgent.slug;
+    const provider = data.provider ?? currentAgent.provider;
+    const model = data.model ?? currentAgent.model ?? this.getDefaultModel(provider);
+    const instructions = data.instructions ?? currentAgent.instructions;
+
+    if (slug !== currentAgent.slug) {
+      const existingSlug = await this.findAgentBySlug(slug);
+      if (existingSlug && existingSlug.id !== agentId) {
+        throw new BadRequestException(`AI agent with slug "${slug}" already exists.`);
+      }
+    }
+
+    let externalAgentId = currentAgent.external_agent_id;
+
+    if (provider !== 'openai') {
+      externalAgentId = null;
+    } else if (!externalAgentId) {
+      externalAgentId = await this.createOpenAiAssistant({
+        slug,
+        model,
+        instructions,
+      });
+    }
+
+    await this.prismaService.$executeRaw`
+      UPDATE ai_agent
+      SET slug = ${slug},
+          provider = ${provider},
+          model = ${model},
+          instructions = ${instructions},
+          external_agent_id = ${externalAgentId},
+          updated_at = NOW()
+      WHERE id = ${agentId}
+    `;
+
+    return this.getAgentById(agentId);
+  }
+
+  async deleteAgents({ ids }: DeleteDTO) {
+    const existing = await this.prismaService.$queryRaw<Array<{ id: number }>>(Prisma.sql`
+      SELECT id
+      FROM ai_agent
+      WHERE id IN (${Prisma.join(ids)})
+    `);
+
+    if (existing.length !== ids.length) {
+      const existingIds = existing.map((item) => item.id);
+      const missingIds = ids.filter((id) => !existingIds.includes(id));
+      throw new NotFoundException(
+        `AI agents with ids "${missingIds.join(', ')}" were not found.`,
+      );
+    }
+
+    const deletedCount = await this.prismaService.$executeRaw`
+      DELETE FROM ai_agent
+      WHERE id IN (${Prisma.join(ids)})
+    `;
+
+    return {
+      count: Number(deletedCount || 0),
+    };
+  }
+
+  async chatWithAgent(slug: string, data: ChatAgentDTO) {
+    const agent = await this.findAgentBySlug(slug);
+
+    if (!agent) {
+      throw new NotFoundException(`AI agent with slug "${slug}" was not found.`);
+    }
+
+    if (agent.provider === 'openai') {
+      if (agent.external_agent_id) {
+        const content = await this.chatWithOpenAiAssistant(
+          agent.external_agent_id,
+          data.message,
+        );
+
+        return {
+          slug: agent.slug,
+          provider: agent.provider,
+          model: agent.model,
+          content,
+        };
+      }
+
+      const content = await this.chatWithOpenAi({
+        message: data.message,
+        model: agent.model || this.getDefaultModel('openai'),
+        systemPrompt: agent.instructions || undefined,
+      });
+
+      return {
+        slug: agent.slug,
+        provider: agent.provider,
+        model: agent.model,
+        content,
+      };
+    }
+
+    const content = await this.chatWithGemini({
+      message: data.message,
+      model: agent.model || this.getDefaultModel('gemini'),
+      systemPrompt: agent.instructions || undefined,
+    });
+
+    return {
+      slug: agent.slug,
+      provider: agent.provider,
+      model: agent.model,
+      content,
+    };
+  }
+
+  async getAgentBySlug(slug: string) {
+    const agent = await this.findAgentBySlug(slug);
+
+    if (!agent) {
+      throw new NotFoundException(`AI agent with slug "${slug}" was not found.`);
+    }
+
+    return agent;
+  }
+
+  private async findAgentBySlug(slug: string): Promise<AiAgentRecord | null> {
+    const result = await this.prismaService.$queryRaw<AiAgentRecord[]>`
+      SELECT id, slug, provider, model, instructions, external_agent_id, created_at, updated_at
+      FROM ai_agent
+      WHERE slug = ${slug}
+      LIMIT 1
+    `;
+
+    return result?.[0] || null;
+  }
+
+  private async findAgentById(id: number): Promise<AiAgentRecord | null> {
+    const result = await this.prismaService.$queryRaw<AiAgentRecord[]>`
+      SELECT id, slug, provider, model, instructions, external_agent_id, created_at, updated_at
+      FROM ai_agent
+      WHERE id = ${id}
+      LIMIT 1
+    `;
+
+    return result?.[0] || null;
+  }
+
+  private getDefaultModel(provider: AiProvider): string {
+    if (provider === 'openai') {
+      return 'gpt-4o-mini';
+    }
+
+    return 'gemini-1.5-flash';
+  }
+
+  private async getApiKeys() {
+    const settings = await this.settingService.getSettingValues([
+      'ai-openai-api-key',
+      'ai-gemini-api-key',
+    ]);
+
+    return {
+      openai: settings['ai-openai-api-key'],
+      gemini: settings['ai-gemini-api-key'],
+    };
+  }
+
+  private async chatWithOpenAi({
+    message,
+    model,
+    systemPrompt,
+  }: {
+    message: string;
+    model: string;
+    systemPrompt?: string;
+  }) {
+    const { openai } = await this.getApiKeys();
+
+    if (!openai) {
+      throw new BadRequestException(
+        'OpenAI API key is not configured (setting "ai-openai-api-key").',
+      );
+    }
+
+    const messages: Array<{ role: 'system' | 'user'; content: string }> = [];
+
+    if (systemPrompt) {
+      messages.push({ role: 'system', content: systemPrompt });
+    }
+
+    messages.push({ role: 'user', content: message });
+
+    const response = await axios.post(
+      'https://api.openai.com/v1/chat/completions',
+      {
+        model,
+        messages,
+      },
+      {
+        headers: {
+          Authorization: `Bearer ${openai}`,
+          'Content-Type': 'application/json',
+        },
+      },
+    );
+
+    return response.data?.choices?.[0]?.message?.content || '';
+  }
+
+  private async createOpenAiAssistant({
+    slug,
+    model,
+    instructions,
+  }: {
+    slug: string;
+    model: string;
+    instructions: string | null;
+  }): Promise<string> {
+    const { openai } = await this.getApiKeys();
+
+    if (!openai) {
+      throw new BadRequestException(
+        'OpenAI API key is not configured (setting "ai-openai-api-key").',
+      );
+    }
+
+    const response = await axios.post(
+      'https://api.openai.com/v1/assistants',
+      {
+        name: slug,
+        model,
+        instructions: instructions || `You are the assistant identified by slug ${slug}.`,
+      },
+      {
+        headers: {
+          Authorization: `Bearer ${openai}`,
+          'Content-Type': 'application/json',
+          'OpenAI-Beta': 'assistants=v2',
+        },
+      },
+    );
+
+    const assistantId = response.data?.id;
+
+    if (!assistantId) {
+      throw new BadRequestException('OpenAI assistant creation failed.');
+    }
+
+    return assistantId;
+  }
+
+  private async chatWithOpenAiAssistant(
+    assistantId: string,
+    message: string,
+  ): Promise<string> {
+    const { openai } = await this.getApiKeys();
+
+    if (!openai) {
+      throw new BadRequestException(
+        'OpenAI API key is not configured (setting "ai-openai-api-key").',
+      );
+    }
+
+    const threadResponse = await axios.post(
+      'https://api.openai.com/v1/threads',
+      {
+        messages: [{ role: 'user', content: message }],
+      },
+      {
+        headers: {
+          Authorization: `Bearer ${openai}`,
+          'Content-Type': 'application/json',
+          'OpenAI-Beta': 'assistants=v2',
+        },
+      },
+    );
+
+    const threadId = threadResponse.data?.id;
+
+    if (!threadId) {
+      throw new BadRequestException('OpenAI thread creation failed.');
+    }
+
+    const runResponse = await axios.post(
+      `https://api.openai.com/v1/threads/${threadId}/runs`,
+      {
+        assistant_id: assistantId,
+      },
+      {
+        headers: {
+          Authorization: `Bearer ${openai}`,
+          'Content-Type': 'application/json',
+          'OpenAI-Beta': 'assistants=v2',
+        },
+      },
+    );
+
+    const runId = runResponse.data?.id;
+
+    if (!runId) {
+      throw new BadRequestException('OpenAI assistant run failed to start.');
+    }
+
+    for (let i = 0; i < 30; i++) {
+      const runStatusResponse = await axios.get(
+        `https://api.openai.com/v1/threads/${threadId}/runs/${runId}`,
+        {
+          headers: {
+            Authorization: `Bearer ${openai}`,
+            'OpenAI-Beta': 'assistants=v2',
+          },
+        },
+      );
+
+      const status = runStatusResponse.data?.status;
+
+      if (status === 'completed') {
+        break;
+      }
+
+      if (['cancelled', 'failed', 'expired'].includes(status)) {
+        throw new BadRequestException(
+          `OpenAI assistant run did not complete successfully (status: ${status}).`,
+        );
+      }
+
+      await this.sleep(1000);
+    }
+
+    const messagesResponse = await axios.get(
+      `https://api.openai.com/v1/threads/${threadId}/messages`,
+      {
+        headers: {
+          Authorization: `Bearer ${openai}`,
+          'OpenAI-Beta': 'assistants=v2',
+        },
+      },
+    );
+
+    const assistantMessage = messagesResponse.data?.data?.find(
+      (item: any) => item.role === 'assistant',
+    );
+
+    const output = assistantMessage?.content?.[0]?.text?.value;
+
+    return output || '';
+  }
+
+  private async chatWithGemini({
+    message,
+    model,
+    systemPrompt,
+  }: {
+    message: string;
+    model: string;
+    systemPrompt?: string;
+  }) {
+    const { gemini } = await this.getApiKeys();
+
+    if (!gemini) {
+      throw new BadRequestException(
+        'Gemini API key is not configured (setting "ai-gemini-api-key").',
+      );
+    }
+
+    const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${gemini}`;
+
+    const payload: any = {
+      contents: [{ parts: [{ text: message }] }],
+    };
+
+    if (systemPrompt) {
+      payload.systemInstruction = {
+        parts: [{ text: systemPrompt }],
+      };
+    }
+
+    const response = await axios.post(url, payload, {
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+
+    const parts = response.data?.candidates?.[0]?.content?.parts || [];
+    return parts.map((part: any) => part.text || '').join('');
+  }
+
+  private async sleep(ms: number) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}

package/src/ai/dto/chat-agent.dto.ts

@@ -0,0 +1,7 @@
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class ChatAgentDTO {
+  @IsString()
+  @IsNotEmpty()
+  message: string;
+}

package/src/ai/dto/chat.dto.ts

@@ -0,0 +1,20 @@
+import { IsIn, IsNotEmpty, IsOptional, IsString } from 'class-validator';
+
+export class ChatDTO {
+  @IsString()
+  @IsNotEmpty()
+  message: string;
+
+  @IsOptional()
+  @IsString()
+  @IsIn(['openai', 'gemini'])
+  provider?: 'openai' | 'gemini';
+
+  @IsOptional()
+  @IsString()
+  model?: string;
+
+  @IsOptional()
+  @IsString()
+  systemPrompt?: string;
+}

package/src/ai/dto/create-agent.dto.ts

@@ -0,0 +1,20 @@
+import { IsIn, IsNotEmpty, IsOptional, IsString } from 'class-validator';
+
+export class CreateAgentDTO {
+  @IsString()
+  @IsNotEmpty()
+  slug: string;
+
+  @IsOptional()
+  @IsString()
+  @IsIn(['openai', 'gemini'])
+  provider?: 'openai' | 'gemini';
+
+  @IsOptional()
+  @IsString()
+  model?: string;
+
+  @IsOptional()
+  @IsString()
+  instructions?: string;
+}

package/src/ai/dto/update-agent.dto.ts

@@ -0,0 +1,20 @@
+import { IsIn, IsOptional, IsString } from 'class-validator';
+
+export class UpdateAgentDTO {
+  @IsOptional()
+  @IsString()
+  slug?: string;
+
+  @IsOptional()
+  @IsString()
+  @IsIn(['openai', 'gemini'])
+  provider?: 'openai' | 'gemini';
+
+  @IsOptional()
+  @IsString()
+  model?: string;
+
+  @IsOptional()
+  @IsString()
+  instructions?: string;
+}

package/src/core.module.ts

@@ -7,6 +7,7 @@ import { HttpModule } from '@nestjs/axios';
 import { forwardRef, Global, Inject, MiddlewareConsumer, Module, NestModule, OnModuleInit } from '@nestjs/common';
 import { ConfigModule } from '@nestjs/config';
 import { APP_INTERCEPTOR, Reflector } from '@nestjs/core';
+import { AiModule } from './ai/ai.module';
 import { AuthModule } from './auth/auth.module';
 import { SystemModule } from './core/system.module';
 import { DashboardModule } from './dashboard/dashboard.module';
@@ -37,6 +38,7 @@ import { ValidatorServiceLocator } from './validators/service-locator';
   imports: [
     HttpModule,
     ConfigModule.forRoot(),
+    forwardRef(() => AiModule),
     forwardRef(() => InstallModule),
     forwardRef(() => AuthModule),
     forwardRef(() => DashboardModule),
@@ -72,6 +74,7 @@ import { ValidatorServiceLocator } from './validators/service-locator';
     SettingModule,
     FileModule,
     SessionModule,
+    AiModule,
     IsStrongPasswordWithSettingsConstraint,
     IsEmailWithSettingsConstraint,
     IsPinCodeWithSettingConstraint,

package/src/file/file.service.ts

@@ -2,12 +2,12 @@ import { getLocaleText } from '@hed-hog/api-locale';
 import { PaginationDTO, PaginationService } from '@hed-hog/api-pagination';
 import { PrismaService } from '@hed-hog/api-prisma';
 import {
-  BadRequestException,
-  forwardRef,
-  Inject,
-  Injectable,
-  NotFoundException,
-  OnModuleInit
+    BadRequestException,
+    forwardRef,
+    Inject,
+    Injectable,
+    NotFoundException,
+    OnModuleInit
 } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
 import { SettingService } from '../setting/setting.service';
@@ -21,6 +21,23 @@ export class FileService implements OnModuleInit {
   private providerId: number;
   private mimetypes: Record<string, number> = {};
 
+  private hasMojibake(value: string): boolean {
+    return /Ã.|Â.|â[\u0080-\u00BF]/.test(value);
+  }
+
+  private normalizeUploadedFilename(filename: string): string {
+    if (!filename) {
+      return filename;
+    }
+
+    if (!this.hasMojibake(filename)) {
+      return filename;
+    }
+
+    const decoded = Buffer.from(filename, 'latin1').toString('utf8');
+    return this.hasMojibake(decoded) ? filename : decoded;
+  }
+
   constructor(
     @Inject(forwardRef(() => PrismaService))
     private readonly prismaService: PrismaService,
@@ -284,11 +301,20 @@ export class FileService implements OnModuleInit {
       throw new BadRequestException(`File too large: ${fileBuffer.size} bytes`);
     }
 
-    const url = await provider.upload(destination, fileBuffer);
+    const normalizedFilename = this.normalizeUploadedFilename(
+      fileBuffer.originalname,
+    );
+
+    const normalizedFile = {
+      ...fileBuffer,
+      originalname: normalizedFilename,
+    };
+
+    const url = await provider.upload(destination, normalizedFile);
 
     const file = await this.prismaService.file.create({
       data: {
-        filename: fileBuffer.originalname,
+        filename: normalizedFilename,
         path: url,
         provider_id: this.providerId,
         location: destination,

package/src/index.ts

@@ -23,6 +23,7 @@ export * from './mail/mail.module';
 export * from './mail/mail.service';
 
 export * from './setting/setting.service';
+export * from './ai/ai.service';
 
 // Validators
 export * from './validators/is-email-with-settings.validator';