ai-agent-router 0.1.0

package/dist/.next/types/app/layout.js

@@ -0,0 +1,22 @@
+// File: /Users/pluckypan/own/AI/ai-agent-router/src/app/layout.tsx
+import * as entry from '../../../src/app/layout.js';
+// Check that the entry is a valid entry
+checkFields();
+// Check the prop type of the entry function
+checkFields();
+// Check the arguments and return type of the generateMetadata function
+if ('generateMetadata' in entry) {
+    checkFields();
+    checkFields();
+}
+// Check the arguments and return type of the generateViewport function
+if ('generateViewport' in entry) {
+    checkFields();
+    checkFields();
+}
+// Check the arguments and return type of the generateStaticParams function
+if ('generateStaticParams' in entry) {
+    checkFields();
+    checkFields();
+}
+function checkFields() { }

package/dist/.next/types/app/logs/page.js

@@ -0,0 +1,22 @@
+// File: /Users/pluckypan/own/AI/ai-agent-router/src/app/logs/page.tsx
+import * as entry from '../../../../src/app/logs/page.js';
+// Check that the entry is a valid entry
+checkFields();
+// Check the prop type of the entry function
+checkFields();
+// Check the arguments and return type of the generateMetadata function
+if ('generateMetadata' in entry) {
+    checkFields();
+    checkFields();
+}
+// Check the arguments and return type of the generateViewport function
+if ('generateViewport' in entry) {
+    checkFields();
+    checkFields();
+}
+// Check the arguments and return type of the generateStaticParams function
+if ('generateStaticParams' in entry) {
+    checkFields();
+    checkFields();
+}
+function checkFields() { }

package/dist/.next/types/app/models/page.js

@@ -0,0 +1,22 @@
+// File: /Users/pluckypan/own/AI/ai-agent-router/src/app/models/page.tsx
+import * as entry from '../../../../src/app/models/page.js';
+// Check that the entry is a valid entry
+checkFields();
+// Check the prop type of the entry function
+checkFields();
+// Check the arguments and return type of the generateMetadata function
+if ('generateMetadata' in entry) {
+    checkFields();
+    checkFields();
+}
+// Check the arguments and return type of the generateViewport function
+if ('generateViewport' in entry) {
+    checkFields();
+    checkFields();
+}
+// Check the arguments and return type of the generateStaticParams function
+if ('generateStaticParams' in entry) {
+    checkFields();
+    checkFields();
+}
+function checkFields() { }

package/dist/.next/types/app/page.js

@@ -0,0 +1,22 @@
+// File: /Users/pluckypan/own/AI/ai-agent-router/src/app/page.tsx
+import * as entry from '../../../src/app/page.js';
+// Check that the entry is a valid entry
+checkFields();
+// Check the prop type of the entry function
+checkFields();
+// Check the arguments and return type of the generateMetadata function
+if ('generateMetadata' in entry) {
+    checkFields();
+    checkFields();
+}
+// Check the arguments and return type of the generateViewport function
+if ('generateViewport' in entry) {
+    checkFields();
+    checkFields();
+}
+// Check the arguments and return type of the generateStaticParams function
+if ('generateStaticParams' in entry) {
+    checkFields();
+    checkFields();
+}
+function checkFields() { }

package/dist/.next/types/app/providers/page.js

@@ -0,0 +1,22 @@
+// File: /Users/pluckypan/own/AI/ai-agent-router/src/app/providers/page.tsx
+import * as entry from '../../../../src/app/providers/page.js';
+// Check that the entry is a valid entry
+checkFields();
+// Check the prop type of the entry function
+checkFields();
+// Check the arguments and return type of the generateMetadata function
+if ('generateMetadata' in entry) {
+    checkFields();
+    checkFields();
+}
+// Check the arguments and return type of the generateViewport function
+if ('generateViewport' in entry) {
+    checkFields();
+    checkFields();
+}
+// Check the arguments and return type of the generateStaticParams function
+if ('generateStaticParams' in entry) {
+    checkFields();
+    checkFields();
+}
+function checkFields() { }

package/dist/src/app/api/config/route.js

