ai-agent-router 0.2.0 → 0.2.2

package/src/app/api/ide/openclaw/apply/route.ts

@@ -0,0 +1,103 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { buildMergedConfig } from '../build-config';
+
+const OPENCLAW_DIR = join(homedir(), '.openclaw');
+const OPENCLAW_FILE = join(OPENCLAW_DIR, 'openclaw.json');
+const BACKUP_FILE = join(OPENCLAW_DIR, 'openclaw.json.aar.bak');
+
+function backupOriginalConfig(): { success: boolean; existed: boolean; isFromAar: boolean; error?: string } {
+  try {
+    const existing = existsSync(OPENCLAW_FILE);
+    if (existing) {
+      const original = readFileSync(OPENCLAW_FILE, 'utf-8');
+      let isFromAar = false;
+      try {
+        const parsed = JSON.parse(original);
+        isFromAar = !!(parsed.models?.providers?.['aar-gateway']);
+      } catch {}
+      // 仅在当前配置不是 AAR 时写入备份，这样「还原」才能恢复到应用 AAR 前的状态；若已是 AAR 则保留原有备份不覆盖
+      if (!isFromAar) {
+        writeFileSync(BACKUP_FILE, original, 'utf-8');
+      }
+      return { success: true, existed: true, isFromAar };
+    }
+    return { success: true, existed: false, isFromAar: false };
+  } catch (error: any) {
+    return { success: false, existed: false, isFromAar: false, error: `Backup failed: ${error.message}` };
+  }
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const {
+      default_model: defaultModel,
+      default_fallbacks: defaultFallbacks = [],
+      image_model: imageModel,
+      image_fallbacks: imageFallbacks = [],
+      config: customConfigStr,
+    } = body;
+
+    let existing: Record<string, any> | null = null;
+    if (existsSync(OPENCLAW_FILE)) {
+      try {
+        existing = JSON.parse(readFileSync(OPENCLAW_FILE, 'utf-8'));
+      } catch {
+        existing = null;
+      }
+    }
+
+    let config: Record<string, any>;
+    if (typeof customConfigStr === 'string' && customConfigStr.trim()) {
+      try {
+        config = JSON.parse(customConfigStr);
+        if (!config || typeof config !== 'object') throw new Error('Invalid config object');
+      } catch (e: any) {
+        return NextResponse.json({ error: 'Invalid config JSON: ' + (e.message || 'parse error') }, { status: 400 });
+      }
+    } else {
+      if (!defaultModel) {
+        return NextResponse.json({ error: 'Missing required field: default_model' }, { status: 400 });
+      }
+      config = await buildMergedConfig(
+        {
+          defaultModel,
+          defaultFallbacks,
+          imageModel: imageModel || undefined,
+          imageFallbacks,
+        },
+        existing
+      );
+    }
+
+    const backupResult = backupOriginalConfig();
+    if (!backupResult.success) {
+      return NextResponse.json({ error: backupResult.error }, { status: 500 });
+    }
+
+    if (!existsSync(OPENCLAW_DIR)) {
+      mkdirSync(OPENCLAW_DIR, { recursive: true });
+    }
+
+    const jsonString = JSON.stringify(config, null, 2);
+    writeFileSync(OPENCLAW_FILE, jsonString, 'utf-8');
+
+    const alreadyHadAar = !!(existing?.models?.providers?.['aar-gateway']);
+    return NextResponse.json({
+      success: true,
+      message: alreadyHadAar ? 'OpenClaw 配置已更新为最新网关信息' : 'OpenClaw configuration applied successfully',
+      config,
+      backup: backupResult.existed ? 'Created backup' : 'No existing config to backup',
+      previousWasFromAar: backupResult.existed && backupResult.isFromAar,
+    });
+  } catch (error: any) {
+    console.error('OpenClaw Apply 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/ide/openclaw/available-models/route.ts

@@ -0,0 +1,59 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getAllModels, getProviderById } from '@/db/queries';
+
+type AvailableModel = {
+  id: number;
+  name: string;
+  model_id: string;
+  provider_id: number;
+  provider_name: string;
+  enabled: boolean;
+};
+
+type GroupedModels = { [providerName: string]: AvailableModel[] };
+
+/**
+ * 查询可用模型列表（与 Claude 共用网关，用于 OpenCode 配置）
+ */
+export async function GET(request: NextRequest) {
+  try {
+    const allModels = (await getAllModels()).filter((m: any) => m.enabled);
+
+    if (allModels.length === 0) {
+      return NextResponse.json({
+        models: {},
+        count: 0,
+        message: 'No enabled models found. Please enable some models first.',
+      });
+    }
+
+    const grouped = await allModels.reduce(async (acc: Promise<GroupedModels>, model: any) => {
+      const resolvedAcc = await acc;
+      const provider = await getProviderById(model.provider_id);
+      if (provider) {
+        if (!resolvedAcc[provider.name]) resolvedAcc[provider.name] = [];
+        resolvedAcc[provider.name].push({
+          id: model.id,
+          name: model.name,
+          model_id: model.model_id,
+          provider_id: model.provider_id,
+          provider_name: provider.name,
+          enabled: model.enabled,
+        });
+      }
+      return resolvedAcc;
+    }, Promise.resolve({} as GroupedModels));
+
+    return NextResponse.json({
+      models: grouped,
+      count: allModels.length,
+      providers: Object.keys(grouped),
+    });
+  } catch (error: any) {
+    console.error('OpenCode Available 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/ide/openclaw/build-config.ts

@@ -0,0 +1,152 @@
+import { getDatabase } from '@/db/database';
+import { getConfig } from '@/db/queries';
+import { getAllModels } from '@/db/queries';
+
+export async function getGatewayAddress(): Promise<string> {
+  await getDatabase();
+  const portConfig = await getConfig('port');
+  const port = portConfig?.value || '1357';
+  return `http://localhost:${port}/v1`;
+}
+
+export async function getGatewayApiKey(): Promise<string> {
+  await getDatabase();
+  const apiKeyConfig = await getConfig('api_key');
+  return apiKeyConfig?.value || 'your-gateway-api-key';
+}
+
+/** OpenClaw provider entry structure */
+export type OpenClawProviderEntry = {
+  baseUrl: string;
+  apiKey: string;
+  api: 'openai-completions';
+  models: Array<{
+    id: string;
+    name: string;
+    reasoning?: boolean;
+    input?: string[];
+    cost?: {
+      input: number;
+      output: number;
+      cacheRead: number;
+      cacheWrite: number;
+    };
+    contextWindow?: number;
+    maxTokens?: number;
+  }>;
+};
+
+export async function buildAarGatewayProvider(): Promise<OpenClawProviderEntry> {
+  const gatewayAddress = await getGatewayAddress();
+  const gatewayApiKey = await getGatewayApiKey();
+  const allModels = (await getAllModels()).filter((m: any) => m.enabled);
+
+  const models = allModels.map((m: any) => ({
+    id: m.model_id,
+    name: m.name,
+    reasoning: m.reasoning || false,
+    input: m.input || ['text'],
+    cost: m.cost || { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: m.context_window || 200000,
+    maxTokens: m.max_tokens || 8192,
+  }));
+
+  return {
+    baseUrl: gatewayAddress,
+    apiKey: gatewayApiKey,
+    api: 'openai-completions',
+    models,
+  };
+}
+
+const AAR_PROVIDER_ID = 'aar-gateway';
+
+/** Merge existing OpenClaw config with AAR gateway */
+export function mergeConfigWithAar(
+  existing: Record<string, any> | null,
+  config: {
+    defaultModel: string;
+    defaultFallbacks?: string[];
+    imageModel?: string;
+    imageFallbacks?: string[];
+  },
+  aarProvider: OpenClawProviderEntry
+): Record<string, any> {
+  const base = existing && typeof existing === 'object' ? { ...existing } : {};
+
+  // Update models.providers
+  const modelsConfig = base.models || {};
+  const providers = modelsConfig.providers || {};
+  providers[AAR_PROVIDER_ID] = aarProvider;
+  modelsConfig.providers = providers;
+  modelsConfig.mode = 'merge';
+  base.models = modelsConfig;
+
+  // Update agents.defaults.model
+  const agents = base.agents || {};
+  const defaults = agents.defaults || {};
+  const model = defaults.model || {};
+
+  // Format: provider/model
+  const fullModelId = `${AAR_PROVIDER_ID}/${config.defaultModel}`;
+  const fullImageModelId = config.imageModel
+    ? `${AAR_PROVIDER_ID}/${config.imageModel}`
+    : undefined;
+
+  model.primary = fullModelId;
+  if (config.defaultFallbacks && config.defaultFallbacks.length > 0) {
+    model.fallbacks = config.defaultFallbacks.map((m: string) =>
+      m.startsWith(`${AAR_PROVIDER_ID}/`) ? m : `${AAR_PROVIDER_ID}/${m}`
+    );
+  } else {
+    delete model.fallbacks;
+  }
+
+  defaults.model = model;
+
+  // Update agents.defaults.imageModel
+  const imageModel = defaults.imageModel || {};
+  if (fullImageModelId) {
+    imageModel.primary = fullImageModelId;
+  }
+  if (config.imageFallbacks && config.imageFallbacks.length > 0) {
+    imageModel.fallbacks = config.imageFallbacks.map((m: string) =>
+      m.startsWith(`${AAR_PROVIDER_ID}/`) ? m : `${AAR_PROVIDER_ID}/${m}`
+    );
+  } else {
+    delete imageModel.fallbacks;
+  }
+  defaults.imageModel = imageModel;
+
+  // Update agents.defaults.models so OpenClaw can resolve aar-gateway model ids (alias, etc.)
+  const modelsMap = defaults.models || {};
+  for (const m of aarProvider.models) {
+    const fullId = `${AAR_PROVIDER_ID}/${m.id}`;
+    modelsMap[fullId] = modelsMap[fullId] || { alias: m.name };
+  }
+  defaults.models = modelsMap;
+
+  agents.defaults = defaults;
+  base.agents = agents;
+
+  // Ensure channels exists (even if empty)
+  if (!base.channels) {
+    base.channels = {};
+  }
+
+  return base;
+}
+
+/** Generate merged config for preview or apply */
+export async function buildMergedConfig(
+  config: {
+    defaultModel: string;
+    defaultFallbacks?: string[];
+    imageModel?: string;
+    imageFallbacks?: string[];
+  },
+  existing: Record<string, any> | null
+): Promise<Record<string, any>> {
+  const aarProvider = await buildAarGatewayProvider();
+  return mergeConfigWithAar(existing, config, aarProvider);
+}

package/src/app/api/ide/openclaw/preview/route.ts

@@ -0,0 +1,57 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { buildMergedConfig } from '../build-config';
+
+const OPENCLAW_FILE = join(homedir(), '.openclaw', 'openclaw.json');
+
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const defaultModel = searchParams.get('default_model') || '';
+    const defaultFallbacksStr = searchParams.get('default_fallbacks') || '';
+    const imageModel = searchParams.get('image_model') || '';
+    const imageFallbacksStr = searchParams.get('image_fallbacks') || '';
+
+    if (!defaultModel) {
+      return NextResponse.json({ error: 'Missing query: default_model' }, { status: 400 });
+    }
+
+    // Parse fallback arrays
+    const defaultFallbacks = defaultFallbacksStr
+      ? defaultFallbacksStr.split(',').filter(Boolean)
+      : [];
+    const imageFallbacks = imageFallbacksStr
+      ? imageFallbacksStr.split(',').filter(Boolean)
+      : [];
+
+    let existingConfig = null;
+    if (existsSync(OPENCLAW_FILE)) {
+      try {
+        const content = readFileSync(OPENCLAW_FILE, 'utf-8');
+        existingConfig = JSON.parse(content);
+      } catch (e) {
+        // If file exists but is invalid, treat as empty
+      }
+    }
+
+    const config = await buildMergedConfig(
+      {
+        defaultModel,
+        defaultFallbacks,
+        imageModel: imageModel || undefined,
+        imageFallbacks,
+      },
+      existingConfig
+    );
+
+    return NextResponse.json({ config });
+  } catch (error: any) {
+    console.error('OpenClaw Preview 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/ide/openclaw/restore/route.ts

@@ -0,0 +1,27 @@
+import { NextResponse } from 'next/server';
+import { existsSync, copyFileSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const OPENCLAW_DIR = join(homedir(), '.openclaw');
+const OPENCLAW_FILE = join(OPENCLAW_DIR, 'openclaw.json');
+const BACKUP_FILE = join(OPENCLAW_DIR, 'openclaw.json.aar.bak');
+
+export async function POST() {
+  try {
+    if (!existsSync(BACKUP_FILE)) {
+      return NextResponse.json({ error: 'No backup file found' }, { status: 404 });
+    }
+
+    copyFileSync(BACKUP_FILE, OPENCLAW_FILE);
+    unlinkSync(BACKUP_FILE);
+
+    return NextResponse.json({ success: true, message: 'Configuration restored' });
+  } catch (error: any) {
+    console.error('OpenClaw Restore 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/ide/openclaw/save/route.ts

@@ -0,0 +1,67 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { buildMergedConfig } from '../build-config';
+
+const AAR_DIR = join(homedir(), '.aar');
+const TEMP_OPENCLAW_FILE = join(AAR_DIR, 'openclaw.tmp.json');
+const OPENCLAW_FILE = join(homedir(), '.openclaw', 'openclaw.json');
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const {
+      default_model: defaultModel,
+      default_fallbacks: defaultFallbacks = [],
+      image_model: imageModel,
+      image_fallbacks: imageFallbacks = [],
+    } = body;
+
+    if (!existsSync(AAR_DIR)) {
+      mkdirSync(AAR_DIR, { recursive: true });
+    }
+
+    let existing: Record<string, any> | null = null;
+    if (existsSync(OPENCLAW_FILE)) {
+      try {
+        existing = JSON.parse(readFileSync(OPENCLAW_FILE, 'utf-8'));
+      } catch {
+        existing = null;
+      }
+    }
+
+    // Build the merged config
+    const mergedConfig = await buildMergedConfig(
+      {
+        defaultModel,
+        defaultFallbacks,
+        imageModel,
+        imageFallbacks,
+      },
+      existing
+    );
+
+    // Save to temp file
+    const tempData = {
+      defaultModel,
+      defaultFallbacks,
+      imageModel,
+      imageFallbacks,
+      updatedAt: new Date().toISOString(),
+    };
+    writeFileSync(TEMP_OPENCLAW_FILE, JSON.stringify(tempData, null, 2), 'utf-8');
+
+    return NextResponse.json({
+      success: true,
+      saveType: 'temp',
+      message: 'Configuration saved temporarily'
+    });
+  } catch (error: any) {
+    console.error('OpenClaw Save 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/ide/openclaw/status/route.ts

@@ -0,0 +1,178 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { existsSync, readFileSync, statSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { getDatabase } from '@/db/database';
+import { getConfig } from '@/db/queries';
+
+const OPENCLAW_DIR = join(homedir(), '.openclaw');
+const OPENCLAW_FILE = join(OPENCLAW_DIR, 'openclaw.json');
+const BACKUP_FILE = join(OPENCLAW_DIR, 'openclaw.json.aar.bak');
+const AAR_DIR = join(homedir(), '.aar');
+const TEMP_OPENCLAW_FILE = join(AAR_DIR, 'openclaw.tmp.json');
+
+type OpenClawStatus = {
+  applied: boolean;
+  defaultModel?: string;
+  defaultFallbacks?: string[];
+  imageModel?: string;
+  imageFallbacks?: string[];
+  gatewayAddress?: string;
+  apiKey?: string;
+  lastUpdated?: string | null;
+  backupExists: boolean;
+  matchCurrentGateway?: boolean;
+  routerProvider?: string;
+  tempDefaultModel?: string;
+  tempDefaultFallbacks?: string[];
+  tempImageModel?: string;
+  tempImageFallbacks?: string[];
+  providerName?: string;
+  modelsCount?: number;
+  /** 当前磁盘上 openclaw.json 的完整内容，用于「生效中」展示 */
+  config?: Record<string, unknown> | null;
+};
+
+function maskApiKey(apiKey: string): string {
+  if (!apiKey || apiKey === 'your-gateway-api-key') return apiKey;
+  if (apiKey.length <= 8) return apiKey.slice(0, 2) + '***' + apiKey.slice(-2);
+  return apiKey.slice(0, 4) + '****' + apiKey.slice(-4);
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    const fileExists = existsSync(OPENCLAW_FILE);
+    const backupExists = existsSync(BACKUP_FILE);
+
+    await getDatabase();
+    const gatewayApiKeyConfig = await getConfig('api_key');
+    const portConfig = await getConfig('port');
+    const gatewayApiKey = gatewayApiKeyConfig?.value || 'your-gateway-api-key';
+    const gatewayAddress = `http://localhost:${portConfig?.value || '1357'}/v1`;
+
+    // Read temp config if exists
+    let tempConfig: any = {};
+    if (existsSync(TEMP_OPENCLAW_FILE)) {
+      try {
+        tempConfig = JSON.parse(readFileSync(TEMP_OPENCLAW_FILE, 'utf-8'));
+      } catch {}
+    }
+
+    if (!fileExists) {
+      return NextResponse.json({
+        applied: false,
+        defaultModel: tempConfig.defaultModel,
+        defaultFallbacks: tempConfig.defaultFallbacks || [],
+        imageModel: tempConfig.imageModel,
+        imageFallbacks: tempConfig.imageFallbacks || [],
+        gatewayAddress,
+        apiKey: maskApiKey(gatewayApiKey),
+        backupExists: false,
+        lastUpdated: undefined,
+        matchCurrentGateway: false,
+        routerProvider: undefined,
+        tempDefaultModel: tempConfig.defaultModel,
+        tempDefaultFallbacks: tempConfig.defaultFallbacks || [],
+        tempImageModel: tempConfig.imageModel,
+        tempImageFallbacks: tempConfig.imageFallbacks || [],
+      } as OpenClawStatus);
+    }
+
+    const content = readFileSync(OPENCLAW_FILE, 'utf-8');
+    let config: any;
+    try {
+      config = JSON.parse(content);
+    } catch {
+      return NextResponse.json({ error: 'Invalid openclaw.json format' }, { status: 500 });
+    }
+
+    const modelsConfig = config.models || {};
+    const providers = modelsConfig.providers || {};
+    const aarProvider = providers['aar-gateway'];
+
+    const appliedBaseUrl = aarProvider?.baseUrl;
+    const appliedApiKey = aarProvider?.apiKey;
+    const matchCurrentGateway = appliedBaseUrl === gatewayAddress && appliedApiKey === gatewayApiKey;
+
+    // Extract current config values
+    let defaultModel: string | undefined;
+    let defaultFallbacks: string[] | undefined;
+    let imageModel: string | undefined;
+    let imageFallbacks: string[] | undefined;
+
+    const primaryModel = config.agents?.defaults?.model?.primary;
+    if (typeof primaryModel === 'string' && primaryModel.startsWith('aar-gateway/')) {
+      defaultModel = primaryModel.slice('aar-gateway/'.length);
+    }
+
+    const fallbackModels = config.agents?.defaults?.model?.fallbacks;
+    if (Array.isArray(fallbackModels)) {
+      defaultFallbacks = fallbackModels.map((m: string) =>
+        m.startsWith('aar-gateway/') ? m.slice('aar-gateway/'.length) : m
+      );
+    }
+
+    const primaryImageModel = config.agents?.defaults?.imageModel?.primary;
+    if (typeof primaryImageModel === 'string' && primaryImageModel.startsWith('aar-gateway/')) {
+      imageModel = primaryImageModel.slice('aar-gateway/'.length);
+    }
+
+    const fallbackImageModels = config.agents?.defaults?.imageModel?.fallbacks;
+    if (Array.isArray(fallbackImageModels)) {
+      imageFallbacks = fallbackImageModels.map((m: string) =>
+        m.startsWith('aar-gateway/') ? m.slice('aar-gateway/'.length) : m
+      );
+    }
+
+    // OpenClaw models is an array
+    const modelsCount = Array.isArray(aarProvider?.models) ? aarProvider.models.length : 0;
+
+    // Use temp config if not matching current gateway
+    const finalDefaultModel = !matchCurrentGateway && tempConfig.defaultModel
+      ? tempConfig.defaultModel
+      : defaultModel;
+    const finalDefaultFallbacks = !matchCurrentGateway && tempConfig.defaultFallbacks
+      ? tempConfig.defaultFallbacks
+      : defaultFallbacks;
+    const finalImageModel = !matchCurrentGateway && tempConfig.imageModel
+      ? tempConfig.imageModel
+      : imageModel;
+    const finalImageFallbacks = !matchCurrentGateway && tempConfig.imageFallbacks
+      ? tempConfig.imageFallbacks
+      : imageFallbacks;
+
+    let lastUpdated: string | null = null;
+    try {
+      lastUpdated = new Date(statSync(OPENCLAW_FILE).mtime).toISOString();
+    } catch {}
+
+    const status: OpenClawStatus = {
+      applied: !!aarProvider,
+      defaultModel: finalDefaultModel,
+      defaultFallbacks: finalDefaultFallbacks,
+      imageModel: finalImageModel,
+      imageFallbacks: finalImageFallbacks,
+      gatewayAddress: appliedBaseUrl,
+      apiKey: maskApiKey(appliedApiKey || gatewayApiKey),
+      backupExists,
+      lastUpdated,
+      matchCurrentGateway,
+      routerProvider: aarProvider ? 'aar' : undefined,
+      tempDefaultModel: tempConfig.defaultModel,
+      tempDefaultFallbacks: tempConfig.defaultFallbacks || [],
+      tempImageModel: tempConfig.imageModel,
+      tempImageFallbacks: tempConfig.imageFallbacks || [],
+      providerName: 'AAR Model Router',
+      modelsCount,
+      config,
+    };
+
+    return NextResponse.json(status);
+  } catch (error: any) {
+    console.error('OpenClaw Status API error:', error);
+    return NextResponse.json(
+      { error: error.message || 'Internal server error', stack: process.env.NODE_ENV === 'development' ? error.stack : undefined },
+      { status: 500 }
+    );
+  }
+}