@hed-hog/core 0.0.328 → 0.0.330

package/src/mcp-chat/mcp-chat.service.ts

@@ -0,0 +1,332 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+  BadRequestException,
+  ForbiddenException,
+  forwardRef,
+  HttpException,
+  HttpStatus,
+  Inject,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import axios from 'axios';
+import { SettingService } from '../setting/setting.service';
+import { McpContext } from '../mcp/types/mcp-context.type';
+import { McpRegistryService } from '../mcp/mcp-registry.service';
+import { CreateConversationDTO } from './dto/create-conversation.dto';
+
+type OpenAiMessage =
+  | { role: 'system'; content: string }
+  | { role: 'user'; content: string }
+  | { role: 'assistant'; content: string | null; tool_calls?: OpenAiToolCall[] }
+  | { role: 'tool'; tool_call_id: string; content: string };
+
+interface OpenAiToolCall {
+  id: string;
+  type: 'function';
+  function: { name: string; arguments: string };
+}
+
+const SYSTEM_PROMPT =
+  'You are a helpful assistant with access to tools from the HedHog system. ' +
+  'Use the available tools to answer the user\'s questions accurately. ' +
+  'Always respond in the same language the user writes in.';
+
+const sanitize = (n: string) => n.replace(/\./g, '__');
+const restore = (n: string) => n.replace(/__/g, '.');
+
+@Injectable()
+export class McpChatService {
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prisma: PrismaService,
+    @Inject(forwardRef(() => SettingService))
+    private readonly setting: SettingService,
+    @Inject(forwardRef(() => McpRegistryService))
+    private readonly registry: McpRegistryService,
+  ) {}
+
+  async listConversations(userId: number) {
+    return this.prisma.mcp_conversation.findMany({
+      where: { user_id: userId },
+      orderBy: { created_at: 'desc' },
+      select: { id: true, title: true, created_at: true, updated_at: true },
+    });
+  }
+
+  async createConversation(userId: number, dto: CreateConversationDTO) {
+    return this.prisma.mcp_conversation.create({
+      data: {
+        user_id: userId,
+        title: dto.title ?? null,
+      },
+    });
+  }
+
+  async deleteConversations(userId: number, ids: number[]) {
+    await this.prisma.mcp_conversation.deleteMany({
+      where: { id: { in: ids }, user_id: userId },
+    });
+    return { count: ids.length };
+  }
+
+  async getMessages(conversationId: number, userId: number) {
+    await this.assertOwnership(conversationId, userId);
+    return this.prisma.mcp_conversation_message.findMany({
+      where: { conversation_id: conversationId },
+      orderBy: { created_at: 'asc' },
+    });
+  }
+
+  async sendMessage(
+    conversationId: number,
+    userId: number,
+    locale: string,
+    message: string,
+  ) {
+    await this.assertOwnership(conversationId, userId);
+
+    const apiKey = await this.getOpenAiKey();
+
+    // Save user message
+    await this.prisma.mcp_conversation_message.create({
+      data: {
+        conversation_id: conversationId,
+        role: 'user',
+        content: message,
+      },
+    });
+
+    // Auto-set title on first message
+    const conv = await this.prisma.mcp_conversation.findUnique({
+      where: { id: conversationId },
+    });
+    if (!conv!.title) {
+      await this.prisma.mcp_conversation.update({
+        where: { id: conversationId },
+        data: { title: message.slice(0, 60) },
+      });
+    }
+
+    // Build OpenAI messages from history
+    const history = await this.prisma.mcp_conversation_message.findMany({
+      where: { conversation_id: conversationId },
+      orderBy: { created_at: 'asc' },
+    });
+
+    const openAiMessages: OpenAiMessage[] = [
+      { role: 'system', content: SYSTEM_PROMPT },
+      ...this.toOpenAiMessages(history),
+    ];
+
+    // Build tool definitions
+    const tools = this.registry.getAll().map((entry) => ({
+      type: 'function' as const,
+      function: {
+        name: sanitize(entry.definition.name),
+        description: entry.definition.description,
+        parameters: entry.definition.inputSchema ?? {
+          type: 'object',
+          properties: {},
+        },
+      },
+    }));
+
+    // Tool-calling loop
+    let maxIterations = 10;
+    while (maxIterations-- > 0) {
+      let response: any;
+      try {
+        response = await axios.post(
+          'https://api.openai.com/v1/chat/completions',
+          {
+            model: 'gpt-4o-mini',
+            messages: openAiMessages,
+            tools: tools.length > 0 ? tools : undefined,
+            tool_choice: tools.length > 0 ? 'auto' : undefined,
+          },
+          {
+            headers: {
+              Authorization: `Bearer ${apiKey}`,
+              'Content-Type': 'application/json',
+            },
+          },
+        );
+      } catch (err: any) {
+        const status = err?.response?.status;
+        const errBody = err?.response?.data?.error;
+        if (status === 429) {
+          throw new HttpException(
+            errBody?.message ?? 'OpenAI rate limit exceeded. Please try again later.',
+            HttpStatus.TOO_MANY_REQUESTS,
+          );
+        }
+        if (status === 401) {
+          throw new BadRequestException('Invalid OpenAI API key.');
+        }
+        throw new HttpException(
+          errBody?.message ?? 'OpenAI API error.',
+          status ?? HttpStatus.BAD_GATEWAY,
+        );
+      }
+
+      const choice = response.data?.choices?.[0];
+      const assistantMsg = choice?.message;
+
+      if (assistantMsg?.tool_calls?.length) {
+        // Add assistant tool-call message to context
+        openAiMessages.push({
+          role: 'assistant',
+          content: null,
+          tool_calls: assistantMsg.tool_calls,
+        });
+
+        // Execute each tool call
+        for (const toolCall of assistantMsg.tool_calls as OpenAiToolCall[]) {
+          const originalName = restore(toolCall.function.name);
+          const argsJson = toolCall.function.arguments;
+          let args: Record<string, any> = {};
+          try {
+            args = JSON.parse(argsJson);
+          } catch {
+            args = {};
+          }
+
+          // Persist tool_call message
+          await this.prisma.mcp_conversation_message.create({
+            data: {
+              conversation_id: conversationId,
+              role: 'tool_call',
+              content: argsJson,
+              tool_name: originalName,
+              tool_call_id: toolCall.id,
+            },
+          });
+
+          // Execute the tool
+          let resultContent: string;
+          const entry = this.registry.get(originalName);
+          if (entry) {
+            const context: McpContext = {
+              userId,
+              sessionId: '',
+              locale,
+              toolName: originalName,
+            };
+            try {
+              const result = await entry.handler(args, context);
+              resultContent = JSON.stringify(result);
+            } catch (e: any) {
+              resultContent = JSON.stringify({ error: e.message });
+            }
+          } else {
+            resultContent = JSON.stringify({ error: `Tool '${originalName}' not found` });
+          }
+
+          // Persist tool_result message
+          await this.prisma.mcp_conversation_message.create({
+            data: {
+              conversation_id: conversationId,
+              role: 'tool_result',
+              content: resultContent,
+              tool_name: originalName,
+              tool_call_id: toolCall.id,
+            },
+          });
+
+          // Add tool result to context for next iteration
+          openAiMessages.push({
+            role: 'tool',
+            tool_call_id: toolCall.id,
+            content: resultContent,
+          });
+        }
+
+        continue; // next iteration with tool results
+      }
+
+      // Final assistant response
+      const finalContent: string = assistantMsg?.content || '';
+      await this.prisma.mcp_conversation_message.create({
+        data: {
+          conversation_id: conversationId,
+          role: 'assistant',
+          content: finalContent,
+        },
+      });
+
+      return this.prisma.mcp_conversation_message.findMany({
+        where: { conversation_id: conversationId },
+        orderBy: { created_at: 'asc' },
+      });
+    }
+
+    throw new BadRequestException('Maximum tool call iterations exceeded.');
+  }
+
+  private toOpenAiMessages(
+    history: Array<{
+      role: string;
+      content: string;
+      tool_name: string | null;
+      tool_call_id: string | null;
+    }>,
+  ): OpenAiMessage[] {
+    const messages: OpenAiMessage[] = [];
+    const toolCallMap = new Map<string, string>(); // tool_call_id → sanitized name
+
+    for (const msg of history) {
+      if (msg.role === 'user') {
+        messages.push({ role: 'user', content: msg.content });
+      } else if (msg.role === 'assistant') {
+        messages.push({ role: 'assistant', content: msg.content });
+      } else if (msg.role === 'tool_call' && msg.tool_call_id && msg.tool_name) {
+        const sanitizedName = sanitize(msg.tool_name);
+        toolCallMap.set(msg.tool_call_id, sanitizedName);
+        messages.push({
+          role: 'assistant',
+          content: null,
+          tool_calls: [
+            {
+              id: msg.tool_call_id,
+              type: 'function',
+              function: { name: sanitizedName, arguments: msg.content },
+            },
+          ],
+        });
+      } else if (msg.role === 'tool_result' && msg.tool_call_id) {
+        messages.push({
+          role: 'tool',
+          tool_call_id: msg.tool_call_id,
+          content: msg.content,
+        });
+      }
+    }
+
+    return messages;
+  }
+
+  private async assertOwnership(conversationId: number, userId: number) {
+    const conv = await this.prisma.mcp_conversation.findUnique({
+      where: { id: conversationId },
+      select: { user_id: true },
+    });
+    if (!conv) {
+      throw new NotFoundException(`Conversation ${conversationId} not found.`);
+    }
+    if (conv.user_id !== userId) {
+      throw new ForbiddenException('Access denied to this conversation.');
+    }
+  }
+
+  private async getOpenAiKey(): Promise<string> {
+    const settings = await this.setting.getSettingValues(['ai-openai-api-key']);
+    const key = settings['ai-openai-api-key'];
+    if (!key) {
+      throw new BadRequestException(
+        'OpenAI API key is not configured (setting "ai-openai-api-key").',
+      );
+    }
+    return key;
+  }
+}

