@nextsparkjs/plugin-ai 0.1.0-beta.1

package/lib/plugin-env.ts

@@ -0,0 +1,252 @@
+/**
+ * AI Plugin Environment Configuration (Server-Only)
+ *
+ * Uses centralized plugin environment loader from core
+ * Provides type-safe access to AI provider credentials and configuration
+ */
+
+import { getPluginEnv } from '@nextsparkjs/core/lib/plugins/env-loader'
+
+interface AIPluginEnvConfig {
+  // AI provider credentials
+  ANTHROPIC_API_KEY?: string
+  OPENAI_API_KEY?: string
+
+  // Ollama configuration
+  OLLAMA_BASE_URL?: string
+  OLLAMA_DEFAULT_MODEL?: string
+
+  // AI provider selection
+  USE_LOCAL_AI?: string
+  DEFAULT_CLOUD_MODEL?: string
+
+  // Plugin configuration
+  AI_PLUGIN_ENABLED?: string
+  AI_PLUGIN_DEBUG?: string
+  AI_PLUGIN_DEFAULT_PROVIDER?: string
+  AI_PLUGIN_MAX_TOKENS?: string
+  AI_PLUGIN_DEFAULT_TEMPERATURE?: string
+
+  // Cost tracking
+  AI_PLUGIN_COST_TRACKING_ENABLED?: string
+  AI_PLUGIN_DAILY_COST_LIMIT?: string
+  AI_PLUGIN_MONTHLY_COST_LIMIT?: string
+
+  // Rate limiting
+  AI_PLUGIN_RATE_LIMIT_REQUESTS_PER_MINUTE?: string
+  AI_PLUGIN_RATE_LIMIT_TOKENS_PER_MINUTE?: string
+}
+
+class PluginEnvironment {
+  private static instance: PluginEnvironment
+  private config: AIPluginEnvConfig = {}
+  private loaded = false
+
+  private constructor() {
+    this.loadEnvironment()
+  }
+
+  public static getInstance(): PluginEnvironment {
+    if (!PluginEnvironment.instance) {
+      PluginEnvironment.instance = new PluginEnvironment()
+    }
+    return PluginEnvironment.instance
+  }
+
+  private loadEnvironment(forceReload: boolean = false): void {
+    if (this.loaded && !forceReload) return
+
+    try {
+      // Use centralized plugin env loader
+      const env = getPluginEnv('ai')
+
+      this.config = {
+        // AI provider credentials
+        ANTHROPIC_API_KEY: env.ANTHROPIC_API_KEY,
+        OPENAI_API_KEY: env.OPENAI_API_KEY,
+
+        // Ollama configuration
+        OLLAMA_BASE_URL: env.OLLAMA_BASE_URL || 'http://localhost:11434',
+        OLLAMA_DEFAULT_MODEL: env.OLLAMA_DEFAULT_MODEL || 'llama3.2:3b',
+
+        // AI provider selection
+        USE_LOCAL_AI: env.USE_LOCAL_AI || 'false',
+        DEFAULT_CLOUD_MODEL: env.DEFAULT_CLOUD_MODEL || 'claude-sonnet-4-5-20250929',
+
+        // Plugin configuration
+        AI_PLUGIN_ENABLED: env.AI_PLUGIN_ENABLED || 'true',
+        AI_PLUGIN_DEBUG: env.AI_PLUGIN_DEBUG || 'false',
+        AI_PLUGIN_DEFAULT_PROVIDER: env.AI_PLUGIN_DEFAULT_PROVIDER || 'anthropic',
+        AI_PLUGIN_MAX_TOKENS: env.AI_PLUGIN_MAX_TOKENS || '4000',
+        AI_PLUGIN_DEFAULT_TEMPERATURE: env.AI_PLUGIN_DEFAULT_TEMPERATURE || '0.7',
+        AI_PLUGIN_COST_TRACKING_ENABLED: env.AI_PLUGIN_COST_TRACKING_ENABLED || 'true',
+        AI_PLUGIN_DAILY_COST_LIMIT: env.AI_PLUGIN_DAILY_COST_LIMIT || '10.00',
+        AI_PLUGIN_MONTHLY_COST_LIMIT: env.AI_PLUGIN_MONTHLY_COST_LIMIT || '100.00',
+        AI_PLUGIN_RATE_LIMIT_REQUESTS_PER_MINUTE: env.AI_PLUGIN_RATE_LIMIT_REQUESTS_PER_MINUTE || '60',
+        AI_PLUGIN_RATE_LIMIT_TOKENS_PER_MINUTE: env.AI_PLUGIN_RATE_LIMIT_TOKENS_PER_MINUTE || '50000'
+      }
+
+      this.logLoadedConfiguration()
+      this.loaded = true
+    } catch (error) {
+      console.error('[AI Plugin] Failed to load environment:', error)
+      this.loaded = true
+    }
+  }
+
+  private logLoadedConfiguration(): void {
+    if (process.env.NODE_ENV === 'development') {
+      console.log('[AI Plugin] ℹ️  Plugin Environment Configuration:')
+      console.log('  → AI Provider Credentials:')
+      console.log(`    - ANTHROPIC_API_KEY: ${this.config.ANTHROPIC_API_KEY ? '✓ set' : '✗ not set'}`)
+      console.log(`    - OPENAI_API_KEY: ${this.config.OPENAI_API_KEY ? '✓ set' : '✗ not set'}`)
+      console.log('  → AI Provider Selection:')
+      console.log(`    - USE_LOCAL_AI: ${this.config.USE_LOCAL_AI}`)
+      console.log(`    - DEFAULT_CLOUD_MODEL: ${this.config.DEFAULT_CLOUD_MODEL}`)
+      console.log('  → Ollama Configuration:')
+      console.log(`    - OLLAMA_BASE_URL: ${this.config.OLLAMA_BASE_URL}`)
+      console.log(`    - OLLAMA_DEFAULT_MODEL: ${this.config.OLLAMA_DEFAULT_MODEL}`)
+      console.log('  → Plugin Settings:')
+      const pluginVars = [
+        'AI_PLUGIN_ENABLED', 'AI_PLUGIN_DEBUG', 'AI_PLUGIN_DEFAULT_PROVIDER',
+        'AI_PLUGIN_MAX_TOKENS', 'AI_PLUGIN_DEFAULT_TEMPERATURE',
+        'AI_PLUGIN_COST_TRACKING_ENABLED', 'AI_PLUGIN_DAILY_COST_LIMIT',
+        'AI_PLUGIN_MONTHLY_COST_LIMIT', 'AI_PLUGIN_RATE_LIMIT_REQUESTS_PER_MINUTE',
+        'AI_PLUGIN_RATE_LIMIT_TOKENS_PER_MINUTE'
+      ]
+      for (const v of pluginVars) {
+        const value = this.config[v as keyof AIPluginEnvConfig]
+        console.log(`    - ${v}: ${value || 'default'}`)
+      }
+      console.log()
+    }
+  }
+
+  public getConfig(): AIPluginEnvConfig {
+    if (!this.loaded) {
+      this.loadEnvironment()
+    }
+    return this.config
+  }
+
+  // Helper methods
+  public getAnthropicApiKey(): string | undefined {
+    return this.getConfig().ANTHROPIC_API_KEY
+  }
+
+  public getOpenAiApiKey(): string | undefined {
+    return this.getConfig().OPENAI_API_KEY
+  }
+
+  public getOllamaBaseUrl(): string {
+    return this.getConfig().OLLAMA_BASE_URL || 'http://localhost:11434'
+  }
+
+  public getOllamaDefaultModel(): string {
+    return this.getConfig().OLLAMA_DEFAULT_MODEL || 'llama3.2:3b'
+  }
+
+  public isUseLocalAI(): boolean {
+    return this.getConfig().USE_LOCAL_AI === 'true'
+  }
+
+  public getDefaultCloudModel(): string {
+    return this.getConfig().DEFAULT_CLOUD_MODEL || 'claude-sonnet-4-5-20250929'
+  }
+
+  public getDefaultProvider(): string {
+    return this.getConfig().AI_PLUGIN_DEFAULT_PROVIDER || 'anthropic'
+  }
+
+  public getDefaultModel(): string {
+    const useLocal = this.isUseLocalAI()
+    const ollamaModel = this.getOllamaDefaultModel()
+    const cloudModel = this.getDefaultCloudModel()
+    console.log(`🔍 [getDefaultModel] USE_LOCAL_AI=${useLocal}, ollamaModel=${ollamaModel}, cloudModel=${cloudModel}`)
+    const selectedModel = useLocal ? ollamaModel : cloudModel
+    console.log(`🔍 [getDefaultModel] Returning: ${selectedModel}`)
+    return selectedModel
+  }
+
+  public getMaxTokens(): number {
+    return parseInt(this.getConfig().AI_PLUGIN_MAX_TOKENS || '4000', 10)
+  }
+
+  public getDefaultTemperature(): number {
+    return parseFloat(this.getConfig().AI_PLUGIN_DEFAULT_TEMPERATURE || '0.7')
+  }
+
+  public isCostTrackingEnabled(): boolean {
+    return this.getConfig().AI_PLUGIN_COST_TRACKING_ENABLED === 'true'
+  }
+
+  public getDailyCostLimit(): number {
+    return parseFloat(this.getConfig().AI_PLUGIN_DAILY_COST_LIMIT || '10.00')
+  }
+
+  public getMonthlyCostLimit(): number {
+    return parseFloat(this.getConfig().AI_PLUGIN_MONTHLY_COST_LIMIT || '100.00')
+  }
+
+  public getRateLimitRequestsPerMinute(): number {
+    return parseInt(this.getConfig().AI_PLUGIN_RATE_LIMIT_REQUESTS_PER_MINUTE || '60', 10)
+  }
+
+  public getRateLimitTokensPerMinute(): number {
+    return parseInt(this.getConfig().AI_PLUGIN_RATE_LIMIT_TOKENS_PER_MINUTE || '50000', 10)
+  }
+
+  public isPluginEnabled(): boolean {
+    return this.getConfig().AI_PLUGIN_ENABLED !== 'false'
+  }
+
+  public isDebugEnabled(): boolean {
+    return this.getConfig().AI_PLUGIN_DEBUG === 'true'
+  }
+
+  public validateEnvironment(): { valid: boolean; errors: string[] } {
+    const errors: string[] = []
+    const config = this.getConfig()
+
+    if (!config.USE_LOCAL_AI || config.USE_LOCAL_AI === 'false') {
+      if (!config.ANTHROPIC_API_KEY && !config.OPENAI_API_KEY) {
+        errors.push('Cloud AI is enabled but no API keys are configured (ANTHROPIC_API_KEY or OPENAI_API_KEY required)')
+      }
+    }
+
+    if (config.AI_PLUGIN_ENABLED === 'false') {
+      errors.push('AI Plugin is disabled (AI_PLUGIN_ENABLED=false)')
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors
+    }
+  }
+
+  public reload(): void {
+    this.loaded = false
+    this.loadEnvironment(true)
+  }
+}
+
+export const pluginEnv = PluginEnvironment.getInstance()
+
+// Convenience exports
+export const getAnthropicApiKey = () => pluginEnv.getAnthropicApiKey()
+export const getOpenAiApiKey = () => pluginEnv.getOpenAiApiKey()
+export const getOllamaBaseUrl = () => pluginEnv.getOllamaBaseUrl()
+export const getOllamaDefaultModel = () => pluginEnv.getOllamaDefaultModel()
+export const isUseLocalAI = () => pluginEnv.isUseLocalAI()
+export const getDefaultCloudModel = () => pluginEnv.getDefaultCloudModel()
+export const getDefaultProvider = () => pluginEnv.getDefaultProvider()
+export const getDefaultModel = () => pluginEnv.getDefaultModel()
+export const getMaxTokens = () => pluginEnv.getMaxTokens()
+export const getDefaultTemperature = () => pluginEnv.getDefaultTemperature()
+export const isCostTrackingEnabled = () => pluginEnv.isCostTrackingEnabled()
+export const getDailyCostLimit = () => pluginEnv.getDailyCostLimit()
+export const getMonthlyCostLimit = () => pluginEnv.getMonthlyCostLimit()
+export const getRateLimitRequestsPerMinute = () => pluginEnv.getRateLimitRequestsPerMinute()
+export const getRateLimitTokensPerMinute = () => pluginEnv.getRateLimitTokensPerMinute()
+export const isPluginEnabled = () => pluginEnv.isPluginEnabled()
+export const isDebugEnabled = () => pluginEnv.isDebugEnabled()