@@ -0,0 +1,43 @@
+import { NextResponse } from 'next/server';
+import { getDatabase } from '@/db/database';
+import { getConfig, setConfig, getAllConfig } from '@/db/queries';
+// Ensure Node.js runtime (required for SQLite)
+export const runtime = 'nodejs';
+export async function GET(request) {
+    try {
+        // Initialize database on request (safer than module load)
+        getDatabase();
+        const { searchParams } = new URL(request.url);
+        const key = searchParams.get('key');
+        if (key) {
+            const config = getConfig(key);
+            if (!config) {
+                return NextResponse.json({ error: 'Config not found' }, { status: 404 });
+            }
+            return NextResponse.json(config);
+        }
+        const configs = getAllConfig();
+        return NextResponse.json(configs);
+    }
+    catch (error) {
+        console.error('Config 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) {
+    try {
+        // Initialize database on request
+        getDatabase();
+        const body = await request.json();
+        const { key, value } = body;
+        if (!key || value === undefined) {
+            return NextResponse.json({ error: 'Key and value are required' }, { status: 400 });
+        }
+        const config = setConfig(key, typeof value === 'string' ? value : JSON.stringify(value));
+        return NextResponse.json(config);
+    }
+    catch (error) {
+        console.error('Config POST API error:', error);
+        return NextResponse.json({ error: error.message || 'Internal server error', stack: process.env.NODE_ENV === 'development' ? error.stack : undefined }, { status: 500 });
+    }
+}

package/dist/src/app/api/gateway/[...path]/route.js

@@ -0,0 +1,83 @@
+import { NextResponse } from 'next/server';
+import { getDatabase } from '@/db/database';
+import { handleGatewayRequest } from '@/server/gateway';
+// Ensure Node.js runtime (required for SQLite)
+export const runtime = 'nodejs';
+export async function POST(request, { params }) {
+    return handleRequest(request, params, 'POST');
+}
+export async function GET(request, { params }) {
+    return handleRequest(request, params, 'GET');
+}
+export async function PUT(request, { params }) {
+    return handleRequest(request, params, 'PUT');
+}
+export async function PATCH(request, { params }) {
+    return handleRequest(request, params, 'PATCH');
+}
+export async function DELETE(request, { params }) {
+    return handleRequest(request, params, 'DELETE');
+}
+async function handleRequest(request, params, method) {
+    try {
+        getDatabase();
+        // Extract model ID from path or query
+        // Common patterns: /v1/models/{model_id}/... or ?model=...
+        const path = params.path.join('/');
+        const searchParams = request.nextUrl.searchParams;
+        // Try to get model from query or path
+        let modelId = searchParams.get('model') || searchParams.get('model_id');
+        // If not in query, try to extract from path (e.g., /v1/models/gpt-4/completions)
+        if (!modelId) {
+            const pathParts = path.split('/');
+            const modelsIndex = pathParts.indexOf('models');
+            if (modelsIndex >= 0 && pathParts[modelsIndex + 1]) {
+                modelId = pathParts[modelsIndex + 1];
+            }
+        }
+        // If still no model, try to get from body
+        if (!modelId) {
+            try {
+                const body = await request.json();
+                modelId = body.model || body.model_id;
+            }
+            catch {
+                // Body might not be JSON or might be empty
+            }
+        }
+        if (!modelId) {
+            return NextResponse.json({ error: { message: 'Model ID not specified' } }, { status: 400 });
+        }
+        // Get request body
+        let body = null;
+        try {
+            if (method !== 'GET' && method !== 'HEAD') {
+                const text = await request.text();
+                if (text) {
+                    body = JSON.parse(text);
+                }
+            }
+        }
+        catch {
+            // Body might not be JSON
+        }
+        // Build gateway request
+        const gatewayRequest = {
+            method,
+            path: '/' + path,
+            headers: Object.fromEntries(request.headers.entries()),
+            query: Object.fromEntries(searchParams.entries()),
+            body,
+        };
+        // Handle the request
+        const response = await handleGatewayRequest(modelId, gatewayRequest);
+        // Return response
+        return NextResponse.json(response.body, {
+            status: response.status,
+            headers: response.headers,
+        });
+    }
+    catch (error) {
+        return NextResponse.json({ error: { message: error.message || 'Internal server error' } }, { status: 500 });
+    }
+}

package/dist/src/app/api/gateway/route.js

@@ -0,0 +1,63 @@
+import { NextResponse } from 'next/server';
+import { getDatabase } from '@/db/database';
+import { handleGatewayRequest } from '@/server/gateway';
+// Ensure Node.js runtime (required for SQLite)
+export const runtime = 'nodejs';
+// Handle requests to /api/gateway (root gateway endpoint)
+export async function POST(request) {
+    return handleGatewayRequestDirect(request, 'POST');
+}
+export async function GET(request) {
+    return handleGatewayRequestDirect(request, 'GET');
+}
+async function handleGatewayRequestDirect(request, method) {
+    try {
+        getDatabase();
+        const searchParams = request.nextUrl.searchParams;
+        let modelId = searchParams.get('model') || searchParams.get('model_id');
+        // Try to get from body
+        if (!modelId) {
+            try {
+                const body = await request.json();
+                modelId = body.model || body.model_id;
+            }
+            catch {
+                // Body might not be JSON
+            }
+        }
+        if (!modelId) {
+            return NextResponse.json({ error: { message: 'Model ID not specified' } }, { status: 400 });
+        }
+        // Get request body
+        let body = null;
+        try {
+            if (method !== 'GET' && method !== 'HEAD') {
+                const text = await request.text();
+                if (text) {
+                    body = JSON.parse(text);
+                }
+            }
+        }
+        catch {
+            // Body might not be JSON
+        }
+        // Build gateway request
+        const gatewayRequest = {
+            method,
+            path: '/',
+            headers: Object.fromEntries(request.headers.entries()),
+            query: Object.fromEntries(searchParams.entries()),
+            body,
+        };
+        // Handle the request
+        const response = await handleGatewayRequest(modelId, gatewayRequest);
+        // Return response
+        return NextResponse.json(response.body, {
+            status: response.status,
+            headers: response.headers,
+        });
+    }
+    catch (error) {
+        return NextResponse.json({ error: { message: error.message || 'Internal server error' } }, { status: 500 });
+    }
+}

package/dist/src/app/api/logs/route.js

@@ -0,0 +1,34 @@
+import { 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) {
+    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) {
+        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/dist/src/app/api/models/route.js

@@ -0,0 +1,152 @@
+import { 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) {
+    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) {
+        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) {
+    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) {
+        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) {
+    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 = {};
+        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) {
+        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) {
+    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) {
+        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) {
+    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) {
+                console.error(`Failed to create/update model ${modelInfo.id}:`, error);
+            }
+        }
+        return NextResponse.json({
+            success: true,
+            models: results,
+            count: results.length,
+        });
+    }
+    catch (error) {
+        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/dist/src/app/api/providers/route.js

@@ -0,0 +1,118 @@
+import { 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) {
+    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) {
+        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) {
+    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) {
+        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) {
+    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 = {};
+        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) {
+        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) {
+    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) {
+        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 });
+    }
+}