@swarmclawai/swarmclaw 0.9.9 → 1.0.2

package/bin/worker-cmd.js

@@ -1,11 +1,17 @@
 #!/usr/bin/env node
 'use strict'
 
-const fs = require('node:fs')
-const path = require('node:path')
-const os = require('node:os')
 const { spawn } = require('node:child_process')
 
+const {
+  BROWSER_PROFILES_DIR,
+  DATA_DIR,
+  PKG_ROOT,
+  SWARMCLAW_HOME,
+  WORKSPACE_DIR,
+  findStandaloneServer,
+} = require('./server-cmd.js')
+
 function printHelp() {
   const help = `
 Usage: swarmclaw worker [options]
@@ -19,8 +25,7 @@ Options:
   console.log(help)
 }
 
-function main() {
-  const args = process.argv.slice(3)
+function main(args = process.argv.slice(3)) {
   for (const arg of args) {
     if (arg === '-h' || arg === '--help') {
       printHelp()
@@ -32,27 +37,28 @@ function main() {
     }
   }
 
-  const SWARMCLAW_HOME = process.env.SWARMCLAW_HOME || path.join(os.homedir(), '.swarmclaw')
-  const DATA_DIR = path.join(SWARMCLAW_HOME, 'data')
-
+  process.env.SWARMCLAW_HOME = SWARMCLAW_HOME
   process.env.DATA_DIR = DATA_DIR
+  process.env.WORKSPACE_DIR = WORKSPACE_DIR
+  process.env.BROWSER_PROFILES_DIR = BROWSER_PROFILES_DIR
   process.env.SWARMCLAW_DAEMON_BACKGROUND_SERVICES = '1'
-  // Flag that tells Next.js NOT to start the HTTP/Websocket listener, just boot the daemon.
   process.env.SWARMCLAW_WORKER_ONLY = '1'
 
-  console.log(`[swarmclaw] Starting dedicated background worker...`)
+  console.log('[swarmclaw] Starting dedicated background worker...')
+  console.log(`[swarmclaw] Package root: ${PKG_ROOT}`)
+  console.log(`[swarmclaw] Home: ${SWARMCLAW_HOME}`)
   console.log(`[swarmclaw] Data directory: ${DATA_DIR}`)
+  console.log(`[swarmclaw] Workspace directory: ${WORKSPACE_DIR}`)
+  console.log(`[swarmclaw] Browser profiles: ${BROWSER_PROFILES_DIR}`)
 
-  // We reuse the built server.js but signal it to only run the daemon
-  const standaloneBase = path.join(SWARMCLAW_HOME, '.next', 'standalone')
-  let serverJs = path.join(standaloneBase, 'server.js')
-  
-  if (!fs.existsSync(serverJs)) {
-     console.error('Standalone server.js not found. Try running: swarmclaw server --build')
-     process.exit(1)
+  const serverJs = findStandaloneServer()
+  if (!serverJs) {
+    console.error('[swarmclaw] Standalone server.js not found in the installed package. Try running: swarmclaw server --build')
+    process.exit(1)
   }
 
   const child = spawn(process.execPath, [serverJs], {
+    cwd: PKG_ROOT,
     env: process.env,
     stdio: 'inherit',
   })

package/next.config.ts

@@ -1,5 +1,6 @@
 import type { NextConfig } from "next";
 import { execSync } from "child_process";
+import { existsSync } from "fs";
 import { networkInterfaces } from "os";
 import path from "path";
 import { fileURLToPath } from "url";
@@ -8,6 +9,7 @@ const PROJECT_ROOT = path.dirname(fileURLToPath(import.meta.url))
 
 function getGitSha(): string {
   try {
+    if (!existsSync(path.join(PROJECT_ROOT, '.git'))) return 'unknown'
     return execSync('git rev-parse --short HEAD', { encoding: 'utf-8' }).trim()
   } catch {
     return 'unknown'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@swarmclawai/swarmclaw",
-  "version": "0.9.9",
-  "description": "Self-hosted AI agent orchestration dashboard — manage LLM providers, orchestrate agent swarms, schedule tasks, and bridge agents to chat platforms.",
+  "version": "1.0.2",
+  "description": "Self-hosted AI agent orchestration dashboard with OpenClaw integration, multi-provider support, LangGraph workflows, and chat platform connectors.",
   "license": "MIT",
   "publishConfig": {
     "access": "public",
@@ -51,8 +51,8 @@
     "dev": "next dev --turbopack --hostname 0.0.0.0 -p 3456",
     "dev:webpack": "next dev --webpack --hostname 0.0.0.0 -p 3456",
     "dev:clean": "rm -rf .next && next dev --turbopack --hostname 0.0.0.0 -p 3456",
-    "build": "next build",
-    "build:ci": "NEXT_DISABLE_ESLINT=1 next build",
+    "build": "next build --webpack",
+    "build:ci": "NEXT_DISABLE_ESLINT=1 next build --webpack",
     "start": "node .next/standalone/server.js",
     "start:standalone": "node .next/standalone/server.js",
     "smoke:browser": "node ./scripts/browser-route-smoke.mjs",
@@ -66,9 +66,10 @@
     "lint:baseline:update": "node ./scripts/lint-baseline.mjs update",
     "cli": "node ./bin/swarmclaw.js",
     "test:cli": "node --test src/cli/*.test.js bin/*.test.js",
-    "test:setup": "tsx --test src/app/api/setup/check-provider/route.test.ts src/lib/server/provider-model-discovery.test.ts src/components/auth/setup-wizard/utils.test.ts src/components/auth/setup-wizard/types.test.ts src/hooks/setup-done-detection.test.ts",
-    "test:openclaw": "tsx --test src/lib/openclaw/openclaw-agent-id.test.ts src/lib/openclaw/openclaw-endpoint.test.ts src/lib/server/agents/agent-runtime-config.test.ts src/lib/server/build-llm.test.ts src/lib/server/connectors/connector-routing.test.ts src/lib/server/connectors/openclaw.test.ts src/lib/server/gateway/protocol.test.ts src/lib/server/llm-response-cache.test.ts src/lib/server/mcp-conformance.test.ts src/lib/server/openclaw/agent-resolver.test.ts src/lib/server/openclaw/deploy.test.ts src/lib/server/openclaw/skills-normalize.test.ts src/lib/server/session-tools/openclaw-nodes.test.ts src/lib/server/tasks/task-quality-gate.test.ts src/lib/server/tasks/task-validation.test.ts src/lib/server/tool-capability-policy.test.ts",
+    "test:setup": "tsx --test src/app/api/setup/check-provider/route.test.ts src/lib/server/provider-model-discovery.test.ts src/components/auth/setup-wizard/utils.test.ts src/components/auth/setup-wizard/types.test.ts src/hooks/setup-done-detection.test.ts src/lib/setup-defaults.test.ts",
+    "test:openclaw": "tsx --test src/lib/openclaw/openclaw-agent-id.test.ts src/lib/openclaw/openclaw-endpoint.test.ts src/lib/server/agents/agent-runtime-config.test.ts src/lib/server/build-llm.test.ts src/lib/server/connectors/connector-routing.test.ts src/lib/server/connectors/openclaw.test.ts src/lib/server/gateway/protocol.test.ts src/lib/server/llm-response-cache.test.ts src/lib/server/mcp-conformance.test.ts src/lib/server/openclaw/agent-resolver.test.ts src/lib/server/openclaw/deploy.test.ts src/lib/server/openclaw/skills-normalize.test.ts src/lib/server/session-tools/openclaw-nodes.test.ts src/lib/server/tasks/task-quality-gate.test.ts src/lib/server/tasks/task-validation.test.ts src/lib/server/tool-capability-policy.test.ts src/lib/providers/openclaw-exports.test.ts src/app/api/openclaw/dashboard-url/route.test.ts",
     "test:mcp:conformance": "node --import tsx ./scripts/mcp-conformance-check.ts",
+    "prepack": "npm run build:ci",
     "postinstall": "node ./scripts/postinstall.mjs"
   },
   "dependencies": {
@@ -76,6 +77,7 @@
     "@langchain/anthropic": "^1.3.18",
     "@langchain/core": "^1.1.31",
     "@modelcontextprotocol/sdk": "^1.27.1",
+    "@tailwindcss/postcss": "^4",
     "@langchain/langgraph": "^1.2.2",
     "@langchain/openai": "^1.2.8",
     "@multiavatar/multiavatar": "^1.0.7",
@@ -116,14 +118,16 @@
     "rehype-highlight": "^7.0.2",
     "remark-gfm": "^4.0.1",
     "remove-markdown": "^0.6.3",
+    "shadcn": "^3.8.5",
     "sonner": "^2.0.7",
+    "tailwindcss": "^4",
     "tailwind-merge": "^3.4.1",
+    "tw-animate-css": "^1.4.0",
     "ws": "^8.19.0",
     "zod": "^4.3.6",
     "zustand": "^5.0.11"
   },
   "devDependencies": {
-    "@tailwindcss/postcss": "^4",
     "@types/better-sqlite3": "^7.6.13",
     "@types/mailparser": "^3.4.6",
     "@types/node": "^20",
@@ -134,10 +138,7 @@
     "@types/ws": "^8.18.1",
     "eslint": "^9",
     "eslint-config-next": "16.1.6",
-    "shadcn": "^3.8.5",
-    "tailwindcss": "^4",
     "tsx": "^4.20.6",
-    "tw-animate-css": "^1.4.0",
     "typescript": "^5"
   },
   "optionalDependencies": {

package/src/app/api/gateways/[id]/health/route.ts

@@ -1,39 +1,9 @@
 import { NextResponse } from 'next/server'
-import { probeOpenClawHealth } from '@/lib/server/openclaw/health'
-import { loadGatewayProfiles, saveGatewayProfiles } from '@/lib/server/storage'
+import { probeOpenClawHealth, persistGatewayHealthResult } from '@/lib/server/openclaw/health'
+import { loadGatewayProfiles } from '@/lib/server/storage'
 import { notFound } from '@/lib/server/collection-helpers'
-import { notify } from '@/lib/server/ws-hub'
-import type { GatewayProfile } from '@/types'
-import type { OpenClawHealthResult } from '@/lib/server/openclaw/health'
 export const dynamic = 'force-dynamic'
 
-export function persistGatewayHealthResult(
-  id: string,
-  result: OpenClawHealthResult,
-  now = Date.now(),
-): GatewayProfile | null {
-  const gateways = loadGatewayProfiles()
-  const gateway = gateways[id]
-  if (!gateway) return null
-
-  gateway.status = result.ok ? 'healthy' : (result.authProvided ? 'degraded' : 'offline')
-  gateway.lastCheckedAt = now
-  gateway.lastError = result.ok ? null : (result.error || result.hint || 'Gateway health check failed.')
-  gateway.lastModelCount = Array.isArray(result.models) ? result.models.length : 0
-  gateway.deployment = {
-    ...(gateway.deployment || {}),
-    lastVerifiedAt: now,
-    lastVerifiedOk: result.ok,
-    lastVerifiedMessage: result.ok
-      ? result.message
-      : (result.error || result.hint || 'Gateway health check failed.'),
-  }
-  gateway.updatedAt = now
-  saveGatewayProfiles(gateways)
-  notify('gateways')
-  return gateway
-}
-
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const gateways = loadGatewayProfiles()

package/src/app/api/gateways/health-route.test.ts

@@ -1,7 +1,7 @@
 import assert from 'node:assert/strict'
 import { afterEach, test } from 'node:test'
 
-import { persistGatewayHealthResult } from './[id]/health/route'
+import { persistGatewayHealthResult } from '@/lib/server/openclaw/health'
 import { loadGatewayProfiles, saveGatewayProfiles } from '@/lib/server/storage'
 
 const originalGateways = loadGatewayProfiles()

package/src/app/api/openclaw/dashboard-url/route.test.ts

@@ -0,0 +1,166 @@
+import assert from 'node:assert/strict'
+import { afterEach, test } from 'node:test'
+
+import type { Agent } from '@/types'
+import {
+  encryptKey,
+  loadAgents,
+  loadCredentials,
+  loadGatewayProfiles,
+  saveAgents,
+  saveCredentials,
+  saveGatewayProfiles,
+} from '@/lib/server/storage'
+import type { GatewayProfile } from '@/types'
+
+const originalAgents = loadAgents({ includeTrashed: true })
+const originalCredentials = loadCredentials()
+const originalGateways = loadGatewayProfiles()
+
+afterEach(() => {
+  saveAgents(originalAgents)
+  saveCredentials(originalCredentials)
+  saveGatewayProfiles(originalGateways)
+})
+
+// ---------------------------------------------------------------------------
+// Helper: call the route handler directly
+// ---------------------------------------------------------------------------
+
+async function callDashboardUrl(agentId: string): Promise<{ status: number; body: Record<string, unknown> }> {
+  const { GET } = await import('./route')
+  const req = new Request(`http://localhost:3456/api/openclaw/dashboard-url?agentId=${agentId}`)
+  const res = await GET(req)
+  return { status: res.status, body: await res.json() as Record<string, unknown> }
+}
+
+function createAgent(id: string, overrides: Partial<Agent> = {}): void {
+  const agents = loadAgents({ includeTrashed: true })
+  agents[id] = {
+    id,
+    name: `Agent ${id}`,
+    systemPrompt: '',
+    provider: 'openclaw',
+    model: '',
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    ...overrides,
+  } as Agent
+  saveAgents(agents)
+}
+
+function createCredential(id: string, token: string): void {
+  const creds = loadCredentials()
+  creds[id] = {
+    id,
+    provider: 'openclaw',
+    name: `Cred ${id}`,
+    encryptedKey: encryptKey(token),
+    createdAt: Date.now(),
+  }
+  saveCredentials(creds)
+}
+
+function createGateway(id: string, overrides: Partial<GatewayProfile> = {}): void {
+  const gateways = loadGatewayProfiles()
+  gateways[id] = {
+    id,
+    name: `Gateway ${id}`,
+    provider: 'openclaw',
+    endpoint: 'http://10.0.0.5:18789',
+    status: 'healthy',
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    ...overrides,
+  } as GatewayProfile
+  saveGatewayProfiles(gateways)
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+test('dashboard-url returns 400 for missing agentId', async () => {
+  const { GET } = await import('./route')
+  const req = new Request('http://localhost:3456/api/openclaw/dashboard-url')
+  const res = await GET(req)
+  assert.equal(res.status, 400)
+})
+
+test('dashboard-url returns 404 for unknown agent', async () => {
+  const { status } = await callDashboardUrl('nonexistent')
+  assert.equal(status, 404)
+})
+
+test('dashboard-url returns 400 for non-OpenClaw agent', async () => {
+  createAgent('oai-agent', { provider: 'openai' as Agent['provider'] })
+  const { status } = await callDashboardUrl('oai-agent')
+  assert.equal(status, 400)
+})
+
+test('dashboard-url returns base URL when no credential', async () => {
+  createAgent('oc-no-cred', { apiEndpoint: 'http://192.168.1.10:18789' })
+  const { status, body } = await callDashboardUrl('oc-no-cred')
+  assert.equal(status, 200)
+  assert.equal(body.url, 'http://192.168.1.10:18789')
+})
+
+test('dashboard-url includes token from agent credential', async () => {
+  createCredential('cred-tok-1', 'my-gateway-token')
+  createAgent('oc-with-cred', {
+    apiEndpoint: 'http://localhost:18789',
+    credentialId: 'cred-tok-1',
+  })
+  const { status, body } = await callDashboardUrl('oc-with-cred')
+  assert.equal(status, 200)
+  assert.equal(body.url, 'http://localhost:18789?token=my-gateway-token')
+})
+
+test('dashboard-url uses gateway profile endpoint and credential', async () => {
+  createCredential('gw-cred-1', 'gw-token-1')
+  createGateway('gw-prof-1', {
+    endpoint: 'http://10.0.0.5:19000',
+    credentialId: 'gw-cred-1',
+  })
+  createAgent('oc-with-gw', {
+    apiEndpoint: 'http://localhost:18789',
+    gatewayProfileId: 'gw-prof-1',
+  })
+  const { status, body } = await callDashboardUrl('oc-with-gw')
+  assert.equal(status, 200)
+  // Should use gateway profile endpoint, not agent's apiEndpoint
+  assert.ok(typeof body.url === 'string')
+  assert.ok((body.url as string).startsWith('http://10.0.0.5:19000'))
+  assert.ok((body.url as string).includes('token=gw-token-1'))
+})
+
+test('dashboard-url defaults to localhost when no endpoint', async () => {
+  createAgent('oc-no-ep', { apiEndpoint: undefined })
+  const { status, body } = await callDashboardUrl('oc-no-ep')
+  assert.equal(status, 200)
+  assert.equal(body.url, 'http://localhost:18789')
+})
+
+test('dashboard-url strips path from endpoint', async () => {
+  createAgent('oc-with-path', { apiEndpoint: 'http://localhost:18789/v1' })
+  const { status, body } = await callDashboardUrl('oc-with-path')
+  assert.equal(status, 200)
+  assert.equal(body.url, 'http://localhost:18789')
+})
+
+test('dashboard-url URL-encodes special characters in token', async () => {
+  createCredential('cred-special', 'tok/with spaces&chars=yes')
+  createAgent('oc-special-tok', {
+    apiEndpoint: 'http://localhost:18789',
+    credentialId: 'cred-special',
+  })
+  const { status, body } = await callDashboardUrl('oc-special-tok')
+  assert.equal(status, 200)
+  const url = body.url as string
+  assert.ok(url.includes('token='))
+  // Token should be URL-encoded
+  assert.ok(!url.includes(' '), 'spaces should be encoded')
+  // Decode and verify the token
+  const parsed = new URL(url)
+  assert.equal(parsed.searchParams.get('token'), 'tok/with spaces&chars=yes')
+})

package/src/app/api/openclaw/dashboard-url/route.ts

@@ -0,0 +1,68 @@
+import { NextResponse } from 'next/server'
+import { loadAgents, loadGatewayProfiles, loadCredentials, decryptKey } from '@/lib/server/storage'
+
+/** GET ?agentId=X — resolve the tokenized dashboard URL for an OpenClaw agent's gateway */
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url)
+  const agentId = searchParams.get('agentId')
+  if (!agentId) {
+    return NextResponse.json({ error: 'Missing agentId' }, { status: 400 })
+  }
+
+  const agents = loadAgents()
+  const agent = agents[agentId]
+  if (!agent) {
+    return NextResponse.json({ error: 'Agent not found' }, { status: 404 })
+  }
+  if (agent.provider !== 'openclaw') {
+    return NextResponse.json({ error: 'Not an OpenClaw agent' }, { status: 400 })
+  }
+
+  // Resolve the gateway endpoint
+  let endpoint = agent.apiEndpoint || ''
+  let credentialId = agent.credentialId || null
+
+  // If agent has a gatewayProfileId, prefer its endpoint and credential
+  if (agent.gatewayProfileId) {
+    const gateways = loadGatewayProfiles()
+    const gw = gateways[agent.gatewayProfileId]
+    if (gw) {
+      endpoint = gw.endpoint || endpoint
+      credentialId = gw.credentialId || credentialId
+    }
+  }
+
+  if (!endpoint) endpoint = 'http://localhost:18789'
+
+  // Build the base dashboard URL (strip path, use http)
+  let dashboardUrl: string
+  try {
+    const parsed = new URL(/^(https?|wss?):\/\//i.test(endpoint) ? endpoint : `http://${endpoint}`)
+    if (parsed.protocol === 'wss:') parsed.protocol = 'https:'
+    if (parsed.protocol === 'ws:') parsed.protocol = 'http:'
+    parsed.pathname = ''
+    parsed.search = ''
+    parsed.hash = ''
+    dashboardUrl = parsed.toString().replace(/\/+$/, '')
+  } catch {
+    dashboardUrl = 'http://localhost:18789'
+  }
+
+  // Decrypt the token if we have a credential
+  if (credentialId) {
+    try {
+      const creds = loadCredentials()
+      const cred = creds[credentialId]
+      if (cred?.encryptedKey) {
+        const token = decryptKey(cred.encryptedKey)
+        if (token) {
+          dashboardUrl = `${dashboardUrl}?token=${encodeURIComponent(token)}`
+        }
+      }
+    } catch {
+      // If decryption fails, return the URL without token
+    }
+  }
+
+  return NextResponse.json({ url: dashboardUrl })
+}

