@swarmclawai/swarmclaw 0.9.9 → 1.0.2

package/src/components/auth/setup-wizard/utils.test.ts

@@ -7,7 +7,10 @@ import {
   resolveOpenClawDashboardUrl,
   getOpenClawErrorHint,
   withHttpScheme,
+  buildStarterDrafts,
+  preferredConfiguredProvider,
 } from './utils'
+import type { ConfiguredProvider } from './types'
 
 // ---------------------------------------------------------------------------
 // stepIndex
@@ -157,3 +160,79 @@ test('withHttpScheme preserves ws://', () => {
 test('withHttpScheme preserves wss://', () => {
   assert.equal(withHttpScheme('wss://example.com'), 'wss://example.com')
 })
+
+// ---------------------------------------------------------------------------
+// buildStarterDrafts — OpenClaw provider handling
+// ---------------------------------------------------------------------------
+
+function makeConfiguredProvider(overrides: Partial<ConfiguredProvider> & { provider: ConfiguredProvider['provider'] }): ConfiguredProvider {
+  return {
+    id: 'cp-1',
+    name: 'Test Provider',
+    credentialId: null,
+    endpoint: null,
+    defaultModel: '',
+    gatewayProfileId: null,
+    verified: true,
+    ...overrides,
+  }
+}
+
+test('buildStarterDrafts assigns OpenClaw provider to drafts', () => {
+  const cp = makeConfiguredProvider({ provider: 'openclaw', endpoint: 'http://localhost:18789' })
+  const drafts = buildStarterDrafts({
+    starterKitId: 'personal_assistant',
+    intentText: '',
+    configuredProviders: [cp],
+  })
+  assert.ok(drafts.length > 0, 'should produce at least one draft')
+  for (const d of drafts) {
+    assert.equal(d.provider, 'openclaw')
+    assert.equal(d.providerConfigId, cp.id)
+  }
+})
+
+test('buildStarterDrafts OpenClaw drafts use empty model (not "default")', () => {
+  const cp = makeConfiguredProvider({ provider: 'openclaw', defaultModel: '' })
+  const drafts = buildStarterDrafts({
+    starterKitId: 'personal_assistant',
+    intentText: '',
+    configuredProviders: [cp],
+  })
+  for (const d of drafts) {
+    // Model should be empty since the gateway controls the model
+    assert.equal(d.model, '')
+  }
+})
+
+test('buildStarterDrafts OpenClaw drafts inherit endpoint from provider', () => {
+  const cp = makeConfiguredProvider({ provider: 'openclaw', endpoint: 'http://10.0.0.5:18789' })
+  const drafts = buildStarterDrafts({
+    starterKitId: 'personal_assistant',
+    intentText: '',
+    configuredProviders: [cp],
+  })
+  for (const d of drafts) {
+    assert.equal(d.apiEndpoint, 'http://10.0.0.5:18789')
+  }
+})
+
+test('buildStarterDrafts carries dashboardUrl through from ConfiguredProvider', () => {
+  const cp = makeConfiguredProvider({
+    provider: 'openclaw',
+    endpoint: 'http://localhost:18789',
+    dashboardUrl: 'http://localhost:18789?token=my-secret',
+  })
+  // dashboardUrl lives on the ConfiguredProvider, not the draft — verify it's accessible
+  assert.equal(cp.dashboardUrl, 'http://localhost:18789?token=my-secret')
+})
+
+test('preferredConfiguredProvider picks openclaw provider for openclaw template', () => {
+  const openclawCp = makeConfiguredProvider({ id: 'oc-1', provider: 'openclaw' })
+  const openaiCp = makeConfiguredProvider({ id: 'oai-1', provider: 'openai' })
+  const result = preferredConfiguredProvider(
+    { id: 'tmpl-1', name: 'Test', description: '', systemPrompt: '', tools: [], recommendedProviders: ['openclaw'] },
+    [openaiCp, openclawCp],
+  )
+  assert.equal(result?.id, 'oc-1')
+})

package/src/components/chat/chat-header.tsx

@@ -162,6 +162,8 @@ export function ChatHeader({ session, streaming, onStop, onMenuToggle, onBack, m
   const sourceDropdownRef = useRef<HTMLDivElement>(null)
   const [syncingHistory, setSyncingHistory] = useState(false)
   const [syncResult, setSyncResult] = useState('')
+  const [openClawDashboardUrl, setOpenClawDashboardUrl] = useState<string | null>(null)
+  const [openClawDashboardLoading, setOpenClawDashboardLoading] = useState(false)
   const [renaming, setRenaming] = useState(false)
   const [renameDraft, setRenameDraft] = useState('')
   const [renameSaving, setRenameSaving] = useState(false)
@@ -494,6 +496,25 @@ export function ChatHeader({ session, streaming, onStop, onMenuToggle, onBack, m
     return () => clearTimeout(timer)
   }, [syncResult])
 
+  const loadOpenClawDashboardUrl = useCallback(async () => {
+    if (!session.agentId || openClawDashboardLoading) return
+    setOpenClawDashboardLoading(true)
+    try {
+      const result = await api<{ url: string }>('GET', `/openclaw/dashboard-url?agentId=${session.agentId}`)
+      if (result.url) setOpenClawDashboardUrl(result.url)
+    } catch {
+      // Fall back to agent endpoint
+      const ep = (agent?.apiEndpoint || 'http://localhost:18789').replace(/\/+$/, '')
+      setOpenClawDashboardUrl(/^https?:\/\//i.test(ep) ? ep : `http://${ep}`)
+    } finally {
+      setOpenClawDashboardLoading(false)
+    }
+  }, [session.agentId, agent?.apiEndpoint, openClawDashboardLoading])
+
+  useEffect(() => {
+    if (isOpenClawAgent && !openClawDashboardUrl) void loadOpenClawDashboardUrl()
+  }, [isOpenClawAgent, openClawDashboardUrl, loadOpenClawDashboardUrl])
+
   const startRename = () => {
     if (!agent) return
     setRenameDraft(agent.name)
@@ -751,7 +772,29 @@ export function ChatHeader({ session, streaming, onStop, onMenuToggle, onBack, m
                 </HeaderChip>
               )
             })}
-            {modelName && (
+            {isOpenClawAgent ? (
+              <a
+                href={openClawDashboardUrl || '#'}
+                target="_blank"
+                rel="noopener noreferrer"
+                onClick={(e) => {
+                  if (openClawDashboardUrl) return
+                  e.preventDefault()
+                  if (!openClawDashboardLoading) void loadOpenClawDashboardUrl()
+                }}
+                className="inline-flex max-w-full items-center gap-1.5 rounded-[9px] border border-white/[0.06] bg-white/[0.03] px-2.5 py-1 text-[10px] font-600 text-text-3/70 backdrop-blur-sm transition-colors hover:border-white/[0.1] hover:bg-white/[0.06] hover:text-accent-bright shrink-0"
+              >
+                <svg width="10" height="10" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" className="shrink-0">
+                  <path d="M12 3l1.8 5.2L19 10l-5.2 1.8L12 17l-1.8-5.2L5 10l5.2-1.8L12 3Z" />
+                </svg>
+                <span className="truncate max-w-[min(42vw,220px)]">OpenClaw Dashboard</span>
+                <svg width="10" height="10" viewBox="0 0 14 14" fill="none" className="shrink-0 opacity-50">
+                  <path d="M5.5 3H3.5C3.22386 3 3 3.22386 3 3.5V10.5C3 10.7761 3.22386 11 3.5 11H10.5C10.7761 11 11 10.7761 11 10.5V8.5" stroke="currentColor" strokeWidth="1.2" strokeLinecap="round" />
+                  <path d="M8 2H12V6" stroke="currentColor" strokeWidth="1.2" strokeLinecap="round" strokeLinejoin="round" />
+                  <path d="M12 2L7 7" stroke="currentColor" strokeWidth="1.2" strokeLinecap="round" />
+                </svg>
+              </a>
+            ) : modelName ? (
               <div className="relative shrink-0" ref={modelSwitcherRef}>
                 <Tip label={`Switch model (${providerLabel})`}>
                 <button
@@ -803,7 +846,7 @@ export function ChatHeader({ session, streaming, onStop, onMenuToggle, onBack, m
                   </div>
                 )}
               </div>
-            )}
+            ) : null}
             {threadContextLabel && (
               <HeaderChip title={threadContextLabel}>
                 <svg width="10" height="10" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" className="shrink-0">

package/src/lib/providers/openclaw-exports.test.ts

@@ -0,0 +1,23 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+
+// Verify that rpcOnConnectedGateway is exported (needed by setup check-provider route)
+test('rpcOnConnectedGateway is exported from openclaw provider', async () => {
+  const mod = await import('./openclaw')
+  assert.equal(typeof mod.rpcOnConnectedGateway, 'function')
+})
+
+test('wsConnect is exported from openclaw provider', async () => {
+  const mod = await import('./openclaw')
+  assert.equal(typeof mod.wsConnect, 'function')
+})
+
+test('getDeviceId is exported from openclaw provider', async () => {
+  const mod = await import('./openclaw')
+  assert.equal(typeof mod.getDeviceId, 'function')
+})
+
+test('buildOpenClawConnectParams is exported from openclaw provider', async () => {
+  const mod = await import('./openclaw')
+  assert.equal(typeof mod.buildOpenClawConnectParams, 'function')
+})

package/src/lib/providers/openclaw.ts

@@ -321,7 +321,7 @@ export function buildOpenClawSessionKey(
   return `agent:${agentId}:swarm:${sessionId}`
 }
 
-async function rpcOnConnectedGateway(
+export async function rpcOnConnectedGateway(
   ws: InstanceType<typeof WebSocket>,
   method: string,
   params: unknown,

package/src/lib/server/data-dir.test.ts

@@ -90,4 +90,39 @@ describe('data-dir resolution', () => {
       fs.rmSync(tempDir, { recursive: true, force: true })
     }
   })
+
+  it('derives runtime directories from SWARMCLAW_HOME when set', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-data-dir-home-'))
+    const fakeHome = path.join(tempDir, 'home')
+    const swarmclawHome = path.join(tempDir, 'project', '.swarmclaw')
+
+    try {
+      const env = { ...process.env, HOME: fakeHome, SWARMCLAW_HOME: swarmclawHome }
+      delete (env as any).DATA_DIR
+      delete (env as any).WORKSPACE_DIR
+      delete (env as any).BROWSER_PROFILES_DIR
+
+      const result = spawnSync(process.execPath, ['--import', 'tsx', '--input-type=module', '--eval', `
+        const modNs = await import('./src/lib/server/data-dir')
+        const mod = modNs.default || modNs['module.exports'] || modNs
+        console.log(JSON.stringify({
+          dataDir: mod.DATA_DIR,
+          workspaceDir: mod.WORKSPACE_DIR,
+          browserProfilesDir: mod.BROWSER_PROFILES_DIR,
+        }))
+      `], {
+        cwd: repoRoot,
+        env,
+        encoding: 'utf-8',
+      })
+
+      assert.equal(result.status, 0, result.stderr || result.stdout || 'subprocess failed')
+      const payload = extractLastJson(result.stdout || '')
+      assert.equal(payload.dataDir, path.join(swarmclawHome, 'data'))
+      assert.equal(payload.workspaceDir, path.join(swarmclawHome, 'workspace'))
+      assert.equal(payload.browserProfilesDir, path.join(swarmclawHome, 'browser-profiles'))
+    } finally {
+      fs.rmSync(tempDir, { recursive: true, force: true })
+    }
+  })
 })

package/src/lib/server/data-dir.ts

@@ -13,9 +13,16 @@ function isBuildBootstrapEnv(env: NodeJS.ProcessEnv = process.env, argv: string[
 
 export const IS_BUILD_BOOTSTRAP = isBuildBootstrapEnv()
 
+function resolveSwarmclawHome(): string | null {
+  const configured = process.env.SWARMCLAW_HOME?.trim()
+  return configured ? path.resolve(configured) : null
+}
+
 function resolveDataDir(): string {
   if (process.env.DATA_DIR) return process.env.DATA_DIR
   if (IS_BUILD_BOOTSTRAP) return path.join(os.tmpdir(), 'swarmclaw-build-data')
+  const appHome = resolveSwarmclawHome()
+  if (appHome) return path.join(appHome, 'data')
   return path.join(process.cwd(), 'data')
 }
 
@@ -41,6 +48,8 @@ function supportsChildWrites(dir: string): boolean {
 function resolveWorkspaceDir(): string {
   if (process.env.WORKSPACE_DIR) return process.env.WORKSPACE_DIR
   if (IS_BUILD_BOOTSTRAP) return path.join(DATA_DIR, 'workspace')
+  const appHome = resolveSwarmclawHome()
+  if (appHome) return path.join(appHome, 'workspace')
   const external = path.join(os.homedir(), '.swarmclaw', 'workspace')
   if (supportsChildWrites(external)) {
     return external
@@ -53,6 +62,8 @@ export const WORKSPACE_DIR = resolveWorkspaceDir()
 function resolveBrowserProfilesDir(): string {
   if (process.env.BROWSER_PROFILES_DIR) return process.env.BROWSER_PROFILES_DIR
   if (IS_BUILD_BOOTSTRAP) return path.join(DATA_DIR, 'browser-profiles')
+  const appHome = resolveSwarmclawHome()
+  if (appHome) return path.join(appHome, 'browser-profiles')
   const external = path.join(os.homedir(), '.swarmclaw', 'browser-profiles')
   if (supportsChildWrites(external)) {
     return external

package/src/lib/server/openclaw/health.ts

@@ -1,6 +1,8 @@
 import { deriveOpenClawWsUrl, normalizeOpenClawEndpoint } from '@/lib/openclaw/openclaw-endpoint'
 import { wsConnect } from '@/lib/providers/openclaw'
-import { decryptKey, loadCredentials } from '../storage'
+import { decryptKey, loadCredentials, loadGatewayProfiles, saveGatewayProfiles } from '../storage'
+import { notify } from '../ws-hub'
+import type { GatewayProfile } from '@/types'
 
 export interface OpenClawHealthInput {
   endpoint?: string | null
@@ -411,3 +413,30 @@ export async function probeOpenClawHealth(input: OpenClawHealthInput): Promise<O
     hint: http.hint,
   }
 }
+
+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
+}

package/src/lib/server/session-tools/file-send.test.ts

@@ -113,10 +113,26 @@ describe('normalizeSendFilePaths', () => {
     fs.rmSync(cwd, { recursive: true, force: true })
   })
 
-  it('resolves browser profile screenshot paths back into the agent home directory', () => {
+  it('resolves browser profile screenshot paths into the configured browser profiles directory', () => {
     const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'send-file-browser-profile-'))
     const resolved = resolveSendFileSourcePath(cwd, '../../../.swarmclaw/browser-profiles/example/mcp-output/page.png')
-    assert.match(resolved, new RegExp(`\\.swarmclaw[\\\\/]browser-profiles[\\\\/]example[\\\\/]mcp-output[\\\\/]page\\.png$`))
+    assert.match(resolved, new RegExp(`browser-profiles[\\\\/]example[\\\\/]mcp-output[\\\\/]page\\.png$`))
     fs.rmSync(cwd, { recursive: true, force: true })
   })
+
+  it('resolves browser profile screenshot paths from BROWSER_PROFILES_DIR when set', () => {
+    const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'send-file-browser-profile-env-'))
+    const browserProfilesDir = path.join(cwd, '.swarmclaw', 'browser-profiles')
+    const previousDir = process.env.BROWSER_PROFILES_DIR
+
+    try {
+      process.env.BROWSER_PROFILES_DIR = browserProfilesDir
+      const resolved = resolveSendFileSourcePath(cwd, '../../../.swarmclaw/browser-profiles/example/mcp-output/page.png')
+      assert.equal(resolved, path.join(browserProfilesDir, 'example', 'mcp-output', 'page.png'))
+    } finally {
+      if (previousDir === undefined) delete process.env.BROWSER_PROFILES_DIR
+      else process.env.BROWSER_PROFILES_DIR = previousDir
+      fs.rmSync(cwd, { recursive: true, force: true })
+    }
+  })
 })

package/src/lib/server/session-tools/file.ts

@@ -1,10 +1,9 @@
 import { z } from 'zod'
 import { tool, type StructuredToolInterface } from '@langchain/core/tools'
 import fs from 'fs'
-import os from 'os'
 import path from 'path'
 import { UPLOAD_DIR } from '../storage'
-import { WORKSPACE_DIR } from '../data-dir'
+import { BROWSER_PROFILES_DIR, WORKSPACE_DIR } from '../data-dir'
 import type { ToolBuildContext } from './context'
 import { safePath, truncate, listDirRecursive, MAX_FILE } from './context'
 import type { Plugin, PluginHooks } from '@/types'
@@ -387,19 +386,24 @@ export function findRecentSendFileFallbackPaths(cwd: string, maxAgeMs = 10 * 60
   return dedup(candidates)
 }
 
+function getBrowserProfilesDir(): string {
+  return process.env.BROWSER_PROFILES_DIR || BROWSER_PROFILES_DIR
+}
+
 export function resolveSendFileSourcePath(cwd: string, rawPath: string, scope?: 'workspace' | 'machine'): string {
   const trimmed = rawPath.trim()
   const uploadMatch = trimmed.match(/^(?:sandbox:)?\/api\/uploads\/(.+)$/)
   if (uploadMatch) {
     return path.join(UPLOAD_DIR, path.basename(uploadMatch[1]))
   }
-  const browserProfileIdx = trimmed.lastIndexOf('.swarmclaw/browser-profiles/')
-  if (browserProfileIdx !== -1) {
-    const relative = trimmed.slice(browserProfileIdx)
-    return path.join(os.homedir(), relative)
+  const browserProfileMatch = trimmed
+    .replaceAll('\\', '/')
+    .match(/(?:^|\/)\.swarmclaw\/browser-profiles\/(.+)$/)
+  if (browserProfileMatch) {
+    return path.join(getBrowserProfilesDir(), browserProfileMatch[1])
   }
   if (trimmed.startsWith('browser-profiles/')) {
-    const candidate = path.join(os.homedir(), '.swarmclaw', trimmed)
+    const candidate = path.join(getBrowserProfilesDir(), trimmed.slice('browser-profiles/'.length))
     if (fs.existsSync(candidate)) return candidate
   }
   if (trimmed === '/workspace' || trimmed === 'workspace') return cwd

package/src/lib/server/skills/skill-discovery.test.ts

@@ -1,7 +1,9 @@
 import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
 import path from 'node:path'
 import test from 'node:test'
-import { discoverSkills } from './skill-discovery'
+import { clearDiscoveredSkillsCache, discoverSkills } from './skill-discovery'
 
 test('discoverSkills includes tracked bundled skills from bundled-skills', () => {
   const skills = discoverSkills({ cwd: path.join(process.cwd(), 'src') })
@@ -14,3 +16,34 @@ test('discoverSkills includes tracked bundled skills from bundled-skills', () =>
     true,
   )
 })
+
+test('discoverSkills reads workspace skills from SWARMCLAW_HOME when set', () => {
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-skills-home-'))
+  const skillDir = path.join(tempHome, 'skills', 'local-skill')
+  const previousHome = process.env.SWARMCLAW_HOME
+
+  try {
+    fs.mkdirSync(skillDir, { recursive: true })
+    fs.writeFileSync(path.join(skillDir, 'SKILL.md'), `---
+name: local-skill
+description: A local test skill.
+---
+
+# Local Skill
+`, 'utf8')
+    process.env.SWARMCLAW_HOME = tempHome
+    clearDiscoveredSkillsCache()
+
+    const skills = discoverSkills()
+    const localSkill = skills.find((skill) => skill.name === 'local-skill')
+
+    assert.ok(localSkill)
+    assert.equal(localSkill?.source, 'workspace')
+    assert.equal(localSkill?.sourcePath, path.join(skillDir, 'SKILL.md'))
+  } finally {
+    clearDiscoveredSkillsCache()
+    if (previousHome === undefined) delete process.env.SWARMCLAW_HOME
+    else process.env.SWARMCLAW_HOME = previousHome
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  }
+})

package/src/lib/server/skills/skill-discovery.ts

@@ -29,7 +29,12 @@ export function clearDiscoveredSkillsCache(): void {
 }
 
 function buildCacheKey(cwd?: string): string {
-  return `${cwd || ''}`
+  return `${cwd || ''}|${resolveWorkspaceSkillsDir()}`
+}
+
+function resolveWorkspaceSkillsDir(): string {
+  const swarmclawHome = process.env.SWARMCLAW_HOME || path.join(os.homedir(), '.swarmclaw')
+  return path.join(swarmclawHome, 'skills')
 }
 
 function scanLayer(
@@ -81,7 +86,7 @@ function scanLayer(
  * Discover skills from three layers:
  *   1. Bundled: `bundled-skills/` (tracked with the app)
  *      Legacy fallback: `data/skills/`
- *   2. Workspace: `~/.swarmclaw/skills/` (user-installed)
+ *   2. Workspace: `<swarmclaw-home>/skills/` (user-installed)
  *   3. Project: `<cwd>/skills/` (project-local)
  *
  * Results are cached with a 5-second TTL. Later layers override
@@ -102,8 +107,8 @@ export function discoverSkills(opts?: { cwd?: string }): DiscoveredSkill[] {
     ...scanLayer(BUNDLED_SKILLS_DIR, 'bundled'),
   ]
 
-  // Layer 2: Workspace skills (~/.swarmclaw/skills/)
-  const workspaceDir = path.join(os.homedir(), '.swarmclaw', 'skills')
+  // Layer 2: Workspace skills (<swarmclaw-home>/skills/)
+  const workspaceDir = resolveWorkspaceSkillsDir()
   const workspace = scanLayer(workspaceDir, 'workspace')
 
   // Layer 3: Project-local skills (<cwd>/skills/)

package/src/lib/setup-defaults.test.ts

@@ -0,0 +1,42 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { DEFAULT_AGENTS, getDefaultModelForProvider } from './setup-defaults'
+
+// ---------------------------------------------------------------------------
+// OpenClaw default model is empty (not 'default')
+// ---------------------------------------------------------------------------
+
+test('OpenClaw default agent model is empty string', () => {
+  assert.equal(DEFAULT_AGENTS.openclaw.model, '')
+})
+
+test('getDefaultModelForProvider returns empty for openclaw', () => {
+  assert.equal(getDefaultModelForProvider('openclaw'), '')
+})
+
+test('OpenClaw default model is falsy so UI does not render a suggested model', () => {
+  assert.ok(!DEFAULT_AGENTS.openclaw.model, 'model should be falsy')
+})
+
+// ---------------------------------------------------------------------------
+// Other providers still have their expected models
+// ---------------------------------------------------------------------------
+
+test('getDefaultModelForProvider returns non-empty for openai', () => {
+  const model = getDefaultModelForProvider('openai')
+  assert.ok(model, 'openai model should be truthy')
+})
+
+test('getDefaultModelForProvider returns non-empty for anthropic', () => {
+  const model = getDefaultModelForProvider('anthropic')
+  assert.ok(model, 'anthropic model should be truthy')
+})
+
+test('getDefaultModelForProvider returns non-empty for ollama', () => {
+  const model = getDefaultModelForProvider('ollama')
+  assert.ok(model, 'ollama model should be truthy')
+})
+
+test('custom provider default model is empty (like openclaw)', () => {
+  assert.equal(DEFAULT_AGENTS.custom.model, '')
+})

package/src/lib/setup-defaults.ts

@@ -629,7 +629,7 @@ export const DEFAULT_AGENTS: Record<SetupProvider, DefaultAgentConfig> = {
     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',
+    model: '',
     tools: STARTER_AGENT_TOOLS,
   },
   custom: {