package/lib/sanitize.ts

@@ -0,0 +1,122 @@
+/**
+ * Data sanitization utilities for AI examples
+ * Removes sensitive information before storing examples
+ */
+
+const SENSITIVE_PATTERNS = {
+  // Email addresses
+  email: /[\w.-]+@[\w.-]+\.\w+/gi,
+
+  // API keys and tokens
+  apiKey: /[a-zA-Z0-9]{20,}/g,
+  bearerToken: /Bearer\s+[\w-]+\.[\w-]+\.[\w-]+/gi,
+
+  // Common secret patterns
+  password: /password['":\s=]+[\w!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]+/gi,
+  secret: /secret['":\s=]+[\w!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]+/gi,
+
+  // Credit card numbers (basic pattern)
+  creditCard: /\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b/g,
+
+  // Phone numbers (basic pattern)
+  phone: /\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/g,
+
+  // URLs with credentials
+  urlWithCredentials: /https?:\/\/[^:]+:[^@]+@[^\s]+/gi,
+}
+
+const REPLACEMENTS = {
+  email: '[EMAIL_REDACTED]',
+  apiKey: '[API_KEY_REDACTED]',
+  bearerToken: 'Bearer [TOKEN_REDACTED]',
+  password: 'password: [REDACTED]',
+  secret: 'secret: [REDACTED]',
+  creditCard: '[CARD_REDACTED]',
+  phone: '[PHONE_REDACTED]',
+  urlWithCredentials: 'https://[CREDENTIALS_REDACTED]',
+}
+
+export interface SanitizationResult {
+  sanitized: string
+  redactedCount: number
+  redactedTypes: string[]
+}
+
+/**
+ * Sanitize text by removing sensitive information
+ */
+export function sanitizeText(text: string): SanitizationResult {
+  if (!text || typeof text !== 'string') {
+    return {
+      sanitized: text || '',
+      redactedCount: 0,
+      redactedTypes: []
+    }
+  }
+
+  let sanitized = text
+  let redactedCount = 0
+  const redactedTypes: string[] = []
+
+  for (const [type, pattern] of Object.entries(SENSITIVE_PATTERNS)) {
+    const matches = sanitized.match(pattern)
+    if (matches && matches.length > 0) {
+      const replacement = REPLACEMENTS[type as keyof typeof REPLACEMENTS]
+      sanitized = sanitized.replace(pattern, replacement)
+      redactedCount += matches.length
+      redactedTypes.push(type)
+    }
+  }
+
+  return {
+    sanitized,
+    redactedCount,
+    redactedTypes
+  }
+}
+
+/**
+ * Sanitize prompt before saving as example
+ */
+export function sanitizePrompt(prompt: string): string {
+  return sanitizeText(prompt).sanitized
+}
+
+/**
+ * Sanitize response before saving as example
+ */
+export function sanitizeResponse(response: string): string {
+  return sanitizeText(response).sanitized
+}
+
+/**
+ * Check if text contains sensitive information
+ */
+export function containsSensitiveInfo(text: string): boolean {
+  if (!text || typeof text !== 'string') {
+    return false
+  }
+
+  for (const pattern of Object.values(SENSITIVE_PATTERNS)) {
+    if (pattern.test(text)) {
+      return true
+    }
+  }
+
+  return false
+}
+
+/**
+ * Get sanitization report for a text
+ */
+export function getSanitizationReport(text: string): {
+  hasSensitiveInfo: boolean
+  details: SanitizationResult
+} {
+  const details = sanitizeText(text)
+
+  return {
+    hasSensitiveInfo: details.redactedCount > 0,
+    details
+  }
+}

package/lib/save-example.ts

@@ -0,0 +1,237 @@
+/**
+ * AI Example Saving - PostgreSQL Implementation
+ *
+ * Uses project's PostgreSQL connection with RLS support.
+ * Self-contained plugin with direct DB access.
+ */
+
+import { mutateWithRLS, queryWithRLS } from '@nextsparkjs/core/lib/db'
+import { sanitizePrompt, sanitizeResponse } from './sanitize'
+
+export interface AIExampleData {
+  title?: string
+  prompt: string
+  response: string
+  model: string
+  status: 'pending' | 'processing' | 'completed' | 'failed'
+  userId?: string
+  metadata?: {
+    tokens?: number
+    cost?: number
+    duration?: number
+    provider?: string
+    isLocal?: boolean
+    platforms?: number
+    imagesProcessed?: number
+  }
+}
+
+export interface SaveExampleResult {
+  success: boolean
+  id?: string
+  error?: string
+  sanitizationApplied?: boolean
+}
+
+/**
+ * Save AI example to PostgreSQL database
+ */
+export async function saveAIExample(
+  data: AIExampleData,
+  userId: string
+): Promise<SaveExampleResult> {
+  try {
+    // 1. Sanitize sensitive data
+    const sanitizedPrompt = sanitizePrompt(data.prompt)
+    const sanitizedResponse = sanitizeResponse(data.response)
+
+    const sanitizationApplied =
+      sanitizedPrompt !== data.prompt ||
+      sanitizedResponse !== data.response
+
+    // 2. Generate title if not provided
+    const title = data.title || generateTitle(sanitizedPrompt)
+
+    // 3. Insert into database with RLS
+    const query = `
+      INSERT INTO ai_example (
+        title, prompt, response, model, status, "userId", metadata, "createdAt", "updatedAt"
+      ) VALUES ($1, $2, $3, $4, $5, $6, $7, NOW(), NOW())
+      RETURNING id
+    `
+
+    const params = [
+      title,
+      sanitizedPrompt,
+      sanitizedResponse,
+      data.model,
+      data.status,
+      userId,
+      JSON.stringify(data.metadata || {})
+    ]
+
+    const result = await mutateWithRLS<{ id: string }>(query, params, userId)
+
+    if (result.rowCount === 0 || !result.rows[0]) {
+      return {
+        success: false,
+        error: 'Failed to insert example'
+      }
+    }
+
+    console.log('[AI Plugin] Example saved to database:', {
+      id: result.rows[0].id,
+      title,
+      sanitizationApplied
+    })
+
+    return {
+      success: true,
+      id: result.rows[0].id,
+      sanitizationApplied
+    }
+
+  } catch (error) {
+    console.error('[AI Plugin] Save example failed:', error)
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error'
+    }
+  }
+}
+
+/**
+ * Get AI examples from PostgreSQL
+ */
+export async function getAIExamples(params: {
+  userId?: string
+  limit?: number
+  offset?: number
+  status?: string
+}) {
+  try {
+    const { userId, limit = 50, offset = 0, status } = params
+
+    let query = `
+      SELECT id, title, prompt, response, model, status, "userId", metadata, "createdAt", "updatedAt"
+      FROM ai_example
+      WHERE 1=1
+    `
+    const queryParams: (string | number)[] = []
+
+    if (status) {
+      queryParams.push(status)
+      query += ` AND status = $${queryParams.length}`
+    }
+
+    query += ` ORDER BY "createdAt" DESC LIMIT $${queryParams.length + 1} OFFSET $${queryParams.length + 2}`
+    queryParams.push(limit, offset)
+
+    const rows = await queryWithRLS(query, queryParams, userId)
+
+    return {
+      success: true,
+      data: rows
+    }
+  } catch (error) {
+    console.error('[AI Plugin] Get examples failed:', error)
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error',
+      data: []
+    }
+  }
+}
+
+/**
+ * Get single AI example by ID from PostgreSQL
+ */
+export async function getAIExampleById(id: string, userId?: string) {
+  try {
+    const query = `
+      SELECT id, title, prompt, response, model, status, "userId", metadata, "createdAt", "updatedAt"
+      FROM ai_example
+      WHERE id = $1
+    `
+
+    const rows = await queryWithRLS(query, [id], userId)
+
+    if (rows.length === 0) {
+      return {
+        success: false,
+        error: 'Example not found'
+      }
+    }
+
+    return {
+      success: true,
+      data: rows[0]
+    }
+  } catch (error) {
+    console.error('[AI Plugin] Get example by ID failed:', error)
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error'
+    }
+  }
+}
+
+/**
+ * Delete AI example from PostgreSQL
+ */
+export async function deleteAIExample(id: string, userId: string) {
+  try {
+    const query = `DELETE FROM ai_example WHERE id = $1 RETURNING id`
+
+    const result = await mutateWithRLS<{ id: string }>(query, [id], userId)
+
+    if (result.rowCount === 0) {
+      return {
+        success: false,
+        error: 'Example not found or unauthorized'
+      }
+    }
+
+    return {
+      success: true,
+      id: result.rows[0].id
+    }
+  } catch (error) {
+    console.error('[AI Plugin] Delete example failed:', error)
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error'
+    }
+  }
+}
+
+/**
+ * Generate title from prompt (helper)
+ */
+function generateTitle(prompt: string): string {
+  const cleaned = prompt.replace(/\n/g, ' ').trim()
+  return cleaned.length > 50
+    ? cleaned.substring(0, 50) + '...'
+    : cleaned
+}
+
+/**
+ * Save example with automatic error handling (fire-and-forget)
+ */
+export async function saveExampleSafely(
+  data: AIExampleData,
+  userId: string
+): Promise<void> {
+  try {
+    const result = await saveAIExample(data, userId)
+
+    if (!result.success) {
+      console.error('[AI Plugin] Example save failed:', result.error)
+    } else if (result.sanitizationApplied) {
+      console.warn('[AI Plugin] Sanitization was applied to saved example')
+    }
+  } catch (error) {
+    // Silent fail - don't break the main request
+    console.error('[AI Plugin] Example save error:', error)
+  }
+}