package/src/app/api/setup/check-provider/helpers.ts

@@ -0,0 +1,28 @@
+export function normalizeOllamaSetupEndpoint(endpoint: string, useCloud: boolean): string {
+  const normalized = endpoint.replace(/\/+$/, '')
+  if (useCloud) return normalized
+  return normalized.replace(/\/v1$/i, '')
+}
+
+export async function parseErrorMessage(res: Response, fallback: string): Promise<string> {
+  const text = await res.text().catch(() => '')
+  if (!text) return fallback
+  try {
+    const parsed = JSON.parse(text)
+    if (typeof parsed?.error?.message === 'string' && parsed.error.message.trim()) return parsed.error.message.trim()
+    if (typeof parsed?.error === 'string' && parsed.error.trim()) return parsed.error.trim()
+    if (typeof parsed?.message === 'string' && parsed.message.trim()) return parsed.message.trim()
+    if (typeof parsed?.detail === 'string' && parsed.detail.trim()) return parsed.detail.trim()
+  } catch {
+    // Non-JSON response body.
+  }
+  return text.slice(0, 300).trim() || fallback
+}
+
+export function normalizeOpenClawUrl(raw: string): { httpUrl: string; wsUrl: string } {
+  let url = (raw || 'http://localhost:18789').replace(/\/+$/, '')
+  if (!/^(https?|wss?):\/\//i.test(url)) url = `http://${url}`
+  const httpUrl = url.replace(/^ws:/i, 'http:').replace(/^wss:/i, 'https:')
+  const wsUrl = httpUrl.replace(/^http:/i, 'ws:').replace(/^https:/i, 'wss:')
+  return { httpUrl, wsUrl }
+}

package/src/app/api/setup/check-provider/route.test.ts

@@ -1,7 +1,7 @@
 import assert from 'node:assert/strict'
 import test from 'node:test'
 
-import { normalizeOllamaSetupEndpoint, normalizeOpenClawUrl, parseErrorMessage } from './route'
+import { normalizeOllamaSetupEndpoint, normalizeOpenClawUrl, parseErrorMessage } from './helpers'
 
 test('normalizeOllamaSetupEndpoint strips local /v1 suffixes but preserves cloud endpoints', () => {
   assert.equal(
@@ -101,3 +101,19 @@ test('parseErrorMessage extracts .message from JSON', async () => {
   const res = fakeResponse(JSON.stringify({ message: 'quota exceeded' }))
   assert.equal(await parseErrorMessage(res, 'fallback'), 'quota exceeded')
 })
+
+// ---------------------------------------------------------------------------
+// normalizeOpenClawUrl — additional edge cases
+// ---------------------------------------------------------------------------
+
+test('normalizeOpenClawUrl handles https:// endpoint correctly', () => {
+  const { httpUrl, wsUrl } = normalizeOpenClawUrl('https://gateway.tailnet.ts.net')
+  assert.equal(httpUrl, 'https://gateway.tailnet.ts.net')
+  assert.equal(wsUrl, 'wss://gateway.tailnet.ts.net')
+})
+
+test('normalizeOpenClawUrl handles bare IP:port', () => {
+  const { httpUrl, wsUrl } = normalizeOpenClawUrl('10.0.0.5:18789')
+  assert.equal(httpUrl, 'http://10.0.0.5:18789')
+  assert.equal(wsUrl, 'ws://10.0.0.5:18789')
+})

package/src/app/api/setup/check-provider/route.ts

@@ -1,8 +1,9 @@
 import { NextResponse } from 'next/server'
 import { loadCredentials, decryptKey } from '@/lib/server/storage'
-import { getDeviceId, wsConnect } from '@/lib/providers/openclaw'
+import { getDeviceId, wsConnect, rpcOnConnectedGateway } from '@/lib/providers/openclaw'
 import { OPENAI_COMPATIBLE_DEFAULTS } from '@/lib/server/provider-health'
 import { resolveOllamaRuntimeConfig } from '@/lib/server/ollama-runtime'
+import { normalizeOllamaSetupEndpoint, normalizeOpenClawUrl, parseErrorMessage } from './helpers'
 
 type SetupProvider =
   | 'openai'
@@ -29,32 +30,11 @@ function clean(value: unknown): string {
   return typeof value === 'string' ? value.trim() : ''
 }
 
-export function normalizeOllamaSetupEndpoint(endpoint: string, useCloud: boolean): string {
-  const normalized = endpoint.replace(/\/+$/, '')
-  if (useCloud) return normalized
-  return normalized.replace(/\/v1$/i, '')
-}
-
 function parseBody(input: unknown): SetupCheckBody {
   if (!input || typeof input !== 'object' || Array.isArray(input)) return {}
   return input as SetupCheckBody
 }
 
-export async function parseErrorMessage(res: Response, fallback: string): Promise<string> {
-  const text = await res.text().catch(() => '')
-  if (!text) return fallback
-  try {
-    const parsed = JSON.parse(text)
-    if (typeof parsed?.error?.message === 'string' && parsed.error.message.trim()) return parsed.error.message.trim()
-    if (typeof parsed?.error === 'string' && parsed.error.trim()) return parsed.error.trim()
-    if (typeof parsed?.message === 'string' && parsed.message.trim()) return parsed.message.trim()
-    if (typeof parsed?.detail === 'string' && parsed.detail.trim()) return parsed.detail.trim()
-  } catch {
-    // Non-JSON response body.
-  }
-  return text.slice(0, 300).trim() || fallback
-}
-
 async function checkOpenAiCompatible(
   providerName: string,
   apiKey: string,
@@ -234,27 +214,40 @@ async function checkOllama(params: {
   }
 }
 
-export function normalizeOpenClawUrl(raw: string): { httpUrl: string; wsUrl: string } {
-  let url = (raw || 'http://localhost:18789').replace(/\/+$/, '')
-  if (!/^(https?|wss?):\/\//i.test(url)) url = `http://${url}`
-  const httpUrl = url.replace(/^ws:/i, 'http:').replace(/^wss:/i, 'https:')
-  const wsUrl = httpUrl.replace(/^http:/i, 'ws:').replace(/^https:/i, 'wss:')
-  return { httpUrl, wsUrl }
-}
-
-async function checkOpenClaw(apiKey: string, endpointRaw: string): Promise<{ ok: boolean; message: string; normalizedEndpoint: string; deviceId?: string; errorCode?: string }> {
+async function checkOpenClaw(apiKey: string, endpointRaw: string): Promise<{ ok: boolean; message: string; normalizedEndpoint: string; deviceId?: string; errorCode?: string; recommendedModel?: string }> {
   const { httpUrl: normalizedEndpoint, wsUrl } = normalizeOpenClawUrl(endpointRaw)
   const token = apiKey || undefined
   const deviceId = getDeviceId()
 
   const result = await wsConnect(wsUrl, token, true, 10_000)
-  // Close the WebSocket immediately — we only care about the handshake result
-  if (result.ws) try { result.ws.close() } catch {}
 
-  if (result.ok) {
-    return { ok: true, message: 'Connected to OpenClaw gateway.', normalizedEndpoint, deviceId }
+  if (!result.ok) {
+    if (result.ws) try { result.ws.close() } catch {}
+    return { ok: false, message: result.message, normalizedEndpoint, deviceId, errorCode: result.errorCode }
   }
-  return { ok: false, message: result.message, normalizedEndpoint, deviceId, errorCode: result.errorCode }
+
+  // Attempt model discovery via RPC before closing the connection
+  let recommendedModel: string | undefined
+  if (result.ws) {
+    try {
+      const payload = await rpcOnConnectedGateway(result.ws, 'models.list', {}, 8_000) as Record<string, unknown> | unknown[] | undefined
+      const p = payload as Record<string, unknown> | undefined
+      const models: unknown[] = Array.isArray(p?.models) ? p.models as unknown[] : Array.isArray(p?.data) ? p.data as unknown[] : Array.isArray(payload) ? payload : []
+      const first = models[0] as Record<string, unknown> | string | undefined
+      if (typeof first === 'string') {
+        recommendedModel = first
+      } else if (typeof first?.id === 'string') {
+        recommendedModel = first.id
+      } else if (typeof first?.name === 'string') {
+        recommendedModel = first.name
+      }
+    } catch {
+      // Model discovery is non-fatal — connection still counts as successful
+    }
+    try { result.ws.close() } catch {}
+  }
+
+  return { ok: true, message: 'Connected to OpenClaw gateway.', normalizedEndpoint, deviceId, recommendedModel }
 }
 
 export async function POST(req: Request) {