package/src/oauth/oauth.service.ts

@@ -1,14 +1,14 @@
 import { getLocaleText } from '@hed-hog/api-locale';
 import { PrismaService, user_account_provider_52222e2ecb_enum } from '@hed-hog/api-prisma';
 import {
-    BadRequestException,
-    ConflictException,
-    Inject,
-    Injectable,
-    Logger,
-    NotFoundException,
-    ServiceUnavailableException,
-    forwardRef
+  BadRequestException,
+  ConflictException,
+  Inject,
+  Injectable,
+  Logger,
+  NotFoundException,
+  ServiceUnavailableException,
+  forwardRef
 } from '@nestjs/common';
 import { AuthService } from '../auth/auth.service';
 import { FileService } from '../file/file.service';
@@ -21,9 +21,9 @@ import { UserService } from '../user/user.service';
 import { OAuthProvider } from './interfaces/OAuthProvider';
 import { OAuthCallbackCoordinatorService } from './oauth-callback-coordinator.service';
 import {
-    OAuthCallbackAlreadyProcessedError,
-    OAuthCallbackInProgressError,
-    OAuthProviderException,
+  OAuthCallbackAlreadyProcessedError,
+  OAuthCallbackInProgressError,
+  OAuthProviderException,
 } from './oauth.errors';
 import { FacebookProvider } from './providers/facebook.provider';
 import { GithubProvider } from './providers/github.provider';
@@ -362,7 +362,7 @@ export class OAuthService {
       data: {
         name: profile.name,
         role_user: {
-          connect: (await roleIds).map((role) => ({ id: role.id })),
+          create: (await roleIds).map((role) => ({ role_id: role.id })),
         },
         user_identifier: {
           create: {