@swarmclawai/swarmclaw 0.7.5 → 0.7.7

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

@@ -0,0 +1,240 @@
+import { NextResponse } from 'next/server'
+import {
+  buildOpenClawDeployBundle,
+  deployOpenClawOverSsh,
+  getOpenClawLocalDeployStatus,
+  getOpenClawRemoteDeployStatus,
+  restartOpenClawLocalDeploy,
+  runOpenClawRemoteLifecycle,
+  startOpenClawLocalDeploy,
+  stopOpenClawLocalDeploy,
+  verifyOpenClawDeployment,
+  type OpenClawExposurePreset,
+  type OpenClawRemoteDeployProvider,
+  type OpenClawRemoteDeployTemplate,
+  type OpenClawSshConfig,
+  type OpenClawUseCaseTemplate,
+} from '@/lib/server/openclaw-deploy'
+
+export const dynamic = 'force-dynamic'
+
+function parsePort(value: unknown): number | undefined {
+  const parsed = typeof value === 'number'
+    ? value
+    : typeof value === 'string'
+      ? Number.parseInt(value, 10)
+      : Number.NaN
+  return Number.isFinite(parsed) ? parsed : undefined
+}
+
+function parseIntBounded(value: unknown, fallback: number, min: number, max: number): number {
+  const parsed = parsePort(value)
+  if (typeof parsed !== 'number') return fallback
+  return Math.max(min, Math.min(max, parsed))
+}
+
+function parseTemplate(value: unknown): OpenClawRemoteDeployTemplate | undefined {
+  if (value === 'docker' || value === 'render' || value === 'fly' || value === 'railway') {
+    return value
+  }
+  return undefined
+}
+
+function parseProvider(value: unknown): OpenClawRemoteDeployProvider | undefined {
+  if (
+    value === 'hetzner'
+    || value === 'digitalocean'
+    || value === 'vultr'
+    || value === 'linode'
+    || value === 'lightsail'
+    || value === 'gcp'
+    || value === 'azure'
+    || value === 'oci'
+    || value === 'generic'
+  ) {
+    return value
+  }
+  return undefined
+}
+
+function parseUseCase(value: unknown): OpenClawUseCaseTemplate | undefined {
+  if (
+    value === 'local-dev'
+    || value === 'single-vps'
+    || value === 'private-tailnet'
+    || value === 'browser-heavy'
+    || value === 'team-control'
+  ) {
+    return value
+  }
+  return undefined
+}
+
+function parseExposure(value: unknown): OpenClawExposurePreset | undefined {
+  if (
+    value === 'private-lan'
+    || value === 'tailscale'
+    || value === 'caddy'
+    || value === 'nginx'
+    || value === 'ssh-tunnel'
+  ) {
+    return value
+  }
+  return undefined
+}
+
+function parseSsh(value: unknown): Partial<OpenClawSshConfig> | null {
+  if (!value || typeof value !== 'object') return null
+  const ssh = value as Record<string, unknown>
+  return {
+    host: typeof ssh.host === 'string' ? ssh.host : '',
+    user: typeof ssh.user === 'string' ? ssh.user : null,
+    port: parsePort(ssh.port),
+    keyPath: typeof ssh.keyPath === 'string' ? ssh.keyPath : null,
+    targetDir: typeof ssh.targetDir === 'string' ? ssh.targetDir : null,
+  }
+}
+
+export async function GET() {
+  return NextResponse.json({
+    local: getOpenClawLocalDeployStatus(),
+    remote: getOpenClawRemoteDeployStatus(),
+  })
+}
+
+export async function POST(req: Request) {
+  const body = await req.json().catch(() => ({}))
+  const action = typeof body?.action === 'string' ? body.action : ''
+
+  try {
+    if (action === 'start-local') {
+      const result = await startOpenClawLocalDeploy({
+        port: parsePort(body.port),
+        token: typeof body.token === 'string' ? body.token : null,
+      })
+      return NextResponse.json({
+        ok: true,
+        local: result.local,
+        token: result.token,
+      })
+    }
+
+    if (action === 'stop-local') {
+      return NextResponse.json({
+        ok: true,
+        local: stopOpenClawLocalDeploy(),
+      })
+    }
+
+    if (action === 'restart-local') {
+      const result = await restartOpenClawLocalDeploy({
+        port: parsePort(body.port),
+        token: typeof body.token === 'string' ? body.token : null,
+      })
+      return NextResponse.json({
+        ok: true,
+        local: result.local,
+        token: result.token,
+      })
+    }
+
+    if (action === 'bundle') {
+      const bundle = buildOpenClawDeployBundle({
+        template: parseTemplate(body.template),
+        target: typeof body.target === 'string' ? body.target : null,
+        token: typeof body.token === 'string' ? body.token : null,
+        scheme: body.scheme === 'http' ? 'http' : 'https',
+        port: parsePort(body.port),
+        provider: parseProvider(body.provider),
+        useCase: parseUseCase(body.useCase),
+        exposure: parseExposure(body.exposure),
+      })
+      return NextResponse.json({
+        ok: true,
+        bundle,
+      })
+    }
+
+    if (action === 'ssh-deploy') {
+      const result = await deployOpenClawOverSsh({
+        template: parseTemplate(body.template),
+        target: typeof body.target === 'string' ? body.target : null,
+        token: typeof body.token === 'string' ? body.token : null,
+        scheme: body.scheme === 'http' ? 'http' : 'https',
+        port: parsePort(body.port),
+        provider: parseProvider(body.provider),
+        useCase: parseUseCase(body.useCase),
+        exposure: parseExposure(body.exposure),
+        ssh: parseSsh(body.ssh),
+      })
+      return NextResponse.json({
+        ok: result.ok,
+        remote: getOpenClawRemoteDeployStatus(),
+        processId: result.processId || null,
+        token: result.token,
+        bundle: result.bundle,
+        summary: result.summary,
+        commandPreview: result.commandPreview,
+      })
+    }
+
+    if (
+      action === 'remote-start'
+      || action === 'remote-stop'
+      || action === 'remote-restart'
+      || action === 'remote-upgrade'
+      || action === 'remote-backup'
+      || action === 'remote-restore'
+      || action === 'remote-rotate-token'
+    ) {
+      const actionMap = {
+        'remote-start': 'start',
+        'remote-stop': 'stop',
+        'remote-restart': 'restart',
+        'remote-upgrade': 'upgrade',
+        'remote-backup': 'backup',
+        'remote-restore': 'restore',
+        'remote-rotate-token': 'rotate-token',
+      } as const
+      const lifecycleAction = action as keyof typeof actionMap
+      const result = await runOpenClawRemoteLifecycle({
+        action: actionMap[lifecycleAction],
+        ssh: parseSsh(body.ssh),
+        token: typeof body.token === 'string' ? body.token : null,
+        backupPath: typeof body.backupPath === 'string' ? body.backupPath : null,
+      })
+      return NextResponse.json({
+        ok: result.ok,
+        remote: getOpenClawRemoteDeployStatus(),
+        processId: result.processId || null,
+        token: result.token,
+        summary: result.summary,
+        commandPreview: result.commandPreview,
+      })
+    }
+
+    if (action === 'verify') {
+      const result = await verifyOpenClawDeployment({
+        endpoint: typeof body.endpoint === 'string' ? body.endpoint : null,
+        credentialId: typeof body.credentialId === 'string' ? body.credentialId : null,
+        token: typeof body.token === 'string' ? body.token : null,
+        model: typeof body.model === 'string' ? body.model : null,
+        timeoutMs: parseIntBounded(body.timeoutMs, 8000, 1000, 30000),
+      })
+      return NextResponse.json({
+        ok: result.ok,
+        verify: result,
+      })
+    }
+
+    return NextResponse.json({ ok: false, error: 'Unknown deploy action.' }, { status: 400 })
+  } catch (err: unknown) {
+    return NextResponse.json(
+      {
+        ok: false,
+        error: err instanceof Error ? err.message : 'OpenClaw deploy action failed.',
+      },
+      { status: 500 },
+    )
+  }
+}

