@swarmclawai/swarmclaw 0.6.6 → 0.6.7

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

@@ -25,7 +25,7 @@ export async function POST(req: Request) {
     return NextResponse.json({ error: 'Invalid JSON body.' }, { status: 400 })
   }
 
-  const { title, content, tags, scope, agentIds } = body as Record<string, unknown>
+  const { title, content, tags, scope, agentIds, source, sourceUrl } = body as Record<string, unknown>
 
   if (typeof title !== 'string' || !title.trim()) {
     return NextResponse.json({ error: 'title is required.' }, { status: 400 })
@@ -43,12 +43,17 @@ export async function POST(req: Request) {
     ? (agentIds as unknown[]).filter((id): id is string => typeof id === 'string')
     : []
 
+  const normalizedSource = typeof source === 'string' && source.trim() ? source.trim() : undefined
+  const normalizedSourceUrl = typeof sourceUrl === 'string' && sourceUrl.trim() ? sourceUrl.trim() : undefined
+
   const entry = addKnowledge({
     title: title.trim(),
     content,
     tags: normalizedTags,
     scope: normalizedScope,
     agentIds: normalizedAgentIds,
+    source: normalizedSource,
+    sourceUrl: normalizedSourceUrl,
   })
 
   return NextResponse.json(entry)

package/src/app/api/openclaw/doctor/route.ts

@@ -0,0 +1,17 @@
+import { NextResponse } from 'next/server'
+import { runOpenClawDoctor } from '@/lib/server/openclaw-doctor'
+
+export const dynamic = 'force-dynamic'
+
+export async function GET() {
+  const result = await runOpenClawDoctor()
+  return NextResponse.json(result)
+}
+
+export async function POST(req: Request) {
+  const body = await req.json().catch(() => ({}))
+  const fix = typeof body.fix === 'boolean' ? body.fix : false
+  const workspace = typeof body.workspace === 'string' ? body.workspace : undefined
+  const result = await runOpenClawDoctor({ fix, workspace })
+  return NextResponse.json(result)
+}

package/src/app/api/sessions/[id]/chat/route.ts

@@ -25,6 +25,7 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
   }
 
   const encoder = new TextEncoder()
+  let abortRun: (() => void) | null = null
   const stream = new ReadableStream({
     start(controller) {
       let closed = false
@@ -48,7 +49,9 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
         mode: queueMode,
         onEvent: (ev) => writeEvent(ev as unknown as Record<string, unknown>),
         replyToId,
+        callerSignal: req.signal,
       })
+      abortRun = run.abort
 
       log.info('chat', `Enqueued session run ${run.runId}`, {
         sessionId: id,
@@ -86,7 +89,8 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
         })
     },
     cancel() {
-      // Client disconnected; subsequent writes should be ignored.
+      // Client disconnected — abort the run so the LLM stream is cancelled.
+      abortRun?.()
     },
   })
 

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

@@ -11,7 +11,7 @@ import { ensureMainSessionFlag, isProtectedMainSession } from '@/lib/server/main
 export const dynamic = 'force-dynamic'
 
 
