insforge 0.3.1

package/backend/src/core/ai/chat.ts

@@ -0,0 +1,207 @@
+import OpenAI from 'openai';
+import { AIUsageService } from './usage';
+import { AIConfigService } from './config';
+import { AIClientService } from './client';
+import type {
+  AIConfigurationSchema,
+  ChatCompletionResponse,
+  ChatMessageSchema,
+} from '@insforge/shared-schemas';
+import logger from '@/utils/logger.js';
+import { ChatCompletionOptions } from '@/types/ai';
+
+export class ChatService {
+  private aiUsageService = new AIUsageService();
+  private aiConfigService = new AIConfigService();
+  private aiCredentialsService = AIClientService.getInstance();
+
+  /**
+   * Format messages for OpenAI API with multimodal support
+   */
+  private formatMessages(
+    messages: ChatMessageSchema[],
+    systemPrompt?: string
+  ): OpenAI.Chat.ChatCompletionMessageParam[] {
+    const formattedMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [];
+
+    // Add system message if provided
+    if (systemPrompt) {
+      formattedMessages.push({ role: 'system', content: systemPrompt });
+    }
+
+    // Format conversation messages
+    for (const msg of messages) {
+      // Check if message has images
+      if (msg.images && msg.images.length > 0) {
+        // Build multimodal content array
+        const content = [
+          { type: 'text', text: msg.content },
+          ...msg.images.map((image) => ({
+            type: 'image_url',
+            image_url: { url: image.url },
+          })),
+        ];
+
+        formattedMessages.push({
+          role: msg.role as 'system' | 'user' | 'assistant',
+          content,
+        } as OpenAI.Chat.ChatCompletionMessageParam);
+      } else {
+        // Simple text message
+        formattedMessages.push({
+          role: msg.role as 'system' | 'user' | 'assistant',
+          content: msg.content,
+        });
+      }
+    }
+
+    return formattedMessages;
+  }
+
+  /**
+   * Validate model and get config
+   */
+  async validateAndGetConfig(modelId: string): Promise<AIConfigurationSchema | null> {
+    const aiConfig = await this.aiConfigService.findByModelId(modelId);
+    if (!aiConfig) {
+      throw new Error(
+        `Model ${modelId} is not enabled. Please contact your administrator to enable this model.`
+      );
+    }
+    return aiConfig;
+  }
+
+  /**
+   * Send a chat message to the specified model
+   * @param messages - Array of messages for conversation
+   * @param options - Chat options including model, temperature, etc.
+   */
+  async chat(
+    messages: ChatMessageSchema[],
+    options: ChatCompletionOptions
+  ): Promise<ChatCompletionResponse> {
+    try {
+      // Get the client (handles validation and initialization automatically)
+      const client = await this.aiCredentialsService.getClient();
+
+      // Validate model and get config
+      const aiConfig = await this.validateAndGetConfig(options.model);
+
+      // Apply system prompt from config if available
+      const formattedMessages = this.formatMessages(messages, aiConfig?.systemPrompt);
+
+      const response = await client.chat.completions.create({
+        model: options.model,
+        messages: formattedMessages,
+        temperature: options.temperature ?? 0.7,
+        max_tokens: options.maxTokens ?? 4096,
+        top_p: options.topP,
+        stream: false,
+      });
+
+      // Extract token usage if available
+      const tokenUsage = response.usage
+        ? {
+            promptTokens: response.usage.prompt_tokens,
+            completionTokens: response.usage.completion_tokens,
+            totalTokens: response.usage.total_tokens,
+          }
+        : undefined;
+
+      // Track usage if config is available
+      if (aiConfig?.id && tokenUsage) {
+        await this.aiUsageService.trackChatUsage(
+          aiConfig.id,
+          tokenUsage.promptTokens,
+          tokenUsage.completionTokens,
+          options.model
+        );
+      }
+
+      return {
+        text: response.choices[0]?.message?.content || '',
+        metadata: {
+          model: options.model,
+          ...tokenUsage,
+        },
+      };
+    } catch (error) {
+      logger.error('Chat error', { error });
+      throw new Error(
+        `Failed to get response: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  /**
+   * Stream a chat response
+   * @param messages - Array of messages for conversation
+   * @param options - Chat options including model, temperature, etc.
+   */
+  async *streamChat(
+    messages: ChatMessageSchema[],
+    options: ChatCompletionOptions
+  ): AsyncGenerator<{
+    chunk?: string;
+    tokenUsage?: { promptTokens?: number; completionTokens?: number; totalTokens?: number };
+  }> {
+    try {
+      // Get the client (handles validation and initialization automatically)
+      const client = await this.aiCredentialsService.getClient();
+
+      // Validate model and get config
+      const aiConfig = await this.validateAndGetConfig(options.model);
+
+      // Apply system prompt from config if available
+      const formattedMessages = this.formatMessages(messages, aiConfig?.systemPrompt);
+
+      const stream = await client.chat.completions.create({
+        model: options.model,
+        messages: formattedMessages,
+        temperature: options.temperature ?? 0.7,
+        max_tokens: options.maxTokens ?? 4096,
+        top_p: options.topP,
+        stream: true,
+      });
+
+      const tokenUsage = {
+        promptTokens: 0,
+        completionTokens: 0,
+        totalTokens: 0,
+      };
+
+      for await (const chunk of stream) {
+        const content = chunk.choices[0]?.delta?.content;
+        if (content) {
+          yield { chunk: content };
+        }
+
+        // Check if this chunk contains usage data
+        if (chunk.usage) {
+          // Accumulate tokens instead of replacing
+          tokenUsage.promptTokens += chunk.usage.prompt_tokens || 0;
+          tokenUsage.completionTokens += chunk.usage.completion_tokens || 0;
+          tokenUsage.totalTokens += chunk.usage.total_tokens || 0;
+
+          // Yield the accumulated usage
+          yield { tokenUsage: { ...tokenUsage } };
+        }
+      }
+
+      // Track usage after streaming completes
+      if (aiConfig?.id && tokenUsage.totalTokens > 0) {
+        await this.aiUsageService.trackChatUsage(
+          aiConfig.id,
+          tokenUsage.promptTokens,
+          tokenUsage.completionTokens,
+          options.model
+        );
+      }
+    } catch (error) {
+      logger.error('Streaming error', { error });
+      throw new Error(
+        `Failed to stream response: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+}

package/backend/src/core/ai/client.ts

@@ -0,0 +1,242 @@
+import OpenAI from 'openai';
+import jwt from 'jsonwebtoken';
+import { isCloudEnvironment } from '@/utils/environment';
+import { AppError } from '@/api/middleware/error';
+import { ERROR_CODES } from '@/types/error-constants';
+
+interface CloudCredentialsResponse {
+  openrouter?: {
+    api_key: string;
+    limit?: number;
+    expired_at?: string | null;
+    usage?: number;
+    limit_remaining?: number;
+  };
+}
+
+interface CloudCredentials {
+  apiKey: string;
+  limitRemaining?: number;
+  expiredAt?: Date | null;
+}
+
+interface OpenRouterKeyInfo {
+  data: {
+    label: string;
+    usage: number;
+    limit: number | null;
+    is_free_tier: boolean;
+  };
+}
+
+interface OpenRouterLimitation {
+  label: string;
+  limit: number | null;
+  usage: number;
+  is_provisioning_key: boolean;
+  limit_remaining: number | null;
+  is_free_tier: boolean;
+  rate_limit: {
+    requests: number;
+    interval: string;
+    note: string;
+  };
+}
+
+export class AIClientService {
+  private static instance: AIClientService;
+  private cloudCredentials: CloudCredentials | undefined;
+  private openRouterClient: OpenAI | null = null;
+  private currentApiKey: string | undefined;
+
+  private constructor() {}
+
+  static getInstance(): AIClientService {
+    if (!AIClientService.instance) {
+      AIClientService.instance = new AIClientService();
+    }
+    return AIClientService.instance;
+  }
+
+  /**
+   * Create or recreate the OpenAI client with the given API key
+   */
+  private createClient(apiKey: string): OpenAI {
+    this.currentApiKey = apiKey;
+    return new OpenAI({
+      baseURL: 'https://openrouter.ai/api/v1',
+      apiKey,
+      defaultHeaders: {
+        'HTTP-Referer': 'https://insforge.dev',
+        'X-Title': 'InsForge',
+      },
+    });
+  }
+
+  /**
+   * Get OpenRouter API key based on environment
+   * In cloud environment: fetches from cloud API with JWT authentication
+   * In local environment: returns from environment variable
+   */
+  async getApiKey(): Promise<string> {
+    if (isCloudEnvironment()) {
+      if (
+        this.cloudCredentials &&
+        (!this.cloudCredentials.expiredAt || new Date() <= this.cloudCredentials.expiredAt)
+      ) {
+        return this.cloudCredentials.apiKey;
+      } else {
+        return await this.fetchCloudApiKey();
+      }
+    }
+
+    const apiKey = process.env.OPENROUTER_API_KEY;
+    if (!apiKey) {
+      throw new AppError(
+        'OPENROUTER_API_KEY not found in environment variables',
+        500,
+        ERROR_CODES.AI_INVALID_API_KEY
+      );
+    }
+    return apiKey;
+  }
+
+  /**
+   * Get the OpenAI client, creating or updating it as needed
+   * This is the main method services should use
+   */
+  async getClient(): Promise<OpenAI> {
+    if (!this.openRouterClient) {
+      this.openRouterClient = this.createClient(await this.getApiKey());
+      return this.openRouterClient;
+    }
+    if (isCloudEnvironment()) {
+      const apiKey = await this.getApiKey();
+      if (this.currentApiKey !== apiKey) {
+        this.openRouterClient = this.createClient(apiKey);
+      }
+    }
+    return this.openRouterClient;
+  }
+
+  /**
+   * Check if AI services are properly configured
+   */
+  isConfigured(): boolean {
+    if (isCloudEnvironment()) {
+      return true;
+    }
+    return !!process.env.OPENROUTER_API_KEY;
+  }
+
+  /**
+   * Get remaining credits for the current API key from OpenRouter
+   */
+  async getRemainingCredits(): Promise<{
+    usage: number;
+    limit: number | null;
+    remaining: number | null;
+  }> {
+    try {
+      const apiKey = await this.getApiKey();
+
+      if (isCloudEnvironment()) {
+        // Use InsForge API for cloud environment
+        const response = await fetch(
+          `https://api.insforge.dev/ai/v1/limitations?credential=${encodeURIComponent(apiKey)}`,
+          {
+            method: 'GET',
+          }
+        );
+
+        if (!response.ok) {
+          throw new Error(`Failed to fetch key info: ${response.statusText}`);
+        }
+
+        const result = (await response.json()) as { data: OpenRouterLimitation };
+        const keyInfo = result.data;
+
+        return {
+          usage: keyInfo.usage,
+          limit: keyInfo.limit,
+          remaining: keyInfo.limit_remaining,
+        };
+      } else {
+        // Use OpenRouter API for local environment
+        const response = await fetch('https://openrouter.ai/api/v1/key', {
+          method: 'GET',
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+          },
+        });
+
+        if (!response.ok) {
+          throw new AppError(
+            `Invalid OpenRouter API Key`,
+            500,
+            ERROR_CODES.AI_INVALID_API_KEY,
+            'Check your OpenRouter key and try again.'
+          );
+        }
+
+        const keyInfo = (await response.json()) as OpenRouterKeyInfo;
+
+        return {
+          usage: keyInfo.data.usage,
+          limit: keyInfo.data.limit,
+          remaining: keyInfo.data.limit !== null ? keyInfo.data.limit - keyInfo.data.usage : null,
+        };
+      }
+    } catch (error) {
+      console.error('Failed to fetch remaining credits:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Fetch API key from cloud service
+   */
+  private async fetchCloudApiKey(): Promise<string> {
+    try {
+      const projectId = process.env.PROJECT_ID;
+      if (!projectId) {
+        throw new Error('PROJECT_ID not found in environment variables');
+      }
+
+      const jwtSecret = process.env.JWT_SECRET;
+      if (!jwtSecret) {
+        throw new Error('JWT_SECRET not found in environment variables');
+      }
+
+      // Sign a token for authentication
+      const token = jwt.sign({ projectId }, jwtSecret, { expiresIn: '1h' });
+
+      // Fetch API key from cloud service with sign token as query parameter
+      const response = await fetch(
+        `https://api.insforge.dev/ai/v1/credentials/${projectId}?sign=${token}`
+      );
+
+      if (!response.ok) {
+        throw new Error(`Failed to fetch cloud API key: ${response.statusText}`);
+      }
+
+      const data = (await response.json()) as CloudCredentialsResponse;
+
+      // Extract API key from the openrouter object in response
+      if (!data.openrouter?.api_key) {
+        throw new Error('Invalid response: missing openrouter API Key');
+      }
+
+      // Store credentials with metadata
+      this.cloudCredentials = {
+        apiKey: data.openrouter.api_key,
+        limitRemaining: data.openrouter.limit_remaining,
+        expiredAt: data.openrouter.expired_at ? new Date(data.openrouter.expired_at) : null,
+      };
+      return data.openrouter.api_key;
+    } catch (error) {
+      console.error('Failed to fetch cloud API key:', error);
+      throw error;
+    }
+  }
+}

package/backend/src/core/ai/config.ts

@@ -0,0 +1,187 @@
+import { Pool } from 'pg';
+import { DatabaseManager } from '@/core/database/manager.js';
+import logger from '@/utils/logger.js';
+import { AIConfigurationSchema, AIConfigurationWithUsageSchema } from '@insforge/shared-schemas';
+
+export class AIConfigService {
+  private pool: Pool | null = null;
+
+  private getPool(): Pool {
+    if (!this.pool) {
+      this.pool = DatabaseManager.getInstance().getPool();
+    }
+    return this.pool;
+  }
+
+  async create(
+    inputModality: string[],
+    outputModality: string[],
+    provider: string,
+    modelId: string,
+    systemPrompt?: string
+  ): Promise<{ id: string }> {
+    const client = await this.getPool().connect();
+    try {
+      const result = await client.query(
+        `INSERT INTO _ai_configs (input_modality, output_modality, provider, model_id, system_prompt)
+         VALUES ($1, $2, $3, $4, $5)
+         RETURNING id`,
+        [inputModality, outputModality, provider, modelId, systemPrompt || null]
+      );
+
+      logger.info('AI configuration created', { id: result.rows[0].id });
+      return { id: result.rows[0].id };
+    } catch (error) {
+      logger.error('Failed to create AI configuration', { error });
+      throw new Error('Failed to create AI configuration');
+    } finally {
+      client.release();
+    }
+  }
+
+  async findAll(): Promise<AIConfigurationWithUsageSchema[]> {
+    const client = await this.getPool().connect();
+    try {
+      // Use a single query with aggregation to get configs with usage stats
+      const result = await client.query(
+        `SELECT 
+          c.id,
+          c.input_modality as "inputModality",
+          c.output_modality as "outputModality",
+          c.provider,
+          c.model_id as "modelId",
+          c.system_prompt as "systemPrompt",
+          COALESCE(SUM(u.input_tokens), 0)::INTEGER as "totalInputTokens",
+          COALESCE(SUM(u.output_tokens), 0)::INTEGER as "totalOutputTokens",
+          COALESCE(SUM(u.input_tokens + u.output_tokens), 0)::INTEGER as "totalTokens",
+          COALESCE(SUM(u.image_count), 0)::INTEGER as "totalImageCount",
+          COALESCE(COUNT(u.id), 0)::INTEGER as "totalRequests"
+         FROM _ai_configs c
+         LEFT JOIN _ai_usage u ON c.id = u.config_id
+         GROUP BY c.id, c.input_modality, c.output_modality, c.provider, c.model_id, c.system_prompt, c.created_at
+         ORDER BY c.created_at DESC`
+      );
+
+      return result.rows.map((row) => ({
+        id: row.id,
+        inputModality: row.inputModality,
+        outputModality: row.outputModality,
+        provider: row.provider,
+        modelId: row.modelId,
+        systemPrompt: row.systemPrompt,
+        usageStats: {
+          totalInputTokens: row.totalInputTokens,
+          totalOutputTokens: row.totalOutputTokens,
+          totalTokens: row.totalTokens,
+          totalImageCount: row.totalImageCount,
+          totalRequests: row.totalRequests,
+        },
+      }));
+    } catch (error) {
+      logger.error('Failed to fetch AI configurations with usage', { error });
+      throw new Error('Failed to fetch AI configurations');
+    } finally {
+      client.release();
+    }
+  }
+
+  async update(id: string, systemPrompt: string | null): Promise<boolean> {
+    const client = await this.getPool().connect();
+    try {
+      const result = await client.query(
+        `UPDATE _ai_configs 
+         SET system_prompt = $1, updated_at = NOW()
+         WHERE id = $2`,
+        [systemPrompt, id]
+      );
+
+      const success = (result.rowCount ?? 0) > 0;
+      if (success) {
+        logger.info('AI configuration updated', { id });
+      }
+      return success;
+    } catch (error) {
+      logger.error('Failed to update AI configuration', { error, id });
+      throw new Error('Failed to update AI configuration');
+    } finally {
+      client.release();
+    }
+  }
+
+  async delete(id: string): Promise<boolean> {
+    const client = await this.getPool().connect();
+    try {
+      const result = await client.query('DELETE FROM _ai_configs WHERE id = $1', [id]);
+
+      const success = (result.rowCount ?? 0) > 0;
+      if (success) {
+        logger.info('AI configuration deleted', { id });
+      }
+      return success;
+    } catch (error) {
+      logger.error('Failed to delete AI configuration', { error, id });
+      throw new Error('Failed to delete AI configuration');
+    } finally {
+      client.release();
+    }
+  }
+
+  async findByModelId(modelId: string): Promise<AIConfigurationSchema | null> {
+    const client = await this.getPool().connect();
+    try {
+      const result = await client.query(
+        `SELECT id, input_modality as "inputModality", output_modality as "outputModality", provider, model_id as "modelId", system_prompt as "systemPrompt", created_at, updated_at
+         FROM _ai_configs
+         WHERE model_id = $1`,
+        [modelId]
+      );
+
+      if (result.rows.length === 0) {
+        return null;
+      }
+
+      const row = result.rows[0];
+      return {
+        id: row.id,
+        inputModality: row.inputModality,
+        outputModality: row.outputModality,
+        provider: row.provider,
+        modelId: row.modelId,
+        systemPrompt: row.systemPrompt,
+      };
+    } catch (error) {
+      logger.error('Failed to fetch AI configuration by modelId', {
+        error,
+        modelId,
+      });
+      throw new Error('Failed to fetch AI configuration');
+    } finally {
+      client.release();
+    }
+  }
+
+  /**
+   * Get AI metadata
+   */
+  async getMetadata(): Promise<{
+    models: Array<{ inputModality: string[]; outputModality: string[]; modelId: string }>;
+  }> {
+    try {
+      const configs = await this.findAll();
+
+      // Map configs to simplified model metadata
+      const models = configs.map((config) => ({
+        inputModality: config.inputModality,
+        outputModality: config.outputModality,
+        modelId: config.modelId,
+      }));
+
+      return { models };
+    } catch (error) {
+      logger.error('Failed to get AI metadata', {
+        error: error instanceof Error ? error.message : String(error),
+      });
+      return { models: [] };
+    }
+  }
+}