insforge 0.3.1

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

@@ -0,0 +1,156 @@
+import OpenAI from 'openai';
+
+import { AIUsageService } from './usage';
+import { AIConfigService } from './config';
+import { AIClientService } from './client';
+import type {
+  AIConfigurationSchema,
+  ImageGenerationRequest,
+  ImageGenerationResponse,
+} from '@insforge/shared-schemas';
+import logger from '@/utils/logger.js';
+import { OpenRouterImageMessage } from '@/types/ai';
+
+export class ImageService {
+  private static aiUsageService = new AIUsageService();
+  private static aiConfigService = new AIConfigService();
+  private static aiCredentialsService = AIClientService.getInstance();
+
+  /**
+   * Validate model and get config
+   */
+  private static async validateAndGetConfig(
+    modelId: string
+  ): Promise<AIConfigurationSchema | null> {
+    const aiConfig = await ImageService.aiConfigService.findByModelId(modelId);
+    if (!aiConfig) {
+      throw new Error(
+        `Model ${modelId} is not enabled. Please contact your administrator to enable this model.`
+      );
+    }
+    return aiConfig;
+  }
+
+  /**
+   * Generate images using the specified model
+   * @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 model = options.model;
+
+    try {
+      // Concatenate system prompt with user prompt if it exists
+      // This is because OpenRouter image models don't properly handle system messages
+      let finalPrompt = options.prompt;
+      if (aiConfig?.systemPrompt) {
+        finalPrompt = `${aiConfig.systemPrompt}\n\n${options.prompt}`;
+      }
+
+      // Build content for the message
+      const userContent = options.images?.length
+        ? [
+            { type: 'text', text: finalPrompt },
+            ...options.images.map((image) => ({
+              type: 'image_url',
+              image_url: { url: image.url },
+            })),
+          ]
+        : finalPrompt;
+
+      // Build the request - OpenRouter extends OpenAI's API with additional fields
+      const request = {
+        model,
+        messages: [
+          {
+            role: 'user',
+            content: userContent,
+          },
+        ],
+        stream: false, // Explicitly disable streaming
+        // OpenRouter-specific field for image generation
+        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
+      )) as OpenAI.Chat.ChatCompletion;
+
+      // Initialize the result
+      const result: ImageGenerationResponse = {
+        images: [],
+        metadata: {
+          model: model,
+          usage: response.usage
+            ? {
+                promptTokens: response.usage.prompt_tokens || 0,
+                completionTokens: response.usage.completion_tokens || 0,
+                totalTokens: response.usage.total_tokens || 0,
+              }
+            : undefined,
+        },
+      };
+
+      // Process the OpenAI-compatible response
+      if (response.choices && response.choices.length > 0) {
+        for (const choice of response.choices) {
+          const message = choice.message;
+
+          // Extract text content if present (for multimodal responses)
+          if (message.content) {
+            result.text = message.content;
+            // Use text as revised prompt if available
+          }
+
+          // OpenRouter adds an 'images' field to the assistant message for image generation
+          // Cast the message to include the extended OpenRouter fields
+          const extendedMessage = message as typeof message & {
+            images?: OpenRouterImageMessage[];
+          };
+
+          // Check for images in the OpenRouter format
+          if (extendedMessage.images && Array.isArray(extendedMessage.images)) {
+            for (const image of extendedMessage.images) {
+              if (image.type === 'image_url' && image.image_url?.url) {
+                result.images.push({
+                  type: 'imageUrl',
+                  imageUrl: image.image_url?.url,
+                });
+              }
+            }
+          }
+        }
+      }
+
+      // Track usage if config is available
+      if (aiConfig?.id) {
+        // Pass token usage information if available
+        const inputTokens = result.metadata?.usage?.promptTokens;
+        const outputTokens = result.metadata?.usage?.completionTokens;
+
+        await ImageService.aiUsageService.trackImageGenerationUsage(
+          aiConfig.id,
+          result.images.length,
+          undefined, // image resolution not available from OpenRouter
+          inputTokens,
+          outputTokens,
+          options.model
+        );
+      }
+
+      return result;
+    } catch (error) {
+      logger.error('Image generation error', { error });
+      throw new Error(
+        `Failed to generate image: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+}

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

@@ -0,0 +1,117 @@
+import { isCloudEnvironment } from '@/utils/environment';
+import { AIClientService } from './client';
+import type { RawOpenRouterModel } from '@/types/ai';
+import type { OpenRouterModel } from '@insforge/shared-schemas';
+
+export interface ModelProviderInfo {
+  provider: string;
+  configured: boolean;
+  models: OpenRouterModel[];
+}
+
+export interface ListModelsResponse {
+  text: ModelProviderInfo[];
+  image: ModelProviderInfo[];
+}
+
+export class AIModelService {
+  /**
+   * Get all available AI models
+   * Fetches from cloud API if in cloud environment, otherwise from OpenRouter directly
+   */
+  static async getModels(): Promise<ListModelsResponse> {
+    const credentialsService = AIClientService.getInstance();
+    const configured = credentialsService.isConfigured();
+
+    if (!configured) {
+      return {
+        text: [
+          {
+            provider: 'openrouter',
+            configured: false,
+            models: [],
+          },
+        ],
+        image: [
+          {
+            provider: 'openrouter',
+            configured: false,
+            models: [],
+          },
+        ],
+      };
+    }
+
+    // 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 models = data.data || [];
+
+    const textModels: OpenRouterModel[] = [];
+    const imageModels: OpenRouterModel[] = [];
+
+    for (const model of models) {
+      // Classify based on output modality
+      const transformedModel: OpenRouterModel = {
+        ...model,
+        architecture: model.architecture
+          ? {
+              inputModalities: model.architecture.input_modalities || [],
+              outputModalities: model.architecture.output_modalities || [],
+              tokenizer: model.architecture.tokenizer || '',
+              instructType: model.architecture.instruct_type || '',
+            }
+          : undefined,
+        topProvider: model.topProvider
+          ? {
+              isModerated: model.topProvider.is_moderated,
+              contextLength: model.topProvider.context_length,
+              maxCompletionTokens: model.topProvider.max_completion_tokens,
+            }
+          : undefined,
+      };
+
+      if (model.architecture?.output_modalities?.includes('image')) {
+        imageModels.push(transformedModel);
+      }
+
+      if (model.architecture?.output_modalities?.includes('text')) {
+        textModels.push(transformedModel);
+      }
+    }
+
+    return {
+      text: [
+        {
+          provider: 'openrouter',
+          configured: true,
+          models: textModels,
+        },
+      ],
+      image: [
+        {
+          provider: 'openrouter',
+          configured: true,
+          models: imageModels,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,290 @@
+import { Pool } from 'pg';
+import { DatabaseManager } from '@/core/database/manager.js';
+import logger from '@/utils/logger.js';
+import type {
+  AIUsageDataSchema,
+  AIUsageRecordSchema,
+  AIUsageSummarySchema,
+  ListAIUsageResponse,
+} from '@insforge/shared-schemas';
+
+export class AIUsageService {
+  private pool: Pool | null = null;
+
+  private getPool(): Pool {
+    if (!this.pool) {
+      this.pool = DatabaseManager.getInstance().getPool();
+    }
+    return this.pool;
+  }
+
+  async trackUsage(data: AIUsageDataSchema): Promise<{ id: string }> {
+    const client = await this.getPool().connect();
+    try {
+      const result = await client.query(
+        `INSERT INTO _ai_usage (config_id, input_tokens, output_tokens, image_count, image_resolution)
+         VALUES ($1, $2, $3, $4, $5)
+         RETURNING id`,
+        [
+          data.configId,
+          data.inputTokens || null,
+          data.outputTokens || null,
+          data.imageCount || null,
+          data.imageResolution || null,
+        ]
+      );
+
+      logger.info('AI usage tracked', {
+        id: result.rows[0].id,
+        configId: data.configId,
+        inputTokens: data.inputTokens,
+        outputTokens: data.outputTokens,
+        imageCount: data.imageCount,
+      });
+
+      return { id: result.rows[0].id };
+    } catch (error) {
+      logger.error('Failed to track AI usage', { error, data });
+      throw new Error('Failed to track AI usage');
+    } finally {
+      client.release();
+    }
+  }
+
+  async trackChatUsage(
+    configId: string,
+    inputTokens?: number,
+    outputTokens?: number,
+    modelId?: string
+  ): Promise<{ id: string }> {
+    const totalTokens = (inputTokens || 0) + (outputTokens || 0);
+
+    const client = await this.getPool().connect();
+    try {
+      const usageResult = await client.query(
+        `INSERT INTO _ai_usage (config_id, input_tokens, output_tokens, model_id)
+         VALUES ($1, $2, $3, $4)
+         RETURNING id`,
+        [configId, inputTokens || null, outputTokens || null, modelId || null]
+      );
+
+      logger.info('Chat usage tracked', {
+        id: usageResult.rows[0].id,
+        configId,
+        inputTokens,
+        outputTokens,
+        totalTokens,
+        modelId,
+      });
+
+      return { id: usageResult.rows[0].id };
+    } catch (error) {
+      logger.error('Failed to track chat usage', { error, configId });
+      throw new Error('Failed to track chat usage');
+    } finally {
+      client.release();
+    }
+  }
+
+  async trackImageGenerationUsage(
+    configId: string,
+    imageCount: number,
+    imageResolution?: string,
+    inputTokens?: number,
+    outputTokens?: number,
+    modelId?: string
+  ): Promise<{ id: string }> {
+    const client = await this.getPool().connect();
+    try {
+      const usageResult = await client.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`,
+        [
+          configId,
+          imageCount,
+          imageResolution || null,
+          inputTokens || null,
+          outputTokens || null,
+          modelId || null,
+        ]
+      );
+
+      logger.info('Image usage tracked', {
+        id: usageResult.rows[0].id,
+        configId,
+        imageCount,
+        imageResolution,
+        inputTokens,
+        outputTokens,
+        modelId,
+      });
+
+      return { id: usageResult.rows[0].id };
+    } catch (error) {
+      logger.error('Failed to track image usage', { error, configId });
+      throw new Error('Failed to track image usage');
+    } finally {
+      client.release();
+    }
+  }
+
+  async getUsageByConfig(
+    configId: string,
+    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", 
+               output_tokens as "outputTokens", image_count as "imageCount",
+               image_resolution as "imageResolution", created_at as "createdAt"
+        FROM _ai_usage
+        WHERE config_id = $1
+      `;
+
+      const params: (string | Date)[] = [configId];
+
+      if (startDate) {
+        params.push(startDate);
+        query += ` AND created_at >= $${params.length}`;
+      }
+
+      if (endDate) {
+        params.push(endDate);
+        query += ` AND created_at <= $${params.length}`;
+      }
+
+      query += ' ORDER BY created_at DESC';
+
+      const result = await client.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();
+    }
+  }
+
+  async getUsageSummary(
+    configId?: string,
+    startDate?: Date,
+    endDate?: Date
+  ): Promise<AIUsageSummarySchema> {
+    const client = await this.getPool().connect();
+    try {
+      let query = `
+        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",
+          COALESCE(SUM(image_count), 0) as "totalImageCount",
+          COUNT(*) as "totalRequests"
+        FROM _ai_usage
+        WHERE 1=1
+      `;
+
+      const params: (string | Date)[] = [];
+
+      if (configId) {
+        params.push(configId);
+        query += ` AND config_id = $${params.length}`;
+      }
+
+      if (startDate) {
+        params.push(startDate);
+        query += ` AND created_at >= $${params.length}`;
+      }
+
+      if (endDate) {
+        params.push(endDate);
+        query += ` AND created_at <= $${params.length}`;
+      }
+
+      const result = await client.query(query, params);
+
+      return {
+        totalInputTokens: parseInt(result.rows[0].totalInputTokens),
+        totalOutputTokens: parseInt(result.rows[0].totalOutputTokens),
+        totalTokens: parseInt(result.rows[0].totalTokens),
+        totalImageCount: parseInt(result.rows[0].totalImageCount),
+        totalRequests: parseInt(result.rows[0].totalRequests),
+      };
+    } catch (error) {
+      logger.error('Failed to fetch usage summary', { error, configId });
+      throw new Error('Failed to fetch usage summary');
+    } finally {
+      client.release();
+    }
+  }
+
+  async getAllUsage(
+    startDate?: Date,
+    endDate?: Date,
+    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", 
+          u.image_count as "imageCount",
+          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
+        FROM _ai_usage u
+        LEFT JOIN _ai_configs c ON u.config_id = c.id
+        WHERE 1=1
+      `;
+
+      const params: (string | Date | number)[] = [];
+
+      if (startDate) {
+        params.push(startDate);
+        query += ` AND u.created_at >= $${params.length}`;
+      }
+
+      if (endDate) {
+        params.push(endDate);
+        query += ` AND u.created_at <= $${params.length}`;
+      }
+
+      const countQuery = `SELECT COUNT(*) as total FROM (${query}) as subquery`;
+      const countResult = await client.query(countQuery, params);
+
+      query += ' ORDER BY u.created_at DESC';
+
+      if (limit) {
+        params.push(limit);
+        query += ` LIMIT $${params.length}`;
+      }
+
+      if (offset) {
+        params.push(offset);
+        query += ` OFFSET $${params.length}`;
+      }
+
+      const result = await client.query(query, params);
+
+      return {
+        records: result.rows,
+        total: parseInt(countResult.rows[0].total),
+      };
+    } catch (error) {
+      logger.error('Failed to fetch all usage records', { error });
+      throw new Error('Failed to fetch usage records');
+    } finally {
+      client.release();
+    }
+  }
+}