openclaw-agent-builder 1.0.0

package/server/routes/agentChat.js

@@ -0,0 +1,168 @@
+import { Router } from 'express';
+import { existsSync, readFileSync } from 'fs';
+import { execSync, spawn } from 'child_process';
+import path from 'path';
+import os from 'os';
+
+const router = Router();
+
+function expandHome(p) {
+  return p.startsWith('~') ? path.join(os.homedir(), p.slice(1)) : p;
+}
+
+function readOpenClawConfig() {
+  try {
+    return JSON.parse(readFileSync(path.join(os.homedir(), '.openclaw', 'openclaw.json'), 'utf8'));
+  } catch { return {}; }
+}
+
+function resolveAgentWorkspace(agentId) {
+  const cfg = readOpenClawConfig();
+  const existing = (cfg.agents?.list || []).find(a => a.id === agentId);
+  if (existing?.workspace) return expandHome(existing.workspace);
+  if (existing) return expandHome(cfg.agents?.defaults?.workspace || '~/.openclaw/workspace');
+  return expandHome(`~/.openclaw/workspace-${agentId}`);
+}
+
+function readWsFile(workspace, filename) {
+  const p = path.join(workspace, filename);
+  return existsSync(p) ? readFileSync(p, 'utf8').trim() : null;
+}
+
+function buildSystemPrompt(agentId, workspace) {
+  const soul     = readWsFile(workspace, 'SOUL.md');
+  const agents   = readWsFile(workspace, 'AGENTS.md');
+  const user     = readWsFile(workspace, 'USER.md');
+  const identity = readWsFile(workspace, 'IDENTITY.md');
+  const tools    = readWsFile(workspace, 'TOOLS.md');
+  const memory   = readWsFile(workspace, 'MEMORY.md');
+
+  const parts = [];
+  if (soul)     parts.push(soul);
+  if (identity) parts.push(`---\n${identity}`);
+  if (agents)   parts.push(`---\n${agents}`);
+  if (user)     parts.push(`---\n${user}`);
+  if (tools)    parts.push(`---\n${tools}`);
+  if (memory)   parts.push(`---\n## Long-term memory\n${memory}`);
+
+  parts.push(`---
+## Preview mode
+You are running in builder preview mode. You do not have access to external tools (web, files, shell) in this preview — respond based on your personality and knowledge only. Mention this briefly if asked about tools or actions. When the OpenClaw gateway is running, you will have full capabilities.`);
+
+  return parts.join('\n\n');
+}
+
+async function callAnthropic({ apiKey, model, messages, system }) {
+  const res = await fetch('https://api.anthropic.com/v1/messages', {
+    method: 'POST',
+    headers: {
+      'x-api-key': apiKey,
+      'anthropic-version': '2023-06-01',
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify({ model, max_tokens: 1024, system, messages }),
+  });
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error?.message || `Anthropic error ${res.status}`);
+  return data.content[0]?.text || '';
+}
+
+async function callOpenAI({ apiKey, model, messages, system }) {
+  const res = await fetch('https://api.openai.com/v1/chat/completions', {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${apiKey}`, 'content-type': 'application/json' },
+    body: JSON.stringify({
+      model,
+      messages: [{ role: 'system', content: system }, ...messages],
+    }),
+  });
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error?.message || `OpenAI error ${res.status}`);
+  return data.choices[0]?.message?.content || '';
+}
+
+// POST /api/agent-chat/:agentId
+router.post('/agent-chat/:agentId', async (req, res) => {
+  const { agentId } = req.params;
+  const { messages, apiKey: clientApiKey, provider = 'anthropic', model } = req.body;
+
+  const workspace = resolveAgentWorkspace(agentId);
+  const system = buildSystemPrompt(agentId, workspace);
+
+  const actualProvider = provider === 'openclaw' ? 'anthropic' : provider;
+  let apiKey = clientApiKey;
+  if (!apiKey) {
+    if (actualProvider === 'anthropic') apiKey = process.env.ANTHROPIC_API_KEY;
+    else if (actualProvider === 'openai') apiKey = process.env.OPENAI_API_KEY;
+  }
+  if (!apiKey) return res.status(400).json({ error: 'No API key available' });
+
+  try {
+    let content;
+    if (actualProvider === 'openai') {
+      content = await callOpenAI({ apiKey, model: model || 'gpt-4o', messages, system });
+    } else {
+      content = await callAnthropic({ apiKey, model: model || 'claude-sonnet-4-6', messages, system });
+    }
+    res.json({ content });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// POST /api/gateway/restart — restart the OpenClaw gateway via SSE stream
+router.post('/gateway/restart', (req, res) => {
+  res.setHeader('Content-Type', 'text/event-stream');
+  res.setHeader('Cache-Control', 'no-cache');
+  res.setHeader('Connection', 'keep-alive');
+
+  function send(type, data) {
+    res.write(`data: ${JSON.stringify({ type, data })}\n\n`);
+  }
+
+  const home = os.homedir();
+  const env = {
+    ...process.env,
+    PATH: [
+      '/usr/local/bin', '/opt/homebrew/bin',
+      process.env.NVM_BIN,
+      `${home}/.npm-global/bin`,
+      `${home}/.volta/bin`,
+      process.env.PATH || '',
+    ].filter(Boolean).join(':'),
+  };
+
+  send('log', 'Restarting OpenClaw gateway...\n');
+
+  const proc = spawn('openclaw', ['restart'], { shell: true, env });
+  proc.stdout.on('data', d => send('log', d.toString()));
+  proc.stderr.on('data', d => send('log', d.toString()));
+
+  proc.on('error', () => {
+    // Fallback: launchctl on macOS
+    send('log', 'Trying launchctl...\n');
+    try {
+      const uid = execSync('id -u', { shell: true }).toString().trim();
+      const out = execSync(
+        `launchctl kickstart -k gui/${uid}/com.openclaw.gateway`,
+        { shell: true, env, timeout: 10000 }
+      ).toString();
+      send('log', out);
+      send('done', 'Gateway restarted');
+    } catch (e) {
+      send('error', 'Could not restart automatically. Run: openclaw restart');
+    }
+    res.end();
+  });
+
+  proc.on('close', code => {
+    if (code === 0) {
+      send('done', 'Gateway restarted — your new agent is live');
+    } else {
+      send('error', `Exited with code ${code}. Try running: openclaw restart`);
+    }
+    res.end();
+  });
+});
+
+export default router;

package/server/routes/capabilities.js

@@ -0,0 +1,195 @@
+import { Router } from 'express';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const router = Router();
+const CONFIG_PATH = path.join(os.homedir(), '.openclaw', 'openclaw.json');
+
+function readConfig() {
+  try { return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8')); } catch { return {}; }
+}
+
+function writeConfig(cfg) {
+  fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true });
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2), 'utf8');
+}
+
+// GET /api/capabilities — return current capabilities state from openclaw.json
+router.get('/capabilities', (_req, res) => {
+  const cfg = readConfig();
+
+  const memoryPlugin = cfg.plugins?.slots?.memory || null;
+  const lancedb = cfg.plugins?.entries?.['memory-lancedb'] || {};
+  const memoryCore = cfg.plugins?.entries?.['memory-core'] || {};
+
+  const webSearch = cfg.tools?.web?.search || {};
+  const webFetch = cfg.tools?.web?.fetch || {};
+  const browser = cfg.browser || {};
+  const haSkill = cfg.skills?.entries?.homeassistant || {};
+  const goPlaces = cfg.skills?.entries?.goplaces || {};
+
+  res.json({
+    memory: {
+      mode: memoryPlugin === 'memory-lancedb' ? 'lancedb'
+           : memoryPlugin === 'memory-core'   ? 'core'
+           : 'none',
+      lancedb: {
+        autoRecall:  lancedb.config?.autoRecall  ?? true,
+        autoCapture: lancedb.config?.autoCapture ?? false,
+        embeddingApiKey: lancedb.config?.embedding?.apiKey || '',
+        embeddingModel:  lancedb.config?.embedding?.model  || 'text-embedding-3-small',
+      },
+    },
+    webSearch: {
+      enabled:  !!webSearch.provider,
+      provider: webSearch.provider || 'brave',
+      braveApiKey:      webSearch.apiKey || '',
+      perplexityApiKey: webSearch.perplexity?.apiKey || '',
+    },
+    webFetch: {
+      enabled: webFetch.enabled !== false && !!cfg.browser?.enabled,
+    },
+    homeAssistant: {
+      enabled: !!haSkill.env?.HA_TOKEN,
+      token: haSkill.env?.HA_TOKEN || '',
+      url:   haSkill.env?.HA_URL   || 'http://homeassistant.local:8123',
+    },
+    googlePlaces: {
+      enabled: !!goPlaces.apiKey,
+      apiKey: goPlaces.apiKey || '',
+    },
+  });
+});
+
+// POST /api/capabilities — write capabilities to openclaw.json
+router.post('/capabilities', (req, res) => {
+  try {
+    const { memory, webSearch, webFetch, homeAssistant, googlePlaces } = req.body;
+    const cfg = readConfig();
+
+    // Backup
+    if (fs.existsSync(CONFIG_PATH)) {
+      const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+      fs.copyFileSync(CONFIG_PATH, `${CONFIG_PATH}.bak-${ts}`);
+    }
+
+    // ── Memory ──────────────────────────────────────────────────────────────
+    if (memory) {
+      if (!cfg.plugins) cfg.plugins = {};
+      if (!cfg.plugins.entries) cfg.plugins.entries = {};
+
+      if (memory.mode === 'lancedb') {
+        cfg.plugins.slots = { ...(cfg.plugins.slots || {}), memory: 'memory-lancedb' };
+        cfg.plugins.entries['memory-lancedb'] = {
+          enabled: true,
+          config: {
+            autoRecall:  memory.lancedb?.autoRecall  ?? true,
+            autoCapture: memory.lancedb?.autoCapture ?? false,
+            embedding: {
+              apiKey: memory.lancedb?.embeddingApiKey || '',
+              model:  memory.lancedb?.embeddingModel  || 'text-embedding-3-small',
+            },
+          },
+        };
+        if (cfg.plugins.entries['memory-core']) {
+          cfg.plugins.entries['memory-core'].enabled = false;
+        }
+      } else if (memory.mode === 'core') {
+        cfg.plugins.slots = { ...(cfg.plugins.slots || {}), memory: 'memory-core' };
+        cfg.plugins.entries['memory-core'] = { enabled: true };
+        if (cfg.plugins.entries['memory-lancedb']) {
+          cfg.plugins.entries['memory-lancedb'].enabled = false;
+        }
+      } else {
+        // none — disable all memory plugins
+        delete cfg.plugins?.slots?.memory;
+        if (cfg.plugins.entries['memory-lancedb']) cfg.plugins.entries['memory-lancedb'].enabled = false;
+        if (cfg.plugins.entries['memory-core'])    cfg.plugins.entries['memory-core'].enabled    = false;
+      }
+    }
+
+    // ── Web Search ──────────────────────────────────────────────────────────
+    if (!cfg.tools) cfg.tools = {};
+    if (!cfg.tools.web) cfg.tools.web = {};
+
+    if (webSearch) {
+      if (!webSearch.enabled) {
+        delete cfg.tools.web.search;
+      } else if (webSearch.provider === 'brave') {
+        cfg.tools.web.search = {
+          ...(cfg.tools.web.search || {}),
+          provider: 'brave',
+          apiKey: webSearch.braveApiKey || '',
+        };
+      } else if (webSearch.provider === 'perplexity') {
+        cfg.tools.web.search = {
+          ...(cfg.tools.web.search || {}),
+          provider: 'perplexity',
+          perplexity: {
+            apiKey:   webSearch.perplexityApiKey || '',
+            baseUrl:  'https://openrouter.ai/api/v1',
+            model:    'perplexity/sonar-pro',
+          },
+        };
+      }
+    }
+
+    // ── Web Fetch / Browser ─────────────────────────────────────────────────
+    if (webFetch !== undefined) {
+      cfg.tools.web.fetch = { enabled: !!webFetch?.enabled };
+      cfg.browser = { enabled: !!webFetch?.enabled, headless: true };
+    }
+
+    // ── Home Assistant ──────────────────────────────────────────────────────
+    if (homeAssistant) {
+      if (!cfg.skills) cfg.skills = {};
+      if (!cfg.skills.entries) cfg.skills.entries = {};
+      if (!homeAssistant.enabled) {
+        delete cfg.skills.entries.homeassistant;
+      } else {
+        cfg.skills.entries.homeassistant = {
+          env: {
+            HA_TOKEN: homeAssistant.token || '',
+            HA_URL:   homeAssistant.url   || 'http://homeassistant.local:8123',
+          },
+        };
+      }
+    }
+
+    // ── Google Places ───────────────────────────────────────────────────────
+    if (googlePlaces) {
+      if (!cfg.skills) cfg.skills = {};
+      if (!cfg.skills.entries) cfg.skills.entries = {};
+      if (!googlePlaces.enabled) {
+        delete cfg.skills.entries.goplaces;
+      } else {
+        cfg.skills.entries.goplaces = { apiKey: googlePlaces.apiKey || '' };
+      }
+    }
+
+    // ── Per-agent tool deny ─────────────────────────────────────────────────
+    const { agentToolDeny } = req.body;
+    if (agentToolDeny && typeof agentToolDeny === 'object') {
+      if (!cfg.agents) cfg.agents = {};
+      if (!cfg.agents.list) cfg.agents.list = [];
+      for (const [agentId, denied] of Object.entries(agentToolDeny)) {
+        if (!Array.isArray(denied) || denied.length === 0) continue;
+        const idx = cfg.agents.list.findIndex(a => a.id === agentId);
+        if (idx >= 0) {
+          cfg.agents.list[idx].tools = {
+            ...(cfg.agents.list[idx].tools || {}),
+            deny: denied,
+          };
+        }
+      }
+    }
+
+    writeConfig(cfg);
+    res.json({ ok: true });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+export default router;

package/server/routes/channel.js

@@ -0,0 +1,161 @@
+import { Router } from 'express';
+import { readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const router = Router();
+const CONFIG_PATH = join(homedir(), '.openclaw', 'openclaw.json');
+
+function readConfig() {
+  try { return JSON.parse(readFileSync(CONFIG_PATH, 'utf8')); }
+  catch { return {}; }
+}
+
+function writeConfig(cfg) {
+  const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  writeFileSync(`${CONFIG_PATH}.bak-${ts}`, JSON.stringify(readConfig(), null, 2));
+  writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2));
+}
+
+// Return existing agents (for the agent-comms picker)
+router.get('/channel/agents', (req, res) => {
+  try {
+    const cfg = readConfig();
+    const agents = (cfg.agents?.list || [])
+      .filter(a => a.id)
+      .map(a => ({
+        id: a.id,
+        name: a.identity?.name || a.name || a.id,
+        emoji: a.identity?.emoji || '🤖',
+      }));
+    res.json({ agents });
+  } catch {
+    res.json({ agents: [] });
+  }
+});
+
+// Return whether telegram is already configured
+router.get('/channel/telegram-status', (req, res) => {
+  try {
+    const cfg = readConfig();
+    const tg = cfg.channels?.telegram;
+    res.json({
+      configured: !!(tg?.botToken),
+      allowFrom: tg?.allowFrom || [],
+    });
+  } catch {
+    res.json({ configured: false, allowFrom: [] });
+  }
+});
+
+// Write channel config for a new agent
+router.post('/channel/setup', (req, res) => {
+  const { channel, agentId, agentName, discord, telegram, agentComms = [] } = req.body;
+  if (!agentId) return res.status(400).json({ error: 'agentId required' });
+
+  try {
+    const cfg = readConfig();
+    cfg.agents = cfg.agents || {};
+    cfg.agents.list = cfg.agents.list || [];
+    cfg.bindings = cfg.bindings || [];
+    cfg.channels = cfg.channels || {};
+    cfg.tools = cfg.tools || {};
+
+    // ── Discord ──────────────────────────────────────────────────────────────
+    if (channel === 'discord' && discord?.token) {
+      cfg.channels.discord = cfg.channels.discord || { enabled: true, accounts: {} };
+      cfg.channels.discord.accounts = cfg.channels.discord.accounts || {};
+
+      const guilds = {};
+      if (discord.guildId) {
+        guilds[discord.guildId] = {
+          requireMention: discord.requireMention ?? false,
+          channels: discord.channelId ? { [discord.channelId]: {} } : {},
+        };
+      }
+
+      cfg.channels.discord.accounts[agentId] = {
+        token: discord.token,
+        allowBots: false,
+        groupPolicy: 'allowlist',
+        streaming: 'partial',
+        dmPolicy: 'pairing',
+        allowFrom: discord.allowFrom || [],
+        guilds,
+        activity: agentName || agentId,
+        status: 'online',
+        activityType: 4,
+      };
+
+      // Remove any existing bindings for this agent then prepend fresh ones
+      cfg.bindings = cfg.bindings.filter(b => b.agentId !== agentId);
+
+      if (discord.channelId && discord.guildId) {
+        cfg.bindings.unshift({
+          agentId,
+          match: {
+            channel: 'discord',
+            accountId: agentId,
+            peer: { kind: 'channel', id: discord.channelId },
+          },
+        });
+      }
+      cfg.bindings.unshift({
+        agentId,
+        match: { channel: 'discord', accountId: agentId },
+      });
+    }
+
+    // ── Telegram ─────────────────────────────────────────────────────────────
+    if (channel === 'telegram') {
+      cfg.channels.telegram = cfg.channels.telegram || {};
+      cfg.channels.telegram.enabled = true;
+      if (telegram?.token) cfg.channels.telegram.botToken = telegram.token;
+      if (telegram?.allowFrom?.length) {
+        const existing = cfg.channels.telegram.allowFrom || [];
+        cfg.channels.telegram.allowFrom = [...new Set([...existing, ...telegram.allowFrom])];
+      }
+    }
+
+    // ── Add / update agent entry in agents.list ───────────────────────────────
+    const existingIdx = cfg.agents.list.findIndex(a => a.id === agentId);
+    const agentEntry = {
+      id: agentId,
+      name: agentId,
+      workspace: join(homedir(), `.openclaw/workspace-${agentId}`),
+      identity: { name: agentName || agentId },
+      subagents: { allowAgents: agentComms },
+    };
+
+    if (existingIdx >= 0) {
+      cfg.agents.list[existingIdx] = { ...cfg.agents.list[existingIdx], ...agentEntry };
+    } else {
+      cfg.agents.list.push(agentEntry);
+    }
+
+    // ── tools.agentToAgent ────────────────────────────────────────────────────
+    cfg.tools.agentToAgent = cfg.tools.agentToAgent || { enabled: true, allow: [] };
+    if (!cfg.tools.agentToAgent.allow.includes(agentId)) {
+      cfg.tools.agentToAgent.allow.push(agentId);
+    }
+
+    // ── Update existing agents so they can talk back ──────────────────────────
+    for (const peerId of agentComms) {
+      const peer = cfg.agents.list.find(a => a.id === peerId);
+      if (peer) {
+        peer.subagents = peer.subagents || {};
+        peer.subagents.allowAgents = peer.subagents.allowAgents || [];
+        if (!peer.subagents.allowAgents.includes(agentId)) {
+          peer.subagents.allowAgents.push(agentId);
+        }
+      }
+    }
+
+    writeConfig(cfg);
+    res.json({ ok: true });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+export default router;

package/server/routes/chat.js

@@ -0,0 +1,150 @@
+import { Router } from 'express';
+
+const router = Router();
+
+const ANTHROPIC_MODELS = ['claude-sonnet-4-6', 'claude-opus-4-6', 'claude-haiku-4-5'];
+const OPENAI_MODELS = ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo'];
+
+function detectProvider(model) {
+  if (!model) return null;
+  const m = model.toLowerCase();
+  if (m.includes('claude')) return 'anthropic';
+  if (m.includes('gpt') || m.includes('o1') || m.includes('o3')) return 'openai';
+  if (m.includes('anthropic/')) return 'anthropic';
+  if (m.includes('openai')) return 'openai';
+  return null;
+}
+
+function normalizeModel(model) {
+  // Strip provider prefix: "anthropic/claude-sonnet-4-6" → "claude-sonnet-4-6"
+  if (model && model.includes('/')) {
+    return model.split('/').pop();
+  }
+  return model;
+}
+
+async function callAnthropic({ apiKey, model, messages, system, maxTokens = 1024 }) {
+  const body = {
+    model: normalizeModel(model),
+    max_tokens: maxTokens,
+    messages,
+  };
+  if (system) body.system = system;
+
+  const res = await fetch('https://api.anthropic.com/v1/messages', {
+    method: 'POST',
+    headers: {
+      'x-api-key': apiKey,
+      'anthropic-version': '2023-06-01',
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify(body),
+  });
+
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error?.message || `Anthropic error ${res.status}`);
+  return data.content?.[0]?.text || '';
+}
+
+async function callOpenAI({ apiKey, model, messages, system, maxTokens = 1024 }) {
+  const openaiMessages = system
+    ? [{ role: 'system', content: system }, ...messages]
+    : messages;
+
+  const res = await fetch('https://api.openai.com/v1/chat/completions', {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${apiKey}`,
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify({
+      model: normalizeModel(model),
+      max_tokens: maxTokens,
+      messages: openaiMessages,
+    }),
+  });
+
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error?.message || `OpenAI error ${res.status}`);
+  return data.choices?.[0]?.message?.content || '';
+}
+
+router.post('/chat', async (req, res) => {
+  const { messages, apiKey: clientApiKey, model, provider: explicitProvider, system } = req.body;
+
+  if (!messages || !model) {
+    return res.status(400).json({ error: 'messages and model are required' });
+  }
+
+  const provider = explicitProvider || detectProvider(model);
+  if (!provider) {
+    return res.status(400).json({ error: `Cannot detect provider for model: ${model}` });
+  }
+
+  // Resolve API key: use client-supplied key, or fall back to environment variables
+  const actualProvider = provider === 'openclaw' ? 'anthropic' : provider;
+  let apiKey = clientApiKey;
+  if (!apiKey) {
+    if (actualProvider === 'anthropic') apiKey = process.env.ANTHROPIC_API_KEY;
+    else if (actualProvider === 'openai') apiKey = process.env.OPENAI_API_KEY;
+  }
+
+  if (!apiKey) {
+    return res.status(400).json({ error: 'No API key available. Set ANTHROPIC_API_KEY in your environment, or enter a key manually.' });
+  }
+
+  try {
+    let content;
+    if (actualProvider === 'anthropic') {
+      content = await callAnthropic({ apiKey, model, messages, system });
+    } else if (actualProvider === 'openai') {
+      content = await callOpenAI({ apiKey, model, messages, system });
+    } else {
+      return res.status(400).json({ error: `Unsupported provider: ${actualProvider}` });
+    }
+    res.json({ content });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Check whether the server has credentials available for "OpenClaw default" mode
+router.get('/chat/openclaw-status', async (req, res) => {
+  try {
+    const { readFileSync } = await import('fs');
+    const { join } = await import('path');
+    const { homedir } = await import('os');
+
+    const anthropicKey = process.env.ANTHROPIC_API_KEY;
+    const openaiKey = process.env.OPENAI_API_KEY;
+
+    // Always use a capable model for the builder — env key availability determines provider
+    let model = null;
+    let provider = null;
+    if (anthropicKey) { model = 'claude-sonnet-4-6'; provider = 'anthropic'; }
+    else if (openaiKey) { model = 'gpt-4o'; provider = 'openai'; }
+
+    const available = !!(model && provider);
+    res.json({ available, provider, model, normalized: model ? normalizeModel(model) : null });
+  } catch {
+    res.json({ available: false, provider: null, model: null, normalized: null });
+  }
+});
+
+// Legacy endpoint kept for compatibility
+router.get('/chat/default-model', async (req, res) => {
+  try {
+    const { readFileSync } = await import('fs');
+    const { join } = await import('path');
+    const { homedir } = await import('os');
+    const configPath = join(homedir(), '.openclaw', 'openclaw.json');
+    const cfg = JSON.parse(readFileSync(configPath, 'utf8'));
+    const primary = cfg?.agents?.defaults?.model?.primary || null;
+    const provider = primary ? detectProvider(primary) : null;
+    res.json({ model: primary, provider, normalized: primary ? normalizeModel(primary) : null });
+  } catch {
+    res.json({ model: null, provider: null, normalized: null });
+  }
+});
+
+export default router;