ai-agent-router 0.1.0

package/src/app/api/logs/route.ts

@@ -0,0 +1,48 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getDatabase } from '@/db/database';
+import { getRequestLogs, getRequestLogById, getRequestLogCount } from '@/db/queries';
+
+// Ensure Node.js runtime (required for SQLite)
+export const runtime = 'nodejs';
+
+export async function GET(request: NextRequest) {
+  try {
+    getDatabase();
+    const { searchParams } = new URL(request.url);
+    const id = searchParams.get('id');
+    const limit = parseInt(searchParams.get('limit') || '100');
+    const offset = parseInt(searchParams.get('offset') || '0');
+    const modelId = searchParams.get('model_id');
+
+    if (id) {
+      const log = getRequestLogById(parseInt(id));
+      if (!log) {
+        return NextResponse.json(
+          { error: 'Log not found' },
+          { status: 404 }
+        );
+      }
+      return NextResponse.json(log);
+    }
+
+    const logs = getRequestLogs(
+      limit,
+      offset,
+      modelId ? parseInt(modelId) : undefined
+    );
+    const total = getRequestLogCount(modelId ? parseInt(modelId) : undefined);
+
+    return NextResponse.json({
+      logs,
+      total,
+      limit,
+      offset,
+    });
+  } catch (error: any) {
+    console.error('Logs API error:', error);
+    return NextResponse.json(
+      { error: error.message || 'Internal server error', stack: process.env.NODE_ENV === 'development' ? error.stack : undefined },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/models/route.ts

@@ -0,0 +1,210 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getDatabase } from '@/db/database';
+import {
+  getAllModels,
+  createModel,
+  updateModel,
+  deleteModel,
+  getModelsByProvider,
+  getProviderById,
+} from '@/db/queries';
+import { getProviderAdapter } from '@/server/providers';
+
+// Ensure Node.js runtime (required for SQLite)
+export const runtime = 'nodejs';
+
+export async function GET(request: NextRequest) {
+  try {
+    getDatabase();
+    const { searchParams } = new URL(request.url);
+    const providerId = searchParams.get('provider_id');
+
+    if (providerId) {
+      const models = getModelsByProvider(parseInt(providerId));
+      return NextResponse.json(models);
+    } else {
+      const models = getAllModels();
+      return NextResponse.json(models);
+    }
+  } catch (error: any) {
+    console.error('Models API error:', error);
+    return NextResponse.json(
+      { error: error.message || 'Internal server error', stack: process.env.NODE_ENV === 'development' ? error.stack : undefined },
+      { status: 500 }
+    );
+  }
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    getDatabase();
+    const body = await request.json();
+    const { provider_id, name, model_id, enabled } = body;
+
+    if (!provider_id || !name || !model_id) {
+      return NextResponse.json(
+        { error: 'Missing required fields' },
+        { status: 400 }
+      );
+    }
+
+    const model = createModel({
+      provider_id,
+      name,
+      model_id,
+      enabled: enabled !== undefined ? enabled : true,
+    });
+
+    return NextResponse.json(model);
+  } catch (error: any) {
+    console.error('Models API error:', error);
+    return NextResponse.json(
+      { error: error.message || 'Internal server error', stack: process.env.NODE_ENV === 'development' ? error.stack : undefined },
+      { status: 500 }
+    );
+  }
+}
+
+export async function PUT(request: NextRequest) {
+  try {
+    getDatabase();
+    const body = await request.json();
+    const { id, name, model_id, enabled, provider_id } = body;
+
+    if (!id) {
+      return NextResponse.json(
+        { error: 'Model ID is required' },
+        { status: 400 }
+      );
+    }
+
+    const updateData: any = {};
+    if (name !== undefined) updateData.name = name;
+    if (model_id !== undefined) updateData.model_id = model_id;
+    if (enabled !== undefined) updateData.enabled = enabled;
+    if (provider_id !== undefined) updateData.provider_id = provider_id;
+
+    const model = updateModel(id, updateData);
+    if (!model) {
+      return NextResponse.json(
+        { error: 'Model not found' },
+        { status: 404 }
+      );
+    }
+
+    return NextResponse.json(model);
+  } catch (error: any) {
+    console.error('Models API error:', error);
+    return NextResponse.json(
+      { error: error.message || 'Internal server error', stack: process.env.NODE_ENV === 'development' ? error.stack : undefined },
+      { status: 500 }
+    );
+  }
+}
+
+export async function DELETE(request: NextRequest) {
+  try {
+    getDatabase();
+    const { searchParams } = new URL(request.url);
+    const id = searchParams.get('id');
+
+    if (!id) {
+      return NextResponse.json(
+        { error: 'Model ID is required' },
+        { status: 400 }
+      );
+    }
+
+    const success = deleteModel(parseInt(id));
+    if (!success) {
+      return NextResponse.json(
+        { error: 'Model not found' },
+        { status: 404 }
+      );
+    }
+
+    return NextResponse.json({ success: true });
+  } catch (error: any) {
+    console.error('Models API error:', error);
+    return NextResponse.json(
+      { error: error.message || 'Internal server error', stack: process.env.NODE_ENV === 'development' ? error.stack : undefined },
+      { status: 500 }
+    );
+  }
+}
+
+// Fetch models from provider
+export async function PATCH(request: NextRequest) {
+  try {
+    getDatabase();
+    const body = await request.json();
+    const { provider_id } = body;
+
+    if (!provider_id) {
+      return NextResponse.json(
+        { error: 'Provider ID is required' },
+        { status: 400 }
+      );
+    }
+
+    const provider = getProviderById(provider_id);
+    if (!provider) {
+      return NextResponse.json(
+        { error: 'Provider not found' },
+        { status: 404 }
+      );
+    }
+
+    console.log('[Models API] Fetching models for provider:', {
+      providerId: provider_id,
+      providerName: provider.name,
+      protocol: provider.protocol,
+      baseUrl: provider.base_url,
+    });
+
+    const adapter = getProviderAdapter(provider.protocol);
+    const models = await adapter.listModels(provider);
+    
+    console.log('[Models API] Fetched models:', models.length);
+
+    // Create or update models
+    const results = [];
+    for (const modelInfo of models) {
+      try {
+        const existing = getAllModels().find(
+          m => m.provider_id === provider_id && m.model_id === modelInfo.id
+        );
+
+        if (existing) {
+          updateModel(existing.id, {
+            name: modelInfo.name,
+            model_id: modelInfo.id,
+          });
+          results.push({ ...existing, name: modelInfo.name });
+        } else {
+          const newModel = createModel({
+            provider_id,
+            name: modelInfo.name,
+            model_id: modelInfo.id,
+            enabled: false, // 默认关闭
+          });
+          results.push(newModel);
+        }
+      } catch (error: any) {
+        console.error(`Failed to create/update model ${modelInfo.id}:`, error);
+      }
+    }
+
+    return NextResponse.json({
+      success: true,
+      models: results,
+      count: results.length,
+    });
+  } catch (error: any) {
+    console.error('Models API error:', error);
+    return NextResponse.json(
+      { error: error.message || 'Internal server error', stack: process.env.NODE_ENV === 'development' ? error.stack : undefined },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/providers/route.ts

@@ -0,0 +1,162 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getDatabase } from '@/db/database';
+import { getAllProviders, getProviderById, createProvider, updateProvider, deleteProvider } from '@/db/queries';
+import { encryptApiKey, decryptApiKey } from '@/server/crypto';
+
+// Ensure Node.js runtime (required for SQLite)
+export const runtime = 'nodejs';
+
+export async function GET(request: NextRequest) {
+  try {
+    getDatabase();
+    const { searchParams } = new URL(request.url);
+    const id = searchParams.get('id');
+    const includeKey = searchParams.get('includeKey') === 'true';
+
+    // If ID is provided, return single provider (for editing)
+    if (id) {
+      const provider = getProviderById(parseInt(id));
+      if (!provider) {
+        return NextResponse.json(
+          { error: 'Provider not found' },
+          { status: 404 }
+        );
+      }
+      // Return with decrypted API key if requested (for editing)
+      return NextResponse.json({
+        ...provider,
+        api_key: includeKey ? decryptApiKey(provider.api_key) : '***',
+      });
+    }
+
+    // Return all providers
+    const providers = getAllProviders();
+    // Don't return API keys in list view
+    const sanitized = providers.map(p => ({
+      ...p,
+      api_key: '***',
+    }));
+    return NextResponse.json(sanitized);
+  } catch (error: any) {
+    console.error('Providers API error:', error);
+    return NextResponse.json(
+      { error: error.message || 'Internal server error', stack: process.env.NODE_ENV === 'development' ? error.stack : undefined },
+      { status: 500 }
+    );
+  }
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    getDatabase();
+    const body = await request.json();
+    const { name, protocol, base_url, api_key } = body;
+
+    if (!name || !protocol || !base_url || !api_key) {
+      return NextResponse.json(
+        { error: 'Missing required fields' },
+        { status: 400 }
+      );
+    }
+
+    const encryptedKey = encryptApiKey(api_key.trim());
+    const provider = createProvider({
+      name,
+      protocol,
+      base_url,
+      api_key: encryptedKey,
+    });
+
+    return NextResponse.json({
+      ...provider,
+      api_key: '***',
+    });
+  } catch (error: any) {
+    console.error('Providers API error:', error);
+    return NextResponse.json(
+      { error: error.message || 'Internal server error', stack: process.env.NODE_ENV === 'development' ? error.stack : undefined },
+      { status: 500 }
+    );
+  }
+}
+
+export async function PUT(request: NextRequest) {
+  try {
+    getDatabase();
+    const body = await request.json();
+    const { id, name, protocol, base_url, api_key } = body;
+
+    if (!id) {
+      return NextResponse.json(
+        { error: 'Provider ID is required' },
+        { status: 400 }
+      );
+    }
+
+    const existingProvider = getProviderById(id);
+    if (!existingProvider) {
+      return NextResponse.json(
+        { error: 'Provider not found' },
+        { status: 404 }
+      );
+    }
+
+    const updateData: any = {};
+    if (name !== undefined) updateData.name = name;
+    if (protocol !== undefined) updateData.protocol = protocol;
+    if (base_url !== undefined) updateData.base_url = base_url;
+    if (api_key !== undefined && api_key !== null && api_key.trim() !== '') {
+      updateData.api_key = encryptApiKey(api_key.trim());
+    }
+
+    const provider = updateProvider(id, updateData);
+    if (!provider) {
+      return NextResponse.json(
+        { error: 'Provider not found' },
+        { status: 404 }
+      );
+    }
+
+    return NextResponse.json({
+      ...provider,
+      api_key: '***',
+    });
+  } catch (error: any) {
+    console.error('Providers API error:', error);
+    return NextResponse.json(
+      { error: error.message || 'Internal server error', stack: process.env.NODE_ENV === 'development' ? error.stack : undefined },
+      { status: 500 }
+    );
+  }
+}
+
+export async function DELETE(request: NextRequest) {
+  try {
+    getDatabase();
+    const { searchParams } = new URL(request.url);
+    const id = searchParams.get('id');
+
+    if (!id) {
+      return NextResponse.json(
+        { error: 'Provider ID is required' },
+        { status: 400 }
+      );
+    }
+
+    const success = deleteProvider(parseInt(id));
+    if (!success) {
+      return NextResponse.json(
+        { error: 'Provider not found' },
+        { status: 404 }
+      );
+    }
+
+    return NextResponse.json({ success: true });
+  } catch (error: any) {
+    console.error('Providers API error:', error);
+    return NextResponse.json(
+      { error: error.message || 'Internal server error', stack: process.env.NODE_ENV === 'development' ? error.stack : undefined },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/providers/test/route.ts

@@ -0,0 +1,182 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getDatabase } from '@/db/database';
+import { getProviderById, getModelById } from '@/db/queries';
+import { getProviderAdapter } from '@/server/providers';
+import type { GatewayRequest } from '@/server/providers/types';
+
+// Ensure Node.js runtime (required for SQLite)
+export const runtime = 'nodejs';
+
+export async function POST(request: NextRequest) {
+  try {
+    getDatabase();
+    const body = await request.json();
+    const { provider_id, model_id } = body;
+
+    if (!provider_id || !model_id) {
+      return NextResponse.json(
+        { error: 'Provider ID and Model ID are required' },
+        { status: 400 }
+      );
+    }
+
+    // Get provider and model
+    const provider = getProviderById(provider_id);
+    if (!provider) {
+      return NextResponse.json(
+        { error: 'Provider not found' },
+        { status: 404 }
+      );
+    }
+
+    const model = getModelById(model_id);
+    if (!model || model.provider_id !== provider_id) {
+      return NextResponse.json(
+        { error: 'Model not found or does not belong to this provider' },
+        { status: 404 }
+      );
+    }
+
+    // Get provider adapter
+    const adapter = getProviderAdapter(provider.protocol);
+
+    // Create a test request based on protocol
+    const testRequest = createTestRequest(provider.protocol, model.model_id);
+
+    // Send test request with timeout
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error('连接超时，请检查网络或稍后重试')), 10000);
+    });
+
+    const testPromise = adapter.forwardRequest(
+      { ...model, provider } as any,
+      testRequest
+    );
+
+    const response = await Promise.race([testPromise, timeoutPromise]) as any;
+
+    // Check response status
+    if (response.status >= 200 && response.status < 300) {
+      return NextResponse.json({
+        success: true,
+        message: '连接成功，模型可用',
+      });
+    } else {
+      // Parse error message
+      let errorMessage = '连接失败';
+      if (response.body?.error?.message) {
+        errorMessage = response.body.error.message;
+      } else if (typeof response.body === 'string') {
+        errorMessage = response.body;
+      }
+
+      // Map common error codes to friendly messages
+      if (response.status === 401 || response.status === 403) {
+        errorMessage = 'API Key 无效，请检查配置';
+      } else if (response.status === 404) {
+        errorMessage = '模型不存在或不可用';
+      } else if (response.status >= 500) {
+        errorMessage = '服务器错误，请稍后重试';
+      }
+
+      return NextResponse.json(
+        {
+          success: false,
+          error: errorMessage,
+          status: response.status,
+        },
+        { status: 200 } // Return 200 so frontend can handle the error
+      );
+    }
+  } catch (error: any) {
+    console.error('Test connection error:', error);
+
+    // Handle specific error types
+    let errorMessage = '连接失败';
+    if (error.message.includes('超时')) {
+      errorMessage = error.message;
+    } else if (error.message.includes('fetch failed') || error.message.includes('ECONNREFUSED')) {
+      errorMessage = '无法连接到服务器，请检查 Base URL 和网络连接';
+    } else if (error.message.includes('ENOTFOUND') || error.message.includes('DNS')) {
+      errorMessage = 'DNS 解析失败，请检查 Base URL';
+    } else {
+      errorMessage = error.message || '连接失败，请检查配置';
+    }
+
+    return NextResponse.json(
+      {
+        success: false,
+        error: errorMessage,
+      },
+      { status: 200 } // Return 200 so frontend can handle the error
+    );
+  }
+}
+
+function createTestRequest(protocol: string, modelId: string): GatewayRequest {
+  switch (protocol) {
+    case 'openai':
+      return {
+        method: 'POST',
+        path: '/v1/chat/completions',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        query: {},
+        body: {
+          model: modelId,
+          messages: [
+            {
+              role: 'user',
+              content: 'test',
+            },
+          ],
+          max_tokens: 5,
+        },
+      };
+
+    case 'anthropic':
+      return {
+        method: 'POST',
+        path: '/v1/messages',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        query: {},
+        body: {
+          model: modelId,
+          max_tokens: 5,
+          messages: [
+            {
+              role: 'user',
+              content: 'test',
+            },
+          ],
+        },
+      };
+
+    case 'gemini':
+      return {
+        method: 'POST',
+        path: `/v1/models/${modelId}:generateContent`,
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        query: {},
+        body: {
+          contents: [
+            {
+              parts: [
+                {
+                  text: 'test',
+                },
+              ],
+            },
+          ],
+        },
+      };
+
+    default:
+      throw new Error(`Unsupported protocol: ${protocol}`);
+  }
+}