package/lib/server-env.ts

@@ -0,0 +1,104 @@
+/**
+ * Server-Only Environment Variable Access
+ *
+ * This module provides server-only access to plugin environment variables
+ * preventing client-side access to sensitive configuration
+ */
+
+import { pluginEnv } from './plugin-env'
+
+// Server-only environment getters
+export async function getServerAnthropicApiKey(): Promise<string | undefined> {
+  return pluginEnv.getAnthropicApiKey()
+}
+
+export async function getServerOpenAiApiKey(): Promise<string | undefined> {
+  return pluginEnv.getOpenAiApiKey()
+}
+
+export async function getServerOllamaBaseUrl(): Promise<string> {
+  return pluginEnv.getOllamaBaseUrl()
+}
+
+export async function getServerOllamaDefaultModel(): Promise<string> {
+  return pluginEnv.getOllamaDefaultModel()
+}
+
+export async function isServerUseLocalAI(): Promise<boolean> {
+  return pluginEnv.isUseLocalAI()
+}
+
+export async function getServerDefaultCloudModel(): Promise<string> {
+  return pluginEnv.getDefaultCloudModel()
+}
+
+export async function getServerDefaultModel(): Promise<string> {
+  return pluginEnv.getDefaultModel()
+}
+
+export async function isServerPluginEnabled(): Promise<boolean> {
+  return pluginEnv.isPluginEnabled()
+}
+
+export async function isServerDebugEnabled(): Promise<boolean> {
+  return pluginEnv.isDebugEnabled()
+}
+
+export async function getServerDefaultProvider(): Promise<string> {
+  return pluginEnv.getDefaultProvider()
+}
+
+export async function getServerMaxTokens(): Promise<number> {
+  return pluginEnv.getMaxTokens()
+}
+
+export async function getServerDefaultTemperature(): Promise<number> {
+  return pluginEnv.getDefaultTemperature()
+}
+
+export async function isServerCostTrackingEnabled(): Promise<boolean> {
+  return pluginEnv.isCostTrackingEnabled()
+}
+
+export async function getServerDailyCostLimit(): Promise<number> {
+  return pluginEnv.getDailyCostLimit()
+}
+
+export async function getServerMonthlyCostLimit(): Promise<number> {
+  return pluginEnv.getMonthlyCostLimit()
+}
+
+export async function getServerRateLimitRequestsPerMinute(): Promise<number> {
+  return pluginEnv.getRateLimitRequestsPerMinute()
+}
+
+export async function getServerRateLimitTokensPerMinute(): Promise<number> {
+  return pluginEnv.getRateLimitTokensPerMinute()
+}
+
+export async function validateServerPluginEnvironment(): Promise<{ valid: boolean; errors: string[] }> {
+  return pluginEnv.validateEnvironment()
+}
+
+// Configuration object for API routes
+export async function getServerPluginConfig() {
+  return {
+    anthropicApiKey: await getServerAnthropicApiKey(),
+    openaiApiKey: await getServerOpenAiApiKey(),
+    ollamaBaseUrl: await getServerOllamaBaseUrl(),
+    ollamaDefaultModel: await getServerOllamaDefaultModel(),
+    useLocalAI: await isServerUseLocalAI(),
+    defaultCloudModel: await getServerDefaultCloudModel(),
+    defaultModel: await getServerDefaultModel(),
+    pluginEnabled: await isServerPluginEnabled(),
+    debugEnabled: await isServerDebugEnabled(),
+    defaultProvider: await getServerDefaultProvider(),
+    maxTokens: await getServerMaxTokens(),
+    defaultTemperature: await getServerDefaultTemperature(),
+    costTrackingEnabled: await isServerCostTrackingEnabled(),
+    dailyCostLimit: await getServerDailyCostLimit(),
+    monthlyCostLimit: await getServerMonthlyCostLimit(),
+    rateLimitRequestsPerMinute: await getServerRateLimitRequestsPerMinute(),
+    rateLimitTokensPerMinute: await getServerRateLimitTokensPerMinute()
+  }
+}