insforge 0.3.2 → 1.2.10

package/backend/src/services/ai/ai-model.service.ts

@@ -0,0 +1,60 @@
+import { isCloudEnvironment } from '@/utils/environment.js';
+import { AIClientService } from '@/providers/ai/openrouter.provider.js';
+import type { RawOpenRouterModel } from '@/types/ai.js';
+import type { AIModelSchema } from '@insforge/shared-schemas';
+import { calculatePriceLevel, filterAndSortModalities, getProviderOrder } from './helpers.js';
+
+export class AIModelService {
+  /**
+   * Get all available AI models
+   * Fetches from cloud API if in cloud environment, otherwise from OpenRouter directly
+   */
+  static async getModels(): Promise<AIModelSchema[]> {
+    const credentialsService = AIClientService.getInstance();
+    const configured = credentialsService.isConfigured();
+
+    if (!configured) {
+      return [];
+    }
+
+    // Get API key from credentials service
+    const apiKey = await credentialsService.getApiKey();
+
+    // Determine the API endpoint based on environment
+    const apiUrl = isCloudEnvironment()
+      ? 'https://api.insforge.dev/ai/v1/models'
+      : 'https://openrouter.ai/api/v1/models/user';
+
+    // Fetch models from the appropriate endpoint
+    const response = await fetch(apiUrl, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to fetch models: ${response.statusText}`);
+    }
+
+    const data = (await response.json()) as { data: RawOpenRouterModel[] };
+    const rawModels = data.data || [];
+
+    const models: AIModelSchema[] = rawModels
+      .map((rawModel) => ({
+        id: rawModel.id, // OpenRouter provided model ID
+        modelId: rawModel.id,
+        provider: 'openrouter',
+        inputModality: filterAndSortModalities(rawModel.architecture?.input_modalities || []),
+        outputModality: filterAndSortModalities(rawModel.architecture?.output_modalities || []),
+        priceLevel: calculatePriceLevel(rawModel.pricing),
+      }))
+      .sort((a, b) => {
+        const [aCompany = '', bCompany = ''] = [a.id.split('/')[0], b.id.split('/')[0]];
+
+        const orderDiff = getProviderOrder(aCompany) - getProviderOrder(bCompany);
+        return orderDiff !== 0 ? orderDiff : a.id.localeCompare(b.id);
+      });
+
+    return models || [];
+  }
+}

package/backend/src/{core/ai/usage.ts → services/ai/ai-usage.service.ts}

@@ -1,5 +1,5 @@
 import { Pool } from 'pg';
-import { DatabaseManager } from '@/core/database/manager.js';
+import { DatabaseManager } from '@/infra/database/database.manager.js';
 import logger from '@/utils/logger.js';
 import type {
   AIUsageDataSchema,
@@ -9,8 +9,18 @@ import type {
 } from '@insforge/shared-schemas';
 
 export class AIUsageService {
+  private static instance: AIUsageService;
   private pool: Pool | null = null;
 
+  private constructor() {}
+
+  public static getInstance(): AIUsageService {
+    if (!AIUsageService.instance) {
+      AIUsageService.instance = new AIUsageService();
+    }
+    return AIUsageService.instance;
+  }
+
   private getPool(): Pool {
     if (!this.pool) {
       this.pool = DatabaseManager.getInstance().getPool();
@@ -19,9 +29,8 @@ export class AIUsageService {
   }
 
   async trackUsage(data: AIUsageDataSchema): Promise<{ id: string }> {
-    const client = await this.getPool().connect();
     try {
-      const result = await client.query(
+      const result = await this.getPool().query(
         `INSERT INTO _ai_usage (config_id, input_tokens, output_tokens, image_count, image_resolution)
          VALUES ($1, $2, $3, $4, $5)
          RETURNING id`,
@@ -46,8 +55,6 @@ export class AIUsageService {
     } catch (error) {
       logger.error('Failed to track AI usage', { error, data });
       throw new Error('Failed to track AI usage');
-    } finally {
-      client.release();
     }
   }
 
@@ -59,9 +66,8 @@ export class AIUsageService {
   ): Promise<{ id: string }> {
     const totalTokens = (inputTokens || 0) + (outputTokens || 0);
 
-    const client = await this.getPool().connect();
     try {
-      const usageResult = await client.query(
+      const usageResult = await this.getPool().query(
         `INSERT INTO _ai_usage (config_id, input_tokens, output_tokens, model_id)
          VALUES ($1, $2, $3, $4)
          RETURNING id`,
@@ -81,8 +87,6 @@ export class AIUsageService {
     } catch (error) {
       logger.error('Failed to track chat usage', { error, configId });
       throw new Error('Failed to track chat usage');
-    } finally {
-      client.release();
     }
   }
 
@@ -94,9 +98,8 @@ export class AIUsageService {
     outputTokens?: number,
     modelId?: string
   ): Promise<{ id: string }> {
-    const client = await this.getPool().connect();
     try {
-      const usageResult = await client.query(
+      const usageResult = await this.getPool().query(
         `INSERT INTO _ai_usage (config_id, image_count, image_resolution, input_tokens, output_tokens, model_id)
          VALUES ($1, $2, $3, $4, $5, $6)
          RETURNING id`,
@@ -124,8 +127,6 @@ export class AIUsageService {
     } catch (error) {
       logger.error('Failed to track image usage', { error, configId });
       throw new Error('Failed to track image usage');
-    } finally {
-      client.release();
     }
   }
 
@@ -134,10 +135,9 @@ export class AIUsageService {
     startDate?: Date,
     endDate?: Date
   ): Promise<AIUsageRecordSchema[]> {
-    const client = await this.getPool().connect();
     try {
       let query = `
-        SELECT id, config_id as "configId", input_tokens as "inputTokens", 
+        SELECT id, config_id as "configId", input_tokens as "inputTokens",
                output_tokens as "outputTokens", image_count as "imageCount",
                image_resolution as "imageResolution", created_at as "createdAt"
         FROM _ai_usage
@@ -158,14 +158,12 @@ export class AIUsageService {
 
       query += ' ORDER BY created_at DESC';
 
-      const result = await client.query(query, params);
+      const result = await this.getPool().query(query, params);
 
       return result.rows;
     } catch (error) {
       logger.error('Failed to fetch usage by config', { error, configId });
       throw new Error('Failed to fetch usage records');
-    } finally {
-      client.release();
     }
   }
 
@@ -174,10 +172,9 @@ export class AIUsageService {
     startDate?: Date,
     endDate?: Date
   ): Promise<AIUsageSummarySchema> {
-    const client = await this.getPool().connect();
     try {
       let query = `
-        SELECT 
+        SELECT
           COALESCE(SUM(input_tokens), 0) as "totalInputTokens",
           COALESCE(SUM(output_tokens), 0) as "totalOutputTokens",
           COALESCE(SUM(COALESCE(input_tokens, 0) + COALESCE(output_tokens, 0)), 0) as "totalTokens",
@@ -204,7 +201,7 @@ export class AIUsageService {
         query += ` AND created_at <= $${params.length}`;
       }
 
-      const result = await client.query(query, params);
+      const result = await this.getPool().query(query, params);
 
       return {
         totalInputTokens: parseInt(result.rows[0].totalInputTokens),
@@ -216,8 +213,6 @@ export class AIUsageService {
     } catch (error) {
       logger.error('Failed to fetch usage summary', { error, configId });
       throw new Error('Failed to fetch usage summary');
-    } finally {
-      client.release();
     }
   }
 
@@ -227,21 +222,21 @@ export class AIUsageService {
     limit?: number,
     offset?: number
   ): Promise<ListAIUsageResponse> {
-    const client = await this.getPool().connect();
     try {
       let query = `
-        SELECT 
-          u.id, 
-          u.config_id as "configId", 
-          u.input_tokens as "inputTokens", 
-          u.output_tokens as "outputTokens", 
+        SELECT
+          u.id,
+          u.config_id as "configId",
+          u.input_tokens as "inputTokens",
+          u.output_tokens as "outputTokens",
           u.image_count as "imageCount",
-          u.image_resolution as "imageResolution", 
+          u.image_resolution as "imageResolution",
           u.created_at as "createdAt",
           u.model_id as "modelId",
           COALESCE(u.model_id, c.model_id) as "model",
           c.provider,
-          c.modality
+          c.input_modality as "inputModality",
+          c.output_modality as "outputModality"
         FROM _ai_usage u
         LEFT JOIN _ai_configs c ON u.config_id = c.id
         WHERE 1=1
@@ -260,7 +255,7 @@ export class AIUsageService {
       }
 
       const countQuery = `SELECT COUNT(*) as total FROM (${query}) as subquery`;
-      const countResult = await client.query(countQuery, params);
+      const countResult = await this.getPool().query(countQuery, params);
 
       query += ' ORDER BY u.created_at DESC';
 
@@ -274,7 +269,7 @@ export class AIUsageService {
         query += ` OFFSET $${params.length}`;
       }
 
-      const result = await client.query(query, params);
+      const result = await this.getPool().query(query, params);
 
       return {
         records: result.rows,
@@ -283,8 +278,6 @@ export class AIUsageService {
     } catch (error) {
       logger.error('Failed to fetch all usage records', { error });
       throw new Error('Failed to fetch usage records');
-    } finally {
-      client.release();
     }
   }
 }

package/backend/src/{core/ai/chat.ts → services/ai/chat-completion.service.ts}

@@ -1,19 +1,29 @@
 import OpenAI from 'openai';
-import { AIUsageService } from './usage';
-import { AIConfigService } from './config';
-import { AIClientService } from './client';
+import { AIUsageService } from './ai-usage.service.js';
+import { AIConfigService } from './ai-config.service.js';
+import { AIClientService } from '@/providers/ai/openrouter.provider.js';
 import type {
   AIConfigurationSchema,
   ChatCompletionResponse,
   ChatMessageSchema,
 } from '@insforge/shared-schemas';
 import logger from '@/utils/logger.js';
-import { ChatCompletionOptions } from '@/types/ai';
+import { ChatCompletionOptions } from '@/types/ai.js';
 
-export class ChatService {
-  private aiUsageService = new AIUsageService();
-  private aiConfigService = new AIConfigService();
-  private aiCredentialsService = AIClientService.getInstance();
+export class ChatCompletionService {
+  private static instance: ChatCompletionService;
+  private aiUsageService = AIUsageService.getInstance();
+  private aiConfigService = AIConfigService.getInstance();
+  private aiClientService = AIClientService.getInstance();
+
+  private constructor() {}
+
+  public static getInstance(): ChatCompletionService {
+    if (!ChatCompletionService.instance) {
+      ChatCompletionService.instance = new ChatCompletionService();
+    }
+    return ChatCompletionService.instance;
+  }
 
   /**
    * Format messages for OpenAI API with multimodal support
@@ -31,8 +41,8 @@ export class ChatService {
 
     // Format conversation messages
     for (const msg of messages) {
-      // Check if message has images
-      if (msg.images && msg.images.length > 0) {
+      // Check if message has images (legacy format), new format image is within the content array
+      if (msg.images && msg.images.length && typeof msg.content === 'string') {
         // Build multimodal content array
         const content = [
           { type: 'text', text: msg.content },
@@ -47,11 +57,11 @@ export class ChatService {
           content,
         } as OpenAI.Chat.ChatCompletionMessageParam);
       } else {
-        // Simple text message
+        // Simple text message or new format (content array)
         formattedMessages.push({
           role: msg.role as 'system' | 'user' | 'assistant',
           content: msg.content,
-        });
+        } as OpenAI.Chat.ChatCompletionMessageParam);
       }
     }
 
@@ -81,23 +91,24 @@ export class ChatService {
     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({
+      const request: OpenAI.Chat.ChatCompletionCreateParamsNonStreaming = {
         model: options.model,
         messages: formattedMessages,
         temperature: options.temperature ?? 0.7,
         max_tokens: options.maxTokens ?? 4096,
         top_p: options.topP,
         stream: false,
-      });
+      };
+
+      // Send request with automatic renewal and retry logic
+      const response = await this.aiClientService.sendRequest((client) =>
+        client.chat.completions.create(request)
+      );
 
       // Extract token usage if available
       const tokenUsage = response.usage
@@ -122,7 +133,7 @@ export class ChatService {
         text: response.choices[0]?.message?.content || '',
         metadata: {
           model: options.model,
-          ...tokenUsage,
+          usage: tokenUsage,
         },
       };
     } catch (error) {
@@ -146,23 +157,25 @@ export class ChatService {
     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({
+      const request: OpenAI.Chat.ChatCompletionCreateParamsStreaming = {
         model: options.model,
         messages: formattedMessages,
         temperature: options.temperature ?? 0.7,
         max_tokens: options.maxTokens ?? 4096,
         top_p: options.topP,
         stream: true,
-      });
+      };
+
+      // Send request with automatic renewal and retry logic
+      const stream = await this.aiClientService.sendRequest((client) =>
+        client.chat.completions.create(request)
+      );
 
       const tokenUsage = {
         promptTokens: 0,

package/backend/src/services/ai/helpers.ts

@@ -0,0 +1,64 @@
+import type { RawOpenRouterModel } from '@/types/ai.js';
+import type { ModalitySchema } from '@insforge/shared-schemas';
+
+const MODALITY_ORDER = ['text', 'image', 'audio', 'video', 'file'];
+const PROVIDER_ORDER: Record<string, number> = {
+  openai: 1,
+  anthropic: 2,
+  google: 3,
+  amazon: 4,
+};
+
+/**
+ * Sort modalities by predefined order
+ */
+export function sortModalities(modalities: string[]): string[] {
+  return [...modalities].sort((a, b) => {
+    const aIndex = MODALITY_ORDER.indexOf(a);
+    const bIndex = MODALITY_ORDER.indexOf(b);
+    return aIndex - bIndex;
+  });
+}
+
+/**
+ * Filter to only supported modalities and sort
+ */
+export function filterAndSortModalities(modalities: string[]): ModalitySchema[] {
+  const supportedModalities: ModalitySchema[] = ['text', 'image'];
+  const filtered = modalities.filter((m): m is ModalitySchema =>
+    supportedModalities.includes(m as ModalitySchema)
+  );
+  return sortModalities(filtered) as ModalitySchema[];
+}
+
+/**
+ * Calculate price level (0-3)
+ */
+export function calculatePriceLevel(pricing: RawOpenRouterModel['pricing']): number {
+  if (!pricing) {
+    return 0;
+  }
+  if (pricing.prompt === '0' && pricing.completion === '0') {
+    return 0;
+  }
+
+  const promptCostPerToken = parseFloat(pricing.prompt) || 0;
+  const completionCostPerToken = parseFloat(pricing.completion) || 0;
+  const avgCostPer1M = ((promptCostPerToken + completionCostPerToken) / 2) * 1000000;
+
+  if (avgCostPer1M <= 3) {
+    return 1;
+  }
+  if (avgCostPer1M <= 15) {
+    return 2;
+  }
+  return 3;
+}
+
+/**
+ * Get provider order for sorting
+ */
+export function getProviderOrder(modelId: string): number {
+  const companyId = modelId.split('/')[0]?.toLowerCase() || '';
+  return PROVIDER_ORDER[companyId] || 999;
+}

package/backend/src/{core/ai/image.ts → services/ai/image-generation.service.ts}

@@ -1,20 +1,20 @@
 import OpenAI from 'openai';
 
-import { AIUsageService } from './usage';
-import { AIConfigService } from './config';
-import { AIClientService } from './client';
+import { AIUsageService } from './ai-usage.service.js';
+import { AIConfigService } from './ai-config.service.js';
+import { AIClientService } from '@/providers/ai/openrouter.provider.js';
 import type {
   AIConfigurationSchema,
   ImageGenerationRequest,
   ImageGenerationResponse,
 } from '@insforge/shared-schemas';
 import logger from '@/utils/logger.js';
-import { OpenRouterImageMessage } from '@/types/ai';
+import { OpenRouterImageMessage } from '@/types/ai.js';
 
-export class ImageService {
-  private static aiUsageService = new AIUsageService();
-  private static aiConfigService = new AIConfigService();
-  private static aiCredentialsService = AIClientService.getInstance();
+export class ImageGenerationService {
+  private static aiUsageService = AIUsageService.getInstance();
+  private static aiConfigService = AIConfigService.getInstance();
+  private static aiClientService = AIClientService.getInstance();
 
   /**
    * Validate model and get config
@@ -22,7 +22,7 @@ export class ImageService {
   private static async validateAndGetConfig(
     modelId: string
   ): Promise<AIConfigurationSchema | null> {
-    const aiConfig = await ImageService.aiConfigService.findByModelId(modelId);
+    const aiConfig = await ImageGenerationService.aiConfigService.findByModelId(modelId);
     if (!aiConfig) {
       throw new Error(
         `Model ${modelId} is not enabled. Please contact your administrator to enable this model.`
@@ -36,11 +36,8 @@ export class ImageService {
    * @param options - Image generation options
    */
   static async generate(options: ImageGenerationRequest): Promise<ImageGenerationResponse> {
-    // Get the client (handles validation and initialization automatically)
-    const client = await this.aiCredentialsService.getClient();
-
     // Validate model and get config
-    const aiConfig = await ImageService.validateAndGetConfig(options.model);
+    const aiConfig = await ImageGenerationService.validateAndGetConfig(options.model);
 
     const model = options.model;
 
@@ -77,10 +74,11 @@ export class ImageService {
         modalities: ['text', 'image'],
       };
 
-      // Use OpenRouter's standard chat completions API
-      // Cast the extended request to the base OpenAI type for the SDK call
-      const response = (await client.chat.completions.create(
-        request as OpenAI.Chat.ChatCompletionCreateParamsNonStreaming
+      // Send request with automatic renewal and retry logic
+      const response = (await this.aiClientService.sendRequest((client) =>
+        client.chat.completions.create(
+          request as OpenAI.Chat.ChatCompletionCreateParamsNonStreaming
+        )
       )) as OpenAI.Chat.ChatCompletion;
 
       // Initialize the result
@@ -99,7 +97,7 @@ export class ImageService {
       };
 
       // Process the OpenAI-compatible response
-      if (response.choices && response.choices.length > 0) {
+      if (response.choices && response.choices.length) {
         for (const choice of response.choices) {
           const message = choice.message;
 
@@ -135,7 +133,7 @@ export class ImageService {
         const inputTokens = result.metadata?.usage?.promptTokens;
         const outputTokens = result.metadata?.usage?.completionTokens;
 
-        await ImageService.aiUsageService.trackImageGenerationUsage(
+        await ImageGenerationService.aiUsageService.trackImageGenerationUsage(
           aiConfig.id,
           result.images.length,
           undefined, // image resolution not available from OpenRouter

package/backend/src/services/ai/index.ts

@@ -0,0 +1,13 @@
+export { AIConfigService } from './ai-config.service.js';
+export { AIModelService } from './ai-model.service.js';
+export { AIUsageService } from './ai-usage.service.js';
+export { ChatCompletionService } from './chat-completion.service.js';
+export { ImageGenerationService } from './image-generation.service.js';
+
+// Helper functions
+export {
+  sortModalities,
+  filterAndSortModalities,
+  calculatePriceLevel,
+  getProviderOrder,
+} from './helpers.js';