package/src/app/api/service/start/route.ts

@@ -0,0 +1,73 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getDatabase } from '@/db/database';
+import { serviceManager } from '@/server/service-manager';
+import { getConfig } from '@/db/queries';
+import net from 'net';
+
+// Ensure Node.js runtime (required for service manager)
+export const runtime = 'nodejs';
+
+export async function POST(request: NextRequest) {
+  try {
+    // Initialize database
+    getDatabase();
+    
+    const body = await request.json().catch(() => ({}));
+    const port = body.port ? parseInt(body.port, 10) : null;
+
+    // Get port from config if not provided
+    let targetPort = port;
+    if (!targetPort) {
+      const portConfig = getConfig('port');
+      targetPort = portConfig ? parseInt(portConfig.value, 10) : 3000;
+    }
+
+    // In development, if port is 3000 (default dev server port), check for conflict
+    const isDev = process.env.NODE_ENV !== 'production';
+    if (isDev && targetPort === 3000) {
+      // Check if port 3000 is in use (likely by the dev server)
+      const testServer = net.createServer();
+      const portInUse = await new Promise<boolean>((resolve) => {
+        testServer.listen(3000, () => {
+          testServer.close(() => resolve(false));
+        });
+        testServer.on('error', () => resolve(true));
+        setTimeout(() => {
+          testServer.close(() => resolve(false));
+        }, 100);
+      });
+
+      if (portInUse) {
+        return NextResponse.json(
+          { 
+            status: 'stopped', 
+            error: 'Port 3000 is already in use by the development server. Please configure a different port (e.g., 3001) in the settings above.' 
+          },
+          { status: 400 }
+        );
+      }
+    }
+
+    // Validate port
+    if (isNaN(targetPort) || targetPort < 1 || targetPort > 65535) {
+      return NextResponse.json(
+        { status: 'stopped', error: 'Invalid port number' },
+        { status: 400 }
+      );
+    }
+
+    const result = await serviceManager.start(targetPort);
+    
+    if (result.error) {
+      return NextResponse.json(result, { status: 400 });
+    }
+
+    return NextResponse.json(result);
+  } catch (error: any) {
+    console.error('Service start API error:', error);
+    return NextResponse.json(
+      { status: 'stopped', error: error.message || 'Failed to start service' },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/service/status/route.ts

@@ -0,0 +1,22 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getDatabase } from '@/db/database';
+import { serviceManager } from '@/server/service-manager';
+
+// Ensure Node.js runtime (required for service manager)
+export const runtime = 'nodejs';
+
+export async function GET(request: NextRequest) {
+  try {
+    // Initialize database
+    getDatabase();
+    
+    const status = await serviceManager.getStatus();
+    return NextResponse.json(status);
+  } catch (error: any) {
+    console.error('Service status API error:', error);
+    return NextResponse.json(
+      { status: 'stopped', error: error.message || 'Failed to get service status' },
+      { status: 500 }
+    );
+  }
+}