package/src/cli/index.js

@@ -310,6 +310,59 @@ const COMMAND_GROUPS = [
     description: 'OpenClaw discovery, gateway control, and runtime APIs',
     commands: [
       cmd('discover', 'GET', '/openclaw/discover', 'Discover OpenClaw gateways'),
+      cmd('deploy-status', 'GET', '/openclaw/deploy', 'Get managed OpenClaw deploy status'),
+      cmd('deploy-local-start', 'POST', '/openclaw/deploy', 'Start a managed local OpenClaw deployment (use --data JSON for port/token overrides)', {
+        expectsJsonBody: true,
+        defaultBody: { action: 'start-local' },
+      }),
+      cmd('deploy-local-stop', 'POST', '/openclaw/deploy', 'Stop the managed local OpenClaw deployment', {
+        expectsJsonBody: true,
+        defaultBody: { action: 'stop-local' },
+      }),
+      cmd('deploy-local-restart', 'POST', '/openclaw/deploy', 'Restart the managed local OpenClaw deployment (use --data JSON for port/token overrides)', {
+        expectsJsonBody: true,
+        defaultBody: { action: 'restart-local' },
+      }),
+      cmd('deploy-bundle', 'POST', '/openclaw/deploy', 'Generate an OpenClaw remote deployment bundle (use --data JSON for template/target/token)', {
+        expectsJsonBody: true,
+        defaultBody: { action: 'bundle' },
+      }),
+      cmd('deploy-ssh', 'POST', '/openclaw/deploy', 'Push the official-image OpenClaw bundle to a remote host over SSH (use --data JSON for target/ssh/provider)', {
+        expectsJsonBody: true,
+        defaultBody: { action: 'ssh-deploy' },
+      }),
+      cmd('deploy-verify', 'POST', '/openclaw/deploy', 'Verify an OpenClaw endpoint/token pair (use --data JSON for endpoint/token)', {
+        expectsJsonBody: true,
+        defaultBody: { action: 'verify' },
+      }),
+      cmd('remote-start', 'POST', '/openclaw/deploy', 'Start a remote SSH-managed OpenClaw stack', {
+        expectsJsonBody: true,
+        defaultBody: { action: 'remote-start' },
+      }),
+      cmd('remote-stop', 'POST', '/openclaw/deploy', 'Stop a remote SSH-managed OpenClaw stack', {
+        expectsJsonBody: true,
+        defaultBody: { action: 'remote-stop' },
+      }),
+      cmd('remote-restart', 'POST', '/openclaw/deploy', 'Restart a remote SSH-managed OpenClaw stack', {
+        expectsJsonBody: true,
+        defaultBody: { action: 'remote-restart' },
+      }),
+      cmd('remote-upgrade', 'POST', '/openclaw/deploy', 'Upgrade a remote SSH-managed OpenClaw stack', {
+        expectsJsonBody: true,
+        defaultBody: { action: 'remote-upgrade' },
+      }),
+      cmd('remote-backup', 'POST', '/openclaw/deploy', 'Create a remote backup on an SSH-managed OpenClaw host', {
+        expectsJsonBody: true,
+        defaultBody: { action: 'remote-backup' },
+      }),
+      cmd('remote-restore', 'POST', '/openclaw/deploy', 'Restore a remote backup on an SSH-managed OpenClaw host', {
+        expectsJsonBody: true,
+        defaultBody: { action: 'remote-restore' },
+      }),
+      cmd('remote-rotate-token', 'POST', '/openclaw/deploy', 'Rotate the gateway token on an SSH-managed OpenClaw host', {
+        expectsJsonBody: true,
+        defaultBody: { action: 'remote-rotate-token' },
+      }),
       cmd('directory', 'GET', '/openclaw/directory', 'List directory entries from running OpenClaw connectors'),
       cmd('gateway-status', 'GET', '/openclaw/gateway', 'Check OpenClaw gateway connection status'),
       cmd('gateway', 'POST', '/openclaw/gateway', 'Call OpenClaw gateway RPC/control action', { expectsJsonBody: true }),

package/src/cli/index.test.js

@@ -163,6 +163,108 @@ test('runCli sends authenticated request and emits compact JSON when --json is s
   assert.equal(stderr.toString(), '')
 })
 
+test('openclaw deploy bundle command merges action with provided JSON body', async () => {
+  const stdout = makeWritable()
+  const stderr = makeWritable()
+  const calls = []
+
+  const fetchImpl = async (url, init) => {
+    calls.push({ url: String(url), init })
+    return jsonResponse({ ok: true, bundle: { template: 'docker' } })
+  }
+
+  const exitCode = await runCli(
+    ['openclaw', 'deploy-bundle', '--data', '{"template":"docker","target":"openclaw.example.com"}', '--json'],
+    {
+      fetchImpl,
+      stdout,
+      stderr,
+      env: {},
+      cwd: process.cwd(),
+    }
+  )
+
+  assert.equal(exitCode, 0)
+  assert.equal(calls.length, 1)
+  assert.match(calls[0].url, /\/api\/openclaw\/deploy$/)
+  assert.equal(calls[0].init.method, 'POST')
+  assert.deepEqual(JSON.parse(String(calls[0].init.body)), {
+    action: 'bundle',
+    template: 'docker',
+    target: 'openclaw.example.com',
+  })
+  assert.equal(stdout.toString().trim(), '{"ok":true,"bundle":{"template":"docker"}}')
+  assert.equal(stderr.toString(), '')
+})
+
+test('openclaw deploy ssh command merges action with provided JSON body', async () => {
+  const stdout = makeWritable()
+  const stderr = makeWritable()
+  const calls = []
+
+  const fetchImpl = async (url, init) => {
+    calls.push({ url: String(url), init })
+    return jsonResponse({ ok: true, processId: 'remote-1' })
+  }
+
+  const exitCode = await runCli(
+    ['openclaw', 'deploy-ssh', '--data', '{"target":"openclaw.example.com","ssh":{"host":"1.2.3.4"}}', '--json'],
+    {
+      fetchImpl,
+      stdout,
+      stderr,
+      env: {},
+      cwd: process.cwd(),
+    }
+  )
+
+  assert.equal(exitCode, 0)
+  assert.equal(calls.length, 1)
+  assert.match(calls[0].url, /\/api\/openclaw\/deploy$/)
+  assert.equal(calls[0].init.method, 'POST')
+  assert.deepEqual(JSON.parse(String(calls[0].init.body)), {
+    action: 'ssh-deploy',
+    target: 'openclaw.example.com',
+    ssh: { host: '1.2.3.4' },
+  })
+  assert.equal(stdout.toString().trim(), '{"ok":true,"processId":"remote-1"}')
+  assert.equal(stderr.toString(), '')
+})
+
+test('openclaw remote restore command merges action with provided JSON body', async () => {
+  const stdout = makeWritable()
+  const stderr = makeWritable()
+  const calls = []
+
+  const fetchImpl = async (url, init) => {
+    calls.push({ url: String(url), init })
+    return jsonResponse({ ok: true, remote: { status: 'running' } })
+  }
+
+  const exitCode = await runCli(
+    ['openclaw', 'remote-restore', '--data', '{"backupPath":"/opt/openclaw/backups/latest.tgz","ssh":{"host":"1.2.3.4"}}', '--json'],
+    {
+      fetchImpl,
+      stdout,
+      stderr,
+      env: {},
+      cwd: process.cwd(),
+    }
+  )
+
+  assert.equal(exitCode, 0)
+  assert.equal(calls.length, 1)
+  assert.match(calls[0].url, /\/api\/openclaw\/deploy$/)
+  assert.equal(calls[0].init.method, 'POST')
+  assert.deepEqual(JSON.parse(String(calls[0].init.body)), {
+    action: 'remote-restore',
+    backupPath: '/opt/openclaw/backups/latest.tgz',
+    ssh: { host: '1.2.3.4' },
+  })
+  assert.equal(stdout.toString().trim(), '{"ok":true,"remote":{"status":"running"}}')
+  assert.equal(stderr.toString(), '')
+})
+
 test('runCli falls back to platform-api-key.txt when env key is missing', async () => {
   const stdout = makeWritable()
   const stderr = makeWritable()

package/src/cli/spec.js

@@ -211,6 +211,85 @@ const COMMAND_GROUPS = {
     description: 'OpenClaw discovery, gateway control, and runtime APIs',
     commands: {
       discover: { description: 'Discover OpenClaw gateways', method: 'GET', path: '/openclaw/discover' },
+      'deploy-status': { description: 'Get managed OpenClaw deploy status', method: 'GET', path: '/openclaw/deploy' },
+      'deploy-local-start': {
+        description: 'Start a managed local OpenClaw deployment (use --data JSON for port/token overrides)',
+        method: 'POST',
+        path: '/openclaw/deploy',
+        staticBody: { action: 'start-local' },
+      },
+      'deploy-local-stop': {
+        description: 'Stop the managed local OpenClaw deployment',
+        method: 'POST',
+        path: '/openclaw/deploy',
+        staticBody: { action: 'stop-local' },
+      },
+      'deploy-local-restart': {
+        description: 'Restart the managed local OpenClaw deployment (use --data JSON for port/token overrides)',
+        method: 'POST',
+        path: '/openclaw/deploy',
+        staticBody: { action: 'restart-local' },
+      },
+      'deploy-bundle': {
+        description: 'Generate an OpenClaw remote deployment bundle (use --data JSON for template/target/token)',
+        method: 'POST',
+        path: '/openclaw/deploy',
+        staticBody: { action: 'bundle' },
+      },
+      'deploy-ssh': {
+        description: 'Push the official-image OpenClaw bundle to a remote host over SSH (use --data JSON for target/ssh/provider)',
+        method: 'POST',
+        path: '/openclaw/deploy',
+        staticBody: { action: 'ssh-deploy' },
+      },
+      'deploy-verify': {
+        description: 'Verify an OpenClaw endpoint/token pair (use --data JSON for endpoint/token)',
+        method: 'POST',
+        path: '/openclaw/deploy',
+        staticBody: { action: 'verify' },
+      },
+      'remote-start': {
+        description: 'Start a remote SSH-managed OpenClaw stack',
+        method: 'POST',
+        path: '/openclaw/deploy',
+        staticBody: { action: 'remote-start' },
+      },
+      'remote-stop': {
+        description: 'Stop a remote SSH-managed OpenClaw stack',
+        method: 'POST',
+        path: '/openclaw/deploy',
+        staticBody: { action: 'remote-stop' },
+      },
+      'remote-restart': {
+        description: 'Restart a remote SSH-managed OpenClaw stack',
+        method: 'POST',
+        path: '/openclaw/deploy',
+        staticBody: { action: 'remote-restart' },
+      },
+      'remote-upgrade': {
+        description: 'Upgrade a remote SSH-managed OpenClaw stack',
+        method: 'POST',
+        path: '/openclaw/deploy',
+        staticBody: { action: 'remote-upgrade' },
+      },
+      'remote-backup': {
+        description: 'Create a remote backup on an SSH-managed OpenClaw host',
+        method: 'POST',
+        path: '/openclaw/deploy',
+        staticBody: { action: 'remote-backup' },
+      },
+      'remote-restore': {
+        description: 'Restore a remote backup on an SSH-managed OpenClaw host',
+        method: 'POST',
+        path: '/openclaw/deploy',
+        staticBody: { action: 'remote-restore' },
+      },
+      'remote-rotate-token': {
+        description: 'Rotate the gateway token on an SSH-managed OpenClaw host',
+        method: 'POST',
+        path: '/openclaw/deploy',
+        staticBody: { action: 'remote-rotate-token' },
+      },
       directory: { description: 'List directory entries from running OpenClaw connectors', method: 'GET', path: '/openclaw/directory' },
       'gateway-status': { description: 'Check OpenClaw gateway connection status', method: 'GET', path: '/openclaw/gateway' },
       gateway: { description: 'Call OpenClaw gateway RPC/control action', method: 'POST', path: '/openclaw/gateway' },

package/src/components/agents/agent-sheet.tsx

@@ -72,6 +72,24 @@ function parseIdentityList(value: string): string[] {
     })
 }
 
+function formatGatewayTagList(value: string[] | null | undefined): string {
+  return Array.isArray(value) ? value.join(', ') : ''
+}
+
+function parseGatewayTagList(value: string): string[] {
+  const seen = new Set<string>()
+  return value
+    .split(/[,\n]/)
+    .map((entry) => entry.trim())
+    .filter((entry) => {
+      if (!entry) return false
+      const key = entry.toLowerCase()
+      if (seen.has(key)) return false
+      seen.add(key)
+      return true
+    })
+}
+
 export function AgentSheet() {
   const open = useAppStore((s) => s.agentSheetOpen)
   const setOpen = useAppStore((s) => s.setAgentSheetOpen)
@@ -113,6 +131,8 @@ export function AgentSheet() {
   const [credentialId, setCredentialId] = useState<string | null>(null)
   const [apiEndpoint, setApiEndpoint] = useState<string | null>(null)
   const [gatewayProfileId, setGatewayProfileId] = useState<string | null>(null)
+  const [preferredGatewayTagsText, setPreferredGatewayTagsText] = useState('')
+  const [preferredGatewayUseCase, setPreferredGatewayUseCase] = useState('')
   const [routingStrategy, setRoutingStrategy] = useState<AgentRoutingStrategy>('single')
   const [routingTargets, setRoutingTargets] = useState<AgentRoutingTarget[]>([])
   const [platformAssignScope, setPlatformAssignScope] = useState<'self' | 'all'>('self')
@@ -220,6 +240,8 @@ export function AgentSheet() {
         setCredentialId(editing.credentialId || null)
         setApiEndpoint(editing.apiEndpoint || null)
         setGatewayProfileId(editing.gatewayProfileId || null)
+        setPreferredGatewayTagsText(formatGatewayTagList(editing.preferredGatewayTags))
+        setPreferredGatewayUseCase(editing.preferredGatewayUseCase || '')
         setRoutingStrategy(editing.routingStrategy || 'single')
         setRoutingTargets(editing.routingTargets || [])
         setPlatformAssignScope(editing.platformAssignScope || 'self')
@@ -287,6 +309,8 @@ export function AgentSheet() {
         setCredentialId(null)
         setApiEndpoint(null)
         setGatewayProfileId(null)
+        setPreferredGatewayTagsText('')
+        setPreferredGatewayUseCase('')
         setRoutingStrategy('single')
         setRoutingTargets([])
         setPlatformAssignScope('self')
@@ -422,6 +446,8 @@ export function AgentSheet() {
       fallbackCredentialIds,
       apiEndpoint,
       gatewayProfileId,
+      preferredGatewayTags: parseGatewayTagList(preferredGatewayTagsText),
+      preferredGatewayUseCase: preferredGatewayUseCase || null,
       priority: routingTargets.length + 1,
     }
     setRoutingTargets((current) => [...current, nextTarget])
@@ -463,9 +489,13 @@ export function AgentSheet() {
       credentialId,
       apiEndpoint: normalizedEndpoint,
       gatewayProfileId,
+      preferredGatewayTags: parseGatewayTagList(preferredGatewayTagsText),
+      preferredGatewayUseCase: preferredGatewayUseCase || null,
       routingStrategy,
       routingTargets: routingTargets.map((target, index) => ({
         ...target,
+        preferredGatewayTags: parseGatewayTagList(formatGatewayTagList(target.preferredGatewayTags)),
+        preferredGatewayUseCase: target.preferredGatewayUseCase || null,
         priority: typeof target.priority === 'number' ? target.priority : index + 1,
       })),
       subAgentIds: canDelegateToAgents ? subAgentIds : [],
@@ -1698,6 +1728,34 @@ export function AgentSheet() {
         </div>
       )}
 
+      {(provider === 'openclaw' || routingTargets.some((target) => target.provider === 'openclaw') || openclawGatewayProfiles.length > 0) && (
+        <div className="mb-8">
+          <label className="flex items-center gap-2 font-display text-[12px] font-600 text-text-2 uppercase tracking-[0.08em] mb-2">
+            Gateway Preferences <HintTip text="When multiple OpenClaw gateways are available, prefer matching tags or deployment templates before falling back to the default route." />
+          </label>
+          <div className="grid grid-cols-1 md:grid-cols-2 gap-3">
+            <input
+              type="text"
+              value={preferredGatewayTagsText}
+              onChange={(e) => setPreferredGatewayTagsText(e.target.value)}
+              placeholder="gpu, local, research"
+              className={inputClass}
+            />
+            <select value={preferredGatewayUseCase} onChange={(e) => setPreferredGatewayUseCase(e.target.value)} className={inputClass}>
+              <option value="">Any OpenClaw template</option>
+              <option value="local-dev">Local Dev</option>
+              <option value="single-vps">Single VPS</option>
+              <option value="private-tailnet">Private Tailnet</option>
+              <option value="browser-heavy">Browser Heavy</option>
+              <option value="team-control">Team Control</option>
+            </select>
+          </div>
+          <p className="text-[11px] text-text-3/70 mt-2">
+            These preferences bias scheduling toward matching OpenClaw control planes without hard-locking the agent to one gateway.
+          </p>
+        </div>
+      )}
+
       <div className="mb-8">
         <label className="flex items-center gap-2 font-display text-[12px] font-600 text-text-2 uppercase tracking-[0.08em] mb-2">
           Model Routing <HintTip text="Route this agent through a provider/model pool instead of a single fixed model. The base provider remains the default when no route matches." />
@@ -1752,25 +1810,45 @@ export function AgentSheet() {
                   />
                 </div>
                 {target.provider === 'openclaw' && openclawGatewayProfiles.length > 0 && (
-                  <select
-                    value={target.gatewayProfileId || ''}
-                    onChange={(e) => {
-                      const nextId = e.target.value || null
-                      const gateway = openclawGatewayProfiles.find((item) => item.id === nextId)
-                      updateRoutingTarget(target.id, {
-                        gatewayProfileId: nextId,
-                        apiEndpoint: gateway?.endpoint || target.apiEndpoint || null,
-                        credentialId: gateway?.credentialId || target.credentialId || null,
-                        model: target.model || 'default',
-                      })
-                    }}
-                    className={inputClass}
-                  >
-                    <option value="">Custom OpenClaw endpoint</option>
-                    {openclawGatewayProfiles.map((gateway) => (
-                      <option key={gateway.id} value={gateway.id}>{gateway.name}</option>
-                    ))}
-                  </select>
+                  <div className="grid grid-cols-1 md:grid-cols-3 gap-3">
+                    <select
+                      value={target.gatewayProfileId || ''}
+                      onChange={(e) => {
+                        const nextId = e.target.value || null
+                        const gateway = openclawGatewayProfiles.find((item) => item.id === nextId)
+                        updateRoutingTarget(target.id, {
+                          gatewayProfileId: nextId,
+                          apiEndpoint: gateway?.endpoint || target.apiEndpoint || null,
+                          credentialId: gateway?.credentialId || target.credentialId || null,
+                          model: target.model || 'default',
+                        })
+                      }}
+                      className={inputClass}
+                    >
+                      <option value="">Custom OpenClaw endpoint</option>
+                      {openclawGatewayProfiles.map((gateway) => (
+                        <option key={gateway.id} value={gateway.id}>{gateway.name}</option>
+                      ))}
+                    </select>
+                    <input
+                      value={formatGatewayTagList(target.preferredGatewayTags)}
+                      onChange={(e) => updateRoutingTarget(target.id, { preferredGatewayTags: parseGatewayTagList(e.target.value) })}
+                      placeholder="Prefer tags"
+                      className={inputClass}
+                    />
+                    <select
+                      value={target.preferredGatewayUseCase || ''}
+                      onChange={(e) => updateRoutingTarget(target.id, { preferredGatewayUseCase: e.target.value || null })}
+                      className={inputClass}
+                    >
+                      <option value="">Any OpenClaw template</option>
+                      <option value="local-dev">Local Dev</option>
+                      <option value="single-vps">Single VPS</option>
+                      <option value="private-tailnet">Private Tailnet</option>
+                      <option value="browser-heavy">Browser Heavy</option>
+                      <option value="team-control">Team Control</option>
+                    </select>
+                  </div>
                 )}
                 <div className="grid grid-cols-1 md:grid-cols-[1fr_auto] gap-3">
                   <input