@swarmclawai/swarmclaw 0.7.7 → 0.8.0

package/src/app/api/chats/[id]/messages/route.ts

@@ -2,17 +2,19 @@ import { NextResponse } from 'next/server'
 import { active, loadStoredItem, upsertStoredItem } from '@/lib/server/storage'
 import { notFound } from '@/lib/server/collection-helpers'
 import { getSessionRunState } from '@/lib/server/session-run-manager'
-import { pruneStreamingAssistantArtifacts } from '@/lib/chat-streaming-state'
+import { materializeStreamingAssistantArtifacts } from '@/lib/chat-streaming-state'
+import { appendSessionNote } from '@/lib/server/session-note'
+import type { Message, Session } from '@/types'
 
 export async function GET(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const session = loadStoredItem('sessions', id)
+  const session = loadStoredItem('sessions', id) as Session | null
   if (!session) return notFound()
   session.messages = Array.isArray(session.messages) ? session.messages : []
 
   const run = getSessionRunState(id)
   const hasLiveRun = active.has(id) || !!run.runningRunId
-  if (!hasLiveRun && pruneStreamingAssistantArtifacts(session.messages)) {
+  if (!hasLiveRun && materializeStreamingAssistantArtifacts(session.messages)) {
     upsertStoredItem('sessions', id, session)
   }
 
@@ -46,27 +48,49 @@ export async function GET(req: Request, { params }: { params: Promise<{ id: stri
 
 export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const body = await req.json() as { kind?: string }
-  if (body.kind !== 'context-clear') {
-    return NextResponse.json({ error: 'Only context-clear kind is supported' }, { status: 400 })
+  const body = await req.json() as {
+    kind?: string
+    role?: Message['role']
+    text?: string
+    messageKind?: Message['kind']
   }
-  const session = loadStoredItem('sessions', id)
-  if (!session) return notFound()
 
-  session.messages.push({
-    role: 'user',
-    text: '',
-    kind: 'context-clear',
-    time: Date.now(),
-  })
-  upsertStoredItem('sessions', id, session)
-  return NextResponse.json({ ok: true })
+  if (body.kind === 'context-clear') {
+    const session = loadStoredItem('sessions', id) as Session | null
+    if (!session) return notFound()
+
+    session.messages.push({
+      role: 'user',
+      text: '',
+      kind: 'context-clear',
+      time: Date.now(),
+    })
+    upsertStoredItem('sessions', id, session)
+    return NextResponse.json({ ok: true })
+  }
+
+  if (body.kind === 'note') {
+    const inserted = appendSessionNote({
+      sessionId: id,
+      text: body.text || '',
+      role: body.role || 'assistant',
+      kind: body.messageKind || 'system',
+    })
+    if (!inserted) {
+      const session = loadStoredItem('sessions', id) as Session | null
+      if (!session) return notFound()
+      return NextResponse.json({ error: 'Note text is required' }, { status: 400 })
+    }
+    return NextResponse.json(inserted)
+  }
+
+  return NextResponse.json({ error: 'Only context-clear and note kinds are supported' }, { status: 400 })
 }
 
 export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const body = await req.json() as { messageIndex: number; bookmarked: boolean }
-  const session = loadStoredItem('sessions', id)
+  const session = loadStoredItem('sessions', id) as Session | null
   if (!session) return notFound()
 
   const { messageIndex, bookmarked } = body
@@ -82,7 +106,7 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
 export async function DELETE(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const body = await req.json() as { messageIndex: number }
-  const session = loadStoredItem('sessions', id)
+  const session = loadStoredItem('sessions', id) as Session | null
   if (!session) return notFound()
 
   const { messageIndex } = body

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

@@ -111,7 +111,7 @@ export async function DELETE(_req: Request, { params }: { params: Promise<{ id:
   const sessions = loadSessions()
   if (!sessions[id]) return notFound()
   if (active.has(id)) {
-    try { active.get(id).kill() } catch {}
+    try { active.get(id)?.kill() } catch {}
     active.delete(id)
   }
   deleteSession(id)

package/src/app/api/chats/[id]/stop/route.ts

@@ -1,17 +1,18 @@
 import { NextResponse } from 'next/server'
-import { pruneStreamingAssistantArtifacts } from '@/lib/chat-streaming-state'
+import { materializeStreamingAssistantArtifacts } from '@/lib/chat-streaming-state'
 import { active, loadStoredItem, upsertStoredItem } from '@/lib/server/storage'
 import { cancelSessionRuns } from '@/lib/server/session-run-manager'
+import type { Session } from '@/types'
 
 export async function POST(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const cancel = cancelSessionRuns(id, 'Stopped by user')
-  const session = loadStoredItem('sessions', id)
-  if (session && Array.isArray(session.messages) && pruneStreamingAssistantArtifacts(session.messages)) {
+  const session = loadStoredItem('sessions', id) as Session | null
+  if (session && Array.isArray(session.messages) && materializeStreamingAssistantArtifacts(session.messages)) {
     upsertStoredItem('sessions', id, session)
   }
   if (active.has(id)) {
-    try { active.get(id).kill() } catch {}
+    try { active.get(id)?.kill() } catch {}
     active.delete(id)
   }
   return NextResponse.json({ ok: true, ...cancel })

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

@@ -2,22 +2,37 @@ import { NextResponse } from 'next/server'
 import { genId } from '@/lib/id'
 import os from 'os'
 import path from 'path'
-import { loadSessions, saveSessions, deleteSession, active, loadAgents } from '@/lib/server/storage'
+import { loadSessions, saveSessions, deleteSession, active, loadAgents, upsertStoredItem } from '@/lib/server/storage'
 import { WORKSPACE_DIR } from '@/lib/server/data-dir'
 import { notify } from '@/lib/server/ws-hub'
 import { getSessionRunState } from '@/lib/server/session-run-manager'
 import { normalizeProviderEndpoint } from '@/lib/openclaw-endpoint'
 import { applyResolvedRoute, resolvePrimaryAgentRoute } from '@/lib/server/agent-runtime-config'
+import { buildAgentDisabledMessage, isAgentDisabled } from '@/lib/server/agent-availability'
+import { materializeStreamingAssistantArtifacts } from '@/lib/chat-streaming-state'
+import { ensureDaemonStarted } from '@/lib/server/daemon-state'
 export const dynamic = 'force-dynamic'
 
 
 export async function GET(req: Request) {
+  ensureDaemonStarted('api/chats:get')
   const sessions = loadSessions()
+  const changedSessionIds: string[] = []
   for (const id of Object.keys(sessions)) {
     const run = getSessionRunState(id)
     sessions[id].active = active.has(id) || !!run.runningRunId
     sessions[id].queuedCount = run.queueLength
     sessions[id].currentRunId = run.runningRunId || null
+    if (!sessions[id].active && Array.isArray(sessions[id].messages)) {
+      if (materializeStreamingAssistantArtifacts(sessions[id].messages)) changedSessionIds.push(id)
+    }
+  }
+  for (const id of changedSessionIds) {
+    const persisted = { ...sessions[id] } as Record<string, unknown>
+    delete persisted.active
+    delete persisted.queuedCount
+    delete persisted.currentRunId
+    upsertStoredItem('sessions', id, persisted)
   }
 
   const { searchParams } = new URL(req.url)
@@ -32,6 +47,7 @@ export async function GET(req: Request) {
 }
 
 export async function DELETE(req: Request) {
+  ensureDaemonStarted('api/chats:delete')
   const { ids } = await req.json().catch(() => ({ ids: [] })) as { ids: string[] }
   if (!Array.isArray(ids) || !ids.length) {
     return new NextResponse('Missing ids', { status: 400 })
@@ -41,7 +57,7 @@ export async function DELETE(req: Request) {
   for (const id of ids) {
     if (!sessions[id]) continue
     if (active.has(id)) {
-      try { active.get(id).kill() } catch {}
+      try { active.get(id)?.kill() } catch {}
       active.delete(id)
     }
     deleteSession(id)
@@ -52,6 +68,7 @@ export async function DELETE(req: Request) {
 }
 
 export async function POST(req: Request) {
+  ensureDaemonStarted('api/chats:post')
   const body = await req.json().catch(() => ({}))
   let cwd = (body.cwd || '').trim()
   if (cwd.startsWith('~/')) cwd = path.join(os.homedir(), cwd.slice(2))
@@ -61,6 +78,9 @@ export async function POST(req: Request) {
   const id = body.id || genId()
   const sessions = loadSessions()
   const agent = body.agentId ? loadAgents()[body.agentId] : null
+  if (isAgentDisabled(agent)) {
+    return NextResponse.json({ error: buildAgentDisabledMessage(agent, 'start chats') }, { status: 409 })
+  }
   const routePreferredGatewayTags = Array.isArray(body.routePreferredGatewayTags)
     ? body.routePreferredGatewayTags.filter((tag: unknown): tag is string => typeof tag === 'string' && tag.trim().length > 0)
     : []
@@ -101,6 +121,7 @@ export async function POST(req: Request) {
       claudeCode: null,
       codex: null,
       opencode: null,
+      gemini: null,
     },
     messages: Array.isArray(body.messages) ? body.messages : [],
     createdAt: Date.now(), lastActiveAt: Date.now(),

package/src/app/api/clawhub/install/route.ts

@@ -2,6 +2,7 @@ import { NextResponse } from 'next/server'
 import { genId } from '@/lib/id'
 import { loadSkills, saveSkills } from '@/lib/server/storage'
 import { fetchSkillContent } from '@/lib/server/clawhub-client'
+import { normalizeSkillPayload } from '@/lib/server/skills-normalize'
 
 export async function POST(req: Request) {
   const body = await req.json()
@@ -19,18 +20,37 @@ export async function POST(req: Request) {
     }
   }
 
+  const normalized = normalizeSkillPayload({
+    name,
+    description,
+    content,
+    sourceUrl: url,
+    author,
+    tags,
+  })
+
   const skills = loadSkills()
   const id = genId()
   skills[id] = {
     id,
-    name,
-    filename: `skill-${id}.md`,
-    content,
-    description: description || '',
-    sourceFormat: 'openclaw',
-    sourceUrl: url,
-    author: author || '',
-    tags: tags || [],
+    name: normalized.name,
+    filename: normalized.filename || `skill-${id}.md`,
+    content: normalized.content,
+    description: normalized.description || '',
+    sourceFormat: normalized.sourceFormat,
+    sourceUrl: normalized.sourceUrl,
+    author: normalized.author || '',
+    tags: normalized.tags || [],
+    version: normalized.version,
+    homepage: normalized.homepage,
+    primaryEnv: normalized.primaryEnv,
+    skillKey: normalized.skillKey,
+    always: normalized.always,
+    installOptions: normalized.installOptions,
+    skillRequirements: normalized.skillRequirements,
+    detectedEnvVars: normalized.detectedEnvVars,
+    security: normalized.security,
+    frontmatter: normalized.frontmatter,
     createdAt: Date.now(),
     updatedAt: Date.now(),
   }

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

@@ -2,8 +2,10 @@ import { NextResponse } from 'next/server'
 import { loadConnectors, saveConnectors, logActivity } from '@/lib/server/storage'
 import { notify } from '@/lib/server/ws-hub'
 import { notFound } from '@/lib/server/collection-helpers'
+import { ensureDaemonStarted } from '@/lib/server/daemon-state'
 
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  ensureDaemonStarted('api/connectors/[id]:get')
   const { id } = await params
   const connectors = loadConnectors()
   const connector = connectors[id]
@@ -11,8 +13,21 @@ export async function GET(_req: Request, { params }: { params: Promise<{ id: str
 
   // Merge runtime status, QR code, and presence
   try {
-    const { getConnectorStatus, getConnectorQR, isConnectorAuthenticated, hasConnectorCredentials, getConnectorPresence } = await import('@/lib/server/connectors/manager')
-    connector.status = getConnectorStatus(id)
+    const { getConnectorStatus, getConnectorQR, isConnectorAuthenticated, hasConnectorCredentials, getConnectorPresence, getReconnectState } = await import('@/lib/server/connectors/manager')
+    const runtimeStatus = getConnectorStatus(id)
+    connector.status = runtimeStatus === 'running'
+      ? 'running'
+      : connector.lastError
+        ? 'error'
+        : 'stopped'
+    const rState = getReconnectState(id)
+    if (rState) {
+      const ext = connector as unknown as Record<string, unknown>
+      ext.reconnectAttempts = rState.attempts
+      ext.nextRetryAt = rState.nextRetryAt
+      ext.reconnectError = rState.error
+      ext.reconnectExhausted = rState.exhausted
+    }
     const qr = getConnectorQR(id)
     if (qr) connector.qrDataUrl = qr
     connector.authenticated = isConnectorAuthenticated(id)
@@ -26,6 +41,7 @@ export async function GET(_req: Request, { params }: { params: Promise<{ id: str
 }
 
 export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  ensureDaemonStarted('api/connectors/[id]:put')
   const { id } = await params
   const body = await req.json()
   const connectors = loadConnectors()
@@ -38,12 +54,14 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
     try {
       const manager = await import('@/lib/server/connectors/manager')
       if (body.action === 'start') {
+        manager.clearReconnectState(id)
         await manager.startConnector(id)
         logActivity({ entityType: 'connector', entityId: id, action: 'started', actor: 'user', summary: `Connector started: "${connector.name}"` })
       } else if (body.action === 'stop') {
         await manager.stopConnector(id)
         logActivity({ entityType: 'connector', entityId: id, action: 'stopped', actor: 'user', summary: `Connector stopped: "${connector.name}"` })
       } else {
+        manager.clearReconnectState(id)
         await manager.repairConnector(id)
         logActivity({ entityType: 'connector', entityId: id, action: 'started', actor: 'user', summary: `Connector repaired: "${connector.name}"` })
       }
@@ -69,8 +87,33 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
 
   connectors[id] = connector
   saveConnectors(connectors)
+
+  try {
+    const manager = await import('@/lib/server/connectors/manager')
+    const wasRunning = manager.getConnectorStatus(id) === 'running'
+    const shouldStop = body.isEnabled === false
+    const shouldReload = wasRunning && (
+      body.name !== undefined
+      || body.agentId !== undefined
+      || body.chatroomId !== undefined
+      || body.credentialId !== undefined
+      || body.config !== undefined
+      || body.isEnabled !== undefined
+    )
+    const shouldStart = body.isEnabled === true && !wasRunning
+
+    if (shouldStop) {
+      await manager.stopConnector(id)
+    } else if (shouldReload || shouldStart) {
+      manager.clearReconnectState(id)
+      await manager.startConnector(id)
+    }
+  } catch {
+    // Keep the saved connector update even if the runtime reload fails.
+  }
+
   notify('connectors')
-  return NextResponse.json(connector)
+  return NextResponse.json(loadConnectors()[id] || connector)
 }
 
 export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {

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

@@ -2,19 +2,26 @@ import { NextResponse } from 'next/server'
 import { genId } from '@/lib/id'
 import { loadConnectors, saveConnectors } from '@/lib/server/storage'
 import { notify } from '@/lib/server/ws-hub'
+import { ensureDaemonStarted } from '@/lib/server/daemon-state'
 import { ConnectorCreateSchema, formatZodError } from '@/lib/validation/schemas'
 import { z } from 'zod'
 import type { Connector } from '@/types'
 export const dynamic = 'force-dynamic'
 
 
-export async function GET(_req: Request) {
+export async function GET() {
+  ensureDaemonStarted('api/connectors:get')
   const connectors = loadConnectors()
   // Merge runtime status from manager
   try {
     const { getConnectorStatus, isConnectorAuthenticated, hasConnectorCredentials, getConnectorQR, getReconnectState } = await import('@/lib/server/connectors/manager')
     for (const c of Object.values(connectors) as Connector[]) {
-      c.status = getConnectorStatus(c.id)
+      const runtimeStatus = getConnectorStatus(c.id)
+      c.status = runtimeStatus === 'running'
+        ? 'running'
+        : c.lastError
+          ? 'error'
+          : 'stopped'
       if (c.platform === 'whatsapp') {
         c.authenticated = isConnectorAuthenticated(c.id)
         c.hasCredentials = hasConnectorCredentials(c.id)
@@ -28,6 +35,7 @@ export async function GET(_req: Request) {
         ext.reconnectAttempts = rState.attempts
         ext.nextRetryAt = rState.nextRetryAt
         ext.reconnectError = rState.error
+        ext.reconnectExhausted = rState.exhausted
       }
     }
   } catch { /* manager not loaded yet */ }
@@ -35,6 +43,7 @@ export async function GET(_req: Request) {
 }
 
 export async function POST(req: Request) {
+  ensureDaemonStarted('api/connectors:post')
   const raw = await req.json()
   const parsed = ConnectorCreateSchema.safeParse(raw)
   if (!parsed.success) {
@@ -72,13 +81,8 @@ export async function POST(req: Request) {
     try {
       const { startConnector } = await import('@/lib/server/connectors/manager')
       await startConnector(id)
-      connector.isEnabled = true
-      connector.status = 'running'
-      connectors[id] = connector
-      saveConnectors(connectors)
-      notify('connectors')
     } catch { /* auto-start is best-effort */ }
   }
 
-  return NextResponse.json(connector)
+  return NextResponse.json(loadConnectors()[id] || connector)
 }

package/src/app/api/external-agents/route.test.ts

@@ -0,0 +1,165 @@
+import assert from 'node:assert/strict'
+import test, { afterEach } from 'node:test'
+
+import { GET as listExternalAgents, POST as registerExternalAgent } from './route'
+import { POST as heartbeatExternalAgent } from './[id]/heartbeat/route'
+import { PUT as mutateExternalAgent, DELETE as deleteExternalAgent } from './[id]/route'
+import {
+  loadExternalAgents,
+  loadGatewayProfiles,
+  saveExternalAgents,
+  saveGatewayProfiles,
+} from '@/lib/server/storage'
+
+const originalExternalAgents = loadExternalAgents()
+const originalGatewayProfiles = loadGatewayProfiles()
+
+function routeParams(id: string) {
+  return { params: Promise.resolve({ id }) }
+}
+
+afterEach(() => {
+  saveExternalAgents(originalExternalAgents)
+  saveGatewayProfiles(originalGatewayProfiles)
+})
+
+test('external agent register + heartbeat derives gateway metadata in listing', async () => {
+  const gateways = loadGatewayProfiles()
+  gateways['gateway-ext-test'] = {
+    id: 'gateway-ext-test',
+    name: 'Gateway Test',
+    provider: 'openclaw',
+    endpoint: 'http://127.0.0.1:19999/v1',
+    wsUrl: 'ws://127.0.0.1:19999',
+    credentialId: null,
+    status: 'healthy',
+    notes: null,
+    tags: ['lan-remote', 'smoke'],
+    lastError: null,
+    lastCheckedAt: null,
+    lastModelCount: 1,
+    discoveredHost: '127.0.0.1',
+    discoveredPort: 19999,
+    deployment: {
+      method: 'imported',
+      managedBy: 'external',
+      useCase: 'single-vps',
+      exposure: 'private-lan',
+      targetHost: '127.0.0.1',
+    },
+    stats: null,
+    isDefault: false,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  }
+  saveGatewayProfiles(gateways)
+
+  const registerResponse = await registerExternalAgent(new Request('http://local/api/external-agents/register', {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({
+      id: 'runtime-ext-test',
+      name: 'External Runtime',
+      sourceType: 'openclaw',
+      transport: 'gateway',
+      endpoint: 'http://127.0.0.1:19999/v1',
+      agentId: 'agent-ext-test',
+      gatewayProfileId: 'gateway-ext-test',
+    }),
+  }))
+  assert.equal(registerResponse.status, 200)
+
+  const heartbeatResponse = await heartbeatExternalAgent(new Request('http://local/api/external-agents/runtime-ext-test/heartbeat', {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({
+      status: 'online',
+      lastHealthNote: 'Heartbeat OK',
+      version: '1.2.3',
+      tokenStats: { inputTokens: 5, outputTokens: 7, totalTokens: 12 },
+    }),
+  }), routeParams('runtime-ext-test'))
+  assert.equal(heartbeatResponse.status, 200)
+
+  const listResponse = await listExternalAgents()
+  assert.equal(listResponse.status, 200)
+  const listPayload = await listResponse.json() as Array<Record<string, unknown>>
+  const runtime = listPayload.find((item) => item.id === 'runtime-ext-test')
+
+  assert.ok(runtime)
+  assert.equal(runtime?.status, 'online')
+  assert.equal(runtime?.gatewayUseCase, 'single-vps')
+  assert.deepEqual(runtime?.gatewayTags, ['lan-remote', 'smoke'])
+  assert.equal(runtime?.lastHealthNote, 'Heartbeat OK')
+  assert.equal((runtime?.tokenStats as { totalTokens?: number } | undefined)?.totalTokens, 12)
+})
+
+test('external agent lifecycle actions update state and delete removes the runtime', async () => {
+  const items = loadExternalAgents()
+  items['runtime-lifecycle-test'] = {
+    id: 'runtime-lifecycle-test',
+    name: 'Lifecycle Runtime',
+    sourceType: 'openclaw',
+    status: 'online',
+    provider: 'openclaw',
+    model: 'default',
+    workspace: null,
+    transport: 'gateway',
+    endpoint: 'http://127.0.0.1:18888/v1',
+    agentId: 'agent-lifecycle-test',
+    gatewayProfileId: null,
+    capabilities: [],
+    labels: [],
+    lifecycleState: 'active',
+    gatewayTags: [],
+    gatewayUseCase: null,
+    version: null,
+    lastHealthNote: null,
+    metadata: null,
+    tokenStats: null,
+    lastHeartbeatAt: Date.now(),
+    lastSeenAt: Date.now(),
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  }
+  saveExternalAgents(items)
+
+  const drainResponse = await mutateExternalAgent(new Request('http://local/api/external-agents/runtime-lifecycle-test', {
+    method: 'PUT',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ action: 'drain' }),
+  }), routeParams('runtime-lifecycle-test'))
+  const drainPayload = await drainResponse.json() as Record<string, unknown>
+  assert.equal(drainPayload.lifecycleState, 'draining')
+
+  const cordonResponse = await mutateExternalAgent(new Request('http://local/api/external-agents/runtime-lifecycle-test', {
+    method: 'PUT',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ action: 'cordon' }),
+  }), routeParams('runtime-lifecycle-test'))
+  const cordonPayload = await cordonResponse.json() as Record<string, unknown>
+  assert.equal(cordonPayload.lifecycleState, 'cordoned')
+
+  const restartResponse = await mutateExternalAgent(new Request('http://local/api/external-agents/runtime-lifecycle-test', {
+    method: 'PUT',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ action: 'restart' }),
+  }), routeParams('runtime-lifecycle-test'))
+  const restartPayload = await restartResponse.json() as Record<string, unknown>
+  assert.equal((restartPayload.metadata as { controlRequest?: { action?: string } } | undefined)?.controlRequest?.action, 'restart')
+
+  const activateResponse = await mutateExternalAgent(new Request('http://local/api/external-agents/runtime-lifecycle-test', {
+    method: 'PUT',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ action: 'activate' }),
+  }), routeParams('runtime-lifecycle-test'))
+  const activatePayload = await activateResponse.json() as Record<string, unknown>
+  assert.equal(activatePayload.lifecycleState, 'active')
+
+  const deleteResponse = await deleteExternalAgent(
+    new Request('http://local/api/external-agents/runtime-lifecycle-test', { method: 'DELETE' }),
+    routeParams('runtime-lifecycle-test'),
+  )
+  assert.equal(deleteResponse.status, 200)
+  assert.equal(loadExternalAgents()['runtime-lifecycle-test'], undefined)
+})

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

@@ -3,34 +3,49 @@ import { probeOpenClawHealth } from '@/lib/server/openclaw-health'
 import { loadGatewayProfiles, saveGatewayProfiles } 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 async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
-  const { id } = await params
+export function persistGatewayHealthResult(
+  id: string,
+  result: OpenClawHealthResult,
+  now = Date.now(),
+): GatewayProfile | null {
   const gateways = loadGatewayProfiles()
   const gateway = gateways[id]
-  if (!gateway) return notFound()
-
-  const result = await probeOpenClawHealth({
-    endpoint: gateway.endpoint,
-    credentialId: gateway.credentialId || null,
-  })
+  if (!gateway) return null
 
   gateway.status = result.ok ? 'healthy' : (result.authProvided ? 'degraded' : 'offline')
-  gateway.lastCheckedAt = Date.now()
+  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: Date.now(),
+    lastVerifiedAt: now,
     lastVerifiedOk: result.ok,
     lastVerifiedMessage: result.ok
-      ? `Verified ${Array.isArray(result.models) ? result.models.length : 0} model${result.models?.length === 1 ? '' : 's'}`
+      ? result.message
       : (result.error || result.hint || 'Gateway health check failed.'),
   }
-  gateway.updatedAt = Date.now()
+  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()
+  const gateway = gateways[id]
+  if (!gateway) return notFound()
+
+  const result = await probeOpenClawHealth({
+    endpoint: gateway.endpoint,
+    credentialId: gateway.credentialId || null,
+  })
+
+  persistGatewayHealthResult(id, result)
 
   return NextResponse.json(result)
 }

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

@@ -35,6 +35,8 @@ function normalizeDeployment(value: unknown): OpenClawDeploymentConfig | null {
     useCase: normalizeText(deployment.useCase) as OpenClawDeploymentConfig['useCase'],
     exposure: normalizeText(deployment.exposure) as OpenClawDeploymentConfig['exposure'],
     managedBy: normalizeText(deployment.managedBy) as OpenClawDeploymentConfig['managedBy'],
+    localInstanceId: normalizeText(deployment.localInstanceId),
+    localPort: normalizeNullableNumber(deployment.localPort),
     targetHost: normalizeText(deployment.targetHost),
     sshHost: normalizeText(deployment.sshHost),
     sshUser: normalizeText(deployment.sshUser),