-export async function GET(_req: Request) {
+export async function GET(req: Request) {
   const sessions = loadSessions()
   for (const id of Object.keys(sessions)) {
     const run = getSessionRunState(id)
@@ -19,7 +19,16 @@ export async function GET(_req: Request) {
     sessions[id].queuedCount = run.queueLength
     sessions[id].currentRunId = run.runningRunId || null
   }
-  return NextResponse.json(sessions)
+
+  const { searchParams } = new URL(req.url)
+  const limitParam = searchParams.get('limit')
+  if (!limitParam) return NextResponse.json(sessions)
+
+  const limit = Math.max(1, Number(limitParam) || 50)
+  const offset = Math.max(0, Number(searchParams.get('offset')) || 0)
+  const all = Object.values(sessions).sort((a, b) => (b.lastActiveAt ?? b.createdAt) - (a.lastActiveAt ?? a.createdAt))
+  const items = all.slice(offset, offset + limit)
+  return NextResponse.json({ items, total: all.length, hasMore: offset + limit < all.length })
 }
 
 export async function DELETE(req: Request) {

package/src/app/api/tasks/[id]/route.ts

@@ -10,6 +10,7 @@ import { notify } from '@/lib/server/ws-hub'
 import { createNotification } from '@/lib/server/create-notification'
 import { enqueueSystemEvent } from '@/lib/server/system-events'
 import { requestHeartbeatNow } from '@/lib/server/heartbeat-wake'
+import { validateDag, cascadeUnblock } from '@/lib/server/dag-validation'
 
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   // Keep completed queue integrity even if daemon is not running.
@@ -29,6 +30,17 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
 
   const prevStatus = tasks[id].status
 
+  // DAG validation: reject if proposed blockedBy would create a cycle
+  if (Array.isArray(body.blockedBy)) {
+    const dagResult = validateDag(tasks, id, body.blockedBy)
+    if (!dagResult.valid) {
+      return NextResponse.json(
+        { error: 'Dependency cycle detected', cycle: dagResult.cycle },
+        { status: 400 },
+      )
+    }
+  }
+
   // Support atomic comment append to avoid race conditions
   if (body.appendComment) {
     if (!tasks[id].comments) tasks[id].comments = []
@@ -114,20 +126,13 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
     }
   }
 
-  // When a task is completed, auto-unblock dependent tasks
+  // When a task is completed, cascade unblock dependent tasks
   if (tasks[id].status === 'completed') {
-    const blockedIds = Array.isArray(tasks[id].blocks) ? tasks[id].blocks as string[] : []
-    for (const blockedId of blockedIds) {
-      const blocked = tasks[blockedId]
-      if (!blocked) continue
-      const deps = Array.isArray(blocked.blockedBy) ? blocked.blockedBy as string[] : []
-      const allDone = deps.every((depId: string) => tasks[depId]?.status === 'completed')
-      if (allDone && (blocked.status === 'backlog' || blocked.status === 'todo')) {
-        blocked.status = 'queued'
-        blocked.queuedAt = Date.now()
-        blocked.updatedAt = Date.now()
-        saveTasks(tasks)
-        enqueueTask(blockedId)
+    const unblockedIds = cascadeUnblock(tasks, id)
+    if (unblockedIds.length > 0) {
+      saveTasks(tasks)
+      for (const uid of unblockedIds) {
+        enqueueTask(uid)
       }
     }
   }

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

@@ -1,6 +1,8 @@
 import { NextResponse } from 'next/server'
 import { genId } from '@/lib/id'
 import { loadTasks, saveTasks, loadSettings, loadAgents, logActivity } from '@/lib/server/storage'
+import { TaskCreateSchema, formatZodError } from '@/lib/validation/schemas'
+import { z } from 'zod'
 import { enqueueTask, validateCompletedTasksQueue } from '@/lib/server/queue'
 import { ensureTaskCompletionReport } from '@/lib/server/task-reports'
 import { formatValidationFailure, validateTaskCompletion } from '@/lib/server/task-validation'
@@ -8,6 +10,7 @@ import { pushMainLoopEventToMainSessions } from '@/lib/server/main-agent-loop'
 import { notify } from '@/lib/server/ws-hub'
 import { computeTaskFingerprint, findDuplicateTask } from '@/lib/task-dedupe'
 import { resolveTaskAgentFromDescription } from '@/lib/server/task-mention'
+import { validateDag } from '@/lib/server/dag-validation'
 
 export async function GET(req: Request) {
   // Keep completed queue integrity even if daemon is not running.
@@ -55,7 +58,12 @@ export async function DELETE(req: Request) {
 }
 
 export async function POST(req: Request) {
-  const body = await req.json()
+  const raw = await req.json()
+  const parsed = TaskCreateSchema.safeParse(raw)
+  if (!parsed.success) {
+    return NextResponse.json(formatZodError(parsed.error as z.ZodError), { status: 400 })
+  }
+  const body = { ...raw, ...parsed.data }
   const id = genId()
   const now = Date.now()
   const tasks = loadTasks()
@@ -66,6 +74,17 @@ export async function POST(req: Request) {
   const retryBackoffSec = Number.isFinite(Number(body.retryBackoffSec))
     ? Math.max(1, Math.min(3600, Math.trunc(Number(body.retryBackoffSec))))
     : Math.max(1, Math.min(3600, Math.trunc(Number(settings.taskRetryBackoffSec ?? 30))))
+  // DAG validation: reject if proposed blockedBy would create a cycle
+  if (Array.isArray(body.blockedBy) && body.blockedBy.length > 0) {
+    const dagResult = validateDag(tasks, id, body.blockedBy)
+    if (!dagResult.valid) {
+      return NextResponse.json(
+        { error: 'Dependency cycle detected', cycle: dagResult.cycle },
+        { status: 400 },
+      )
+    }
+  }
+
   // Resolve @mentions in description to auto-assign agent
   const resolvedAgentId = body.description
     ? resolveTaskAgentFromDescription(body.description, body.agentId || '', loadAgents())

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

@@ -1,5 +1,5 @@
 import { NextResponse } from 'next/server'
-import { loadUsage } from '@/lib/server/storage'
+import { loadUsage, loadSessions, loadAgents } from '@/lib/server/storage'
 import type { UsageRecord } from '@/types'
 export const dynamic = 'force-dynamic'
 
@@ -41,10 +41,14 @@ export async function GET(req: Request) {
     }
   }
 
+  // Build session→agent lookup
+  const sessions = loadSessions() as Record<string, { agentId?: string }>
+  const agents = loadAgents() as Record<string, { name?: string }>
+
   // Compute summaries
   let totalTokens = 0
   let totalCost = 0
-  const byAgent: Record<string, { tokens: number; cost: number }> = {}
+  const byAgent: Record<string, { name: string; cost: number; tokens: number; count: number }> = {}
   const byProvider: Record<string, { tokens: number; cost: number }> = {}
   const bucketMap: Record<string, { tokens: number; cost: number }> = {}
 
@@ -60,11 +64,16 @@ export async function GET(req: Request) {
     byProvider[prov].tokens += tokens
     byProvider[prov].cost += cost
 
-    // by agent (using sessionId as proxy — agents map to sessions)
-    const agentKey = r.sessionId || 'unknown'
-    if (!byAgent[agentKey]) byAgent[agentKey] = { tokens: 0, cost: 0 }
-    byAgent[agentKey].tokens += tokens
-    byAgent[agentKey].cost += cost
+    // by agent — resolve sessionId → agentId → agent name
+    const session = r.sessionId ? sessions[r.sessionId] : undefined
+    const agentId = session?.agentId || 'unknown'
+    const agentName = agentId !== 'unknown' && agents[agentId]?.name
+      ? agents[agentId].name
+      : agentId
+    if (!byAgent[agentId]) byAgent[agentId] = { name: agentName, cost: 0, tokens: 0, count: 0 }
+    byAgent[agentId].cost += cost
+    byAgent[agentId].tokens += tokens
+    byAgent[agentId].count += 1
 
     // time series bucketing
     const bk = bucketKey(r.timestamp || now, range)

package/src/cli/index.js

@@ -21,6 +21,7 @@ const COMMAND_GROUPS = [
       cmd('restore', 'POST', '/agents/trash', 'Restore a trashed agent', { expectsJsonBody: true }),
       cmd('purge', 'DELETE', '/agents/trash', 'Permanently delete a trashed agent', { expectsJsonBody: true }),
       cmd('thread', 'POST', '/agents/:id/thread', 'Get or create agent thread session'),
+      cmd('clone', 'POST', '/agents/:id/clone', 'Clone an agent'),
     ],
   },
   {
@@ -77,6 +78,7 @@ const COMMAND_GROUPS = [
       cmd('pin', 'POST', '/chatrooms/:id/pins', 'Toggle pin on a chatroom message', {
         expectsJsonBody: true,
       }),
+      cmd('moderate', 'POST', '/chatrooms/:id/moderate', 'Run moderation action on a chatroom', { expectsJsonBody: true }),
     ],
   },
   {
@@ -109,6 +111,7 @@ const COMMAND_GROUPS = [
         expectsJsonBody: true,
         defaultBody: { action: 'repair' },
       }),
+      cmd('health', 'GET', '/connectors/:id/health', 'Get connector health status'),
     ],
   },
   {
@@ -289,6 +292,8 @@ const COMMAND_GROUPS = [
       cmd('skills-install', 'POST', '/openclaw/skills/install', 'Install OpenClaw skill dependencies', { expectsJsonBody: true }),
       cmd('skills-remove', 'POST', '/openclaw/skills/remove', 'Remove OpenClaw skill', { expectsJsonBody: true }),
       cmd('sync', 'POST', '/openclaw/sync', 'Run OpenClaw sync action', { expectsJsonBody: true }),
+      cmd('doctor', 'GET', '/openclaw/doctor', 'Run OpenClaw doctor check (read-only)'),
+      cmd('doctor-fix', 'POST', '/openclaw/doctor', 'Run OpenClaw doctor with auto-fix', { expectsJsonBody: true }),
     ],
   },
   {

package/src/cli/index.ts

@@ -2,6 +2,12 @@
 
 import { Command } from 'commander'
 import { pathToFileURL } from 'node:url'
+import {
+  SETUP_PROVIDERS,
+  DEFAULT_AGENTS,
+  STARTER_AGENT_TOOLS,
+  type SetupProvider,
+} from '../lib/setup-defaults.ts'
 
 interface CliContext {
   baseUrl: string
@@ -9,8 +15,6 @@ interface CliContext {
   rawOutput: boolean
 }
 
-type SetupProvider = 'openai' | 'anthropic' | 'ollama' | 'openclaw'
-
 interface SetupAuthStatus {
   firstTime?: boolean
   key?: string
@@ -23,34 +27,7 @@ interface SetupProviderCheckResponse {
   recommendedModel?: string
 }
 
-const SUPPORTED_SETUP_PROVIDERS = new Set<SetupProvider>(['openai', 'anthropic', 'ollama', 'openclaw'])
-
-const DEFAULT_SETUP_AGENTS: Record<SetupProvider, { name: string; description: string; systemPrompt: string; model: string }> = {
-  openai: {
-    name: 'Assistant',
-    description: 'A helpful GPT-powered assistant.',
-    systemPrompt: 'You are a helpful, pragmatic assistant. Be concise, concrete, and action-oriented.',
-    model: 'gpt-4o',
-  },
-  anthropic: {
-    name: 'Assistant',
-    description: 'A helpful Claude-powered assistant.',
-    systemPrompt: 'You are a helpful, pragmatic assistant. Be concise, concrete, and action-oriented.',
-    model: 'claude-sonnet-4-6',
-  },
-  ollama: {
-    name: 'Assistant',
-    description: 'A local assistant running through Ollama.',
-    systemPrompt: 'You are a helpful, pragmatic assistant. Be concise, concrete, and action-oriented.',
-    model: 'llama3',
-  },
-  openclaw: {
-    name: 'OpenClaw Operator',
-    description: 'A manager agent for talking to and coordinating OpenClaw instances.',
-    systemPrompt: 'You are an operator focused on reliable execution, clear status updates, and task completion.',
-    model: 'default',
-  },
-}
+const SUPPORTED_SETUP_PROVIDERS = new Set<SetupProvider>(SETUP_PROVIDERS.map((p) => p.id))
 
 const DEFAULT_BASE_URL =
   process.env.SWARMCLAW_URL
@@ -206,7 +183,8 @@ async function apiRequestWithAccessKey<T = unknown>(
 function normalizeSetupProvider(value: string | undefined): SetupProvider {
   const lower = (value || '').trim().toLowerCase()
   if (SUPPORTED_SETUP_PROVIDERS.has(lower as SetupProvider)) return lower as SetupProvider
-  throw new Error(`Unsupported provider "${value}". Supported: openai, anthropic, ollama, openclaw`)
+  const supported = SETUP_PROVIDERS.map((p) => p.id).join(', ')
+  throw new Error(`Unsupported provider "${value}". Supported: ${supported}`)
 }
 
 function maskToken(value: string): string {
@@ -288,6 +266,201 @@ async function runWithHandler(command: Command, task: (ctx: CliContext) => Promi
   }
 }
 
+async function readSecret(prompt: string): Promise<string> {
+  const { stdin, stdout } = process
+  stdout.write(prompt)
+  return new Promise((resolve) => {
+    let buf = ''
+    const wasRaw = stdin.isRaw
+    stdin.setRawMode?.(true)
+    stdin.resume()
+    stdin.setEncoding('utf8')
+    const onData = (ch: string) => {
+      if (ch === '\n' || ch === '\r') {
+        stdin.setRawMode?.(wasRaw ?? false)
+        stdin.pause()
+        stdin.removeListener('data', onData)
+        stdout.write('\n')
+        resolve(buf)
+      } else if (ch === '\u0003') {
+        // Ctrl+C
+        process.exit(130)
+      } else if (ch === '\u007f' || ch === '\b') {
+        buf = buf.slice(0, -1)
+      } else {
+        buf += ch
+      }
+    }
+    stdin.on('data', onData)
+  })
+}
+
+async function runInteractiveSetup(ctx: CliContext): Promise<unknown> {
+  const { createInterface } = await import('node:readline/promises')
+
+  const auth = await resolveSetupAccessKey(ctx)
+  const configuredProviders: string[] = []
+  const createdAgents: Array<{ name: string; provider: string; model: string }> = []
+
+  // Wraps readline so we can destroy/recreate after raw-mode readSecret
+  let rl = createInterface({ input: process.stdin, output: process.stdout })
+
+  const freshRl = () => {
+    try { rl.close() } catch { /* already closed */ }
+    rl = createInterface({ input: process.stdin, output: process.stdout })
+  }
+
+  const ask = async (question: string, defaultValue?: string): Promise<string> => {
+    const suffix = defaultValue ? ` (${defaultValue})` : ''
+    const answer = (await rl.question(`${question}${suffix}: `)).trim()
+    return answer || defaultValue || ''
+  }
+
+  const askYN = async (question: string, defaultYes: boolean): Promise<boolean> => {
+    const hint = defaultYes ? 'Y/n' : 'y/N'
+    const answer = (await rl.question(`${question} [${hint}]: `)).trim().toLowerCase()
+    if (!answer) return defaultYes
+    return answer.startsWith('y')
+  }
+
+  const askSecret = async (prompt: string): Promise<string> => {
+    rl.close()
+    const value = await readSecret(prompt)
+    freshRl()
+    return value
+  }
+
+  console.log('\n  SwarmClaw Interactive Setup\n')
+
+  let addMore = true
+  while (addMore) {
+    console.log('  Available providers:\n')
+    const available = SETUP_PROVIDERS.filter((p) => !configuredProviders.includes(p.id))
+    if (available.length === 0) {
+      console.log('  All providers configured!\n')
+      break
+    }
+    available.forEach((p, i) => {
+      const badge = p.badge ? ` (${p.badge})` : ''
+      console.log(`  ${i + 1}. ${p.name}${badge}`)
+    })
+    console.log()
+
+    const choiceStr = await ask('Pick a provider', '1')
+    const choiceNum = parseInt(choiceStr, 10)
+    const selected = (choiceNum >= 1 && choiceNum <= available.length)
+      ? available[choiceNum - 1]
+      : available.find((p) => p.id === choiceStr.toLowerCase() || p.name.toLowerCase() === choiceStr.toLowerCase())
+
+    if (!selected) {
+      console.log(`  Invalid choice "${choiceStr}". Try again.\n`)
+      continue
+    }
+
+    const provider = selected.id
+    const defaults = DEFAULT_AGENTS[provider]
+    console.log(`\n  Setting up ${selected.name}...\n`)
+
+    // Collect inputs
+    let inputApiKey = ''
+    if (selected.requiresKey) {
+      inputApiKey = await askSecret('  API key: ')
+      if (!inputApiKey) {
+        console.log('  API key is required for this provider.\n')
+        continue
+      }
+    } else if (selected.optionalKey) {
+      inputApiKey = await askSecret('  Token (optional, press Enter to skip): ')
+    }
+
+    let inputEndpoint = ''
+    if (selected.supportsEndpoint) {
+      inputEndpoint = await ask('  Endpoint', selected.defaultEndpoint)
+    }
+
+    const agentName = await ask('  Agent name', defaults.name)
+    const runCheck = await askYN('  Run connection check?', true)
+
+    // Connection check
+    let normalizedEndpoint = inputEndpoint || undefined
+    let selectedModel: string | undefined
+
+    if (runCheck) {
+      process.stdout.write('  Checking connection...')
+      try {
+        const check = await apiRequestWithAccessKey<SetupProviderCheckResponse>(
+          ctx, 'POST', '/setup/check-provider', auth.accessKey,
+          compactObject({
+            provider,
+            apiKey: inputApiKey || undefined,
+            endpoint: selected.supportsEndpoint ? normalizedEndpoint : undefined,
+          }),
+        )
+        if (check?.ok) {
+          console.log(' OK')
+          if (check.normalizedEndpoint) normalizedEndpoint = check.normalizedEndpoint
+          if (check.recommendedModel) selectedModel = check.recommendedModel
+        } else {
+          console.log(` FAILED: ${check?.message || 'Unknown error'}`)
+        }
+      } catch (err: unknown) {
+        console.log(` FAILED: ${err instanceof Error ? err.message : String(err)}`)
+      }
+    }
+
+    // Save credential
+    let credentialId: string | null = null
+    if (inputApiKey) {
+      const credential = await apiRequestWithAccessKey<{ id?: string }>(
+        ctx, 'POST', '/credentials', auth.accessKey,
+        { provider, name: `${selected.name} key`, apiKey: inputApiKey },
+      )
+      credentialId = typeof credential?.id === 'string' ? credential.id : null
+    }
+
+    // Create agent
+    await apiRequestWithAccessKey<Record<string, unknown>>(
+      ctx, 'POST', '/agents', auth.accessKey,
+      compactObject({
+        name: agentName || defaults.name,
+        description: defaults.description,
+        systemPrompt: defaults.systemPrompt,
+        provider,
+        model: selectedModel || defaults.model,
+        credentialId: credentialId || null,
+        apiEndpoint: selected.supportsEndpoint ? (normalizedEndpoint || undefined) : undefined,
+        tools: STARTER_AGENT_TOOLS,
+      }),
+    )
+
+    configuredProviders.push(provider)
+    createdAgents.push({ name: agentName || defaults.name, provider, model: selectedModel || defaults.model })
+    console.log(`  Agent "${agentName || defaults.name}" created.\n`)
+
+    addMore = await askYN('  Add another provider?', false)
+  }
+
+  rl.close()
+
+  await apiRequestWithAccessKey(ctx, 'PUT', '/settings', auth.accessKey, { setupCompleted: true })
+
+  console.log('\n  Setup complete!\n')
+  console.log('  Created agents:')
+  for (const a of createdAgents) {
+    console.log(`    - ${a.name} (${a.provider}, ${a.model})`)
+  }
+  console.log()
+
+  return {
+    ok: true,
+    interactive: true,
+    providers: configuredProviders,
+    agents: createdAgents,
+    accessKeyMasked: maskToken(auth.accessKey),
+    firstTimeSetup: auth.firstTime,
+  }
+}
+
 export function buildProgram(): Command {
   const program = new Command()
 
@@ -743,8 +916,8 @@ export function buildProgram(): Command {
   setup
     .command('init')
     .description('Run command-line first-time setup (provider check, credential, starter agent)')
-    .option('--provider <provider>', 'Provider id (openai|anthropic|ollama|openclaw)', 'openai')
-    .option('--api-key <apiKey>', 'API key or token (required for openai/anthropic)')
+    .option('--provider <provider>', 'Provider id (e.g. openai, anthropic, ollama, google)')
+    .option('--api-key <apiKey>', 'API key or token')
     .option('--endpoint <endpoint>', 'Provider endpoint override')
     .option('--model <model>', 'Model override')
     .option('--agent-name <name>', 'Starter agent name')
@@ -752,6 +925,7 @@ export function buildProgram(): Command {
     .option('--system-prompt <systemPrompt>', 'Starter agent system prompt')
     .option('--skip-check', 'Skip provider connection check')
     .option('--no-create-agent', 'Do not create a starter agent')
+    .option('--no-interactive', 'Disable interactive prompts (flag-only mode)')
     .action(async function (opts: {
       provider?: string
       apiKey?: string
@@ -762,12 +936,21 @@ export function buildProgram(): Command {
       systemPrompt?: string
       skipCheck?: boolean
       createAgent?: boolean
+      interactive?: boolean
     }) {
       await runWithHandler(this as Command, async (ctx) => {
-        const provider = normalizeSetupProvider(opts.provider)
-        const defaults = DEFAULT_SETUP_AGENTS[provider]
-        const requiresApiKey = provider === 'openai' || provider === 'anthropic'
-        const supportsEndpoint = provider === 'openai' || provider === 'ollama' || provider === 'openclaw'
+        const hasFlags = !!(opts.provider && opts.provider !== 'openai') || !!opts.apiKey || !!opts.endpoint
+        const wantInteractive = opts.interactive !== false && !hasFlags && process.stdin.isTTY
+
+        if (wantInteractive) {
+          return runInteractiveSetup(ctx)
+        }
+
+        const provider = normalizeSetupProvider(opts.provider || 'openai')
+        const defaults = DEFAULT_AGENTS[provider]
+        const meta = SETUP_PROVIDERS.find((p) => p.id === provider)
+        const requiresApiKey = meta?.requiresKey ?? false
+        const supportsEndpoint = meta?.supportsEndpoint ?? false
 
         const inputApiKey = (opts.apiKey || '').trim()
         const inputEndpoint = (opts.endpoint || '').trim()
@@ -807,7 +990,7 @@ export function buildProgram(): Command {
         }
 
         let credentialId: string | null = null
-        if (inputApiKey && (provider === 'openai' || provider === 'anthropic' || provider === 'openclaw')) {
+        if (inputApiKey && (requiresApiKey || meta?.optionalKey)) {
           const credential = await apiRequestWithAccessKey<{ id?: string; name?: string }>(
             ctx,
             'POST',
@@ -815,7 +998,7 @@ export function buildProgram(): Command {
             auth.accessKey,
             {
               provider,
-              name: `${provider} key`,
+              name: `${meta?.name || provider} key`,
               apiKey: inputApiKey,
             },
           )
@@ -837,6 +1020,7 @@ export function buildProgram(): Command {
               model: selectedModel || defaults.model,
               credentialId: credentialId || null,
               apiEndpoint: supportsEndpoint ? (normalizedEndpoint || undefined) : undefined,
+              tools: STARTER_AGENT_TOOLS,
             }),
           )
         }