@swarmclawai/swarmclaw 1.2.6 → 1.2.9

package/src/app/api/chats/messages-route.test.ts

@@ -3,65 +3,119 @@ import test from 'node:test'
 
 import { runWithTempDataDir } from '@/lib/server/test-utils/run-with-temp-data-dir'
 
-test('chat messages route materializes stale streaming artifacts even if runtime memory is stale', () => {
+test('messages route serves and mutates repo-backed transcript history', () => {
   const output = runWithTempDataDir<{
-    status: number
-    returnedStreaming: boolean | null
-    returnedText: string | null
-    persistedStreaming: boolean | null
-    persistedText: string | null
-	  }>(`
-	    const storageMod = await import('./src/lib/server/storage')
-	    const routeMod = await import('./src/app/api/chats/[id]/messages/route')
-	    const runtimeStateMod = await import('./src/lib/server/runtime/runtime-state')
-	    const storage = storageMod.default || storageMod
-	    const route = routeMod.default || routeMod
-	    const runtimeState = runtimeStateMod.default || runtimeStateMod
+    fullCount: number
+    paginatedTexts: string[]
+    paginatedStartIndex: number
+    paginatedTotal: number
+    bookmarkPersisted: boolean
+    contextClearCountAfterPost: number
+    finalKinds: Array<string | null>
+    finalBookmarked: boolean
+    blobMessageCount: number
+  }>(`
+    const storageMod = await import('./src/lib/server/storage')
+    const repoMod = await import('@/lib/server/messages/message-repository')
+    const routeMod = await import('./src/app/api/chats/[id]/messages/route')
+    const storage = storageMod.default || storageMod
+    const repo = repoMod.default || repoMod
+    const route = routeMod.default || routeMod
 
-    storage.upsertStoredItem('sessions', 'session-stale', {
-      id: 'session-stale',
-      name: 'Stale session',
-      provider: 'ollama',
-      model: 'test-model',
-      createdAt: 1,
-      updatedAt: 1,
-      active: false,
-      currentRunId: null,
-      messages: [
-        { role: 'user', text: 'hello', time: 1 },
-        {
-          role: 'assistant',
-          text: 'partial reply',
-          time: 2,
-          streaming: true,
-          toolEvents: [{ name: 'http_request', input: '{}', output: '{"ok":true}' }],
-        },
-      ],
+    const now = Date.now()
+    storage.saveSessions({
+      sess_1: {
+        id: 'sess_1',
+        name: 'Repo-backed session',
+        cwd: process.env.WORKSPACE_DIR,
+        user: 'tester',
+        provider: 'openai',
+        model: 'gpt-5',
+        claudeSessionId: null,
+        codexThreadId: null,
+        opencodeSessionId: null,
+        delegateResumeIds: { claudeCode: null, codex: null, opencode: null, gemini: null },
+        messages: [],
+        createdAt: now,
+        lastActiveAt: now,
+      },
     })
 
-	    runtimeState.registerActiveSessionProcess('session-stale', { kill() {} })
+    repo.appendMessage('sess_1', { role: 'user', text: 'hello', time: now })
+    repo.appendMessage('sess_1', { role: 'user', text: '', kind: 'context-clear', time: now + 1 })
+    repo.appendMessage('sess_1', { role: 'assistant', text: 'welcome back', time: now + 2 })
+    storage.patchSession('sess_1', (current) => {
+      if (!current) return null
+      current.messages = [{ role: 'assistant', text: 'stale blob only', time: now - 10 }]
+      return current
+    })
+
+    const fullResponse = await route.GET(
+      new Request('http://local/api/chats/sess_1/messages'),
+      { params: Promise.resolve({ id: 'sess_1' }) },
+    )
+    const fullMessages = await fullResponse.json()
 
-    const response = await route.GET(
-      new Request('http://local/api/chats/session-stale/messages'),
-      { params: Promise.resolve({ id: 'session-stale' }) },
+    const paginatedResponse = await route.GET(
+      new Request('http://local/api/chats/sess_1/messages?limit=2'),
+      { params: Promise.resolve({ id: 'sess_1' }) },
     )
-    const payload = await response.json()
-    const persisted = storage.loadSession('session-stale')
-    const returned = Array.isArray(payload) ? payload[payload.length - 1] : null
-    const saved = Array.isArray(persisted?.messages) ? persisted.messages[persisted.messages.length - 1] : null
+    const paginated = await paginatedResponse.json()
+
+    const bookmarkResponse = await route.PUT(
+      new Request('http://local/api/chats/sess_1/messages', {
+        method: 'PUT',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ messageIndex: 2, bookmarked: true }),
+      }),
+      { params: Promise.resolve({ id: 'sess_1' }) },
+    )
+    const bookmarked = await bookmarkResponse.json()
+
+    await route.POST(
+      new Request('http://local/api/chats/sess_1/messages', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ kind: 'context-clear' }),
+      }),
+      { params: Promise.resolve({ id: 'sess_1' }) },
+    )
+
+    const afterPost = repo.getMessages('sess_1')
+    const contextClearCountAfterPost = afterPost.filter((message) => message.kind === 'context-clear').length
+
+    await route.DELETE(
+      new Request('http://local/api/chats/sess_1/messages', {
+        method: 'DELETE',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ messageIndex: 1 }),
+      }),
+      { params: Promise.resolve({ id: 'sess_1' }) },
+    )
+
+    const finalMessages = repo.getMessages('sess_1')
+    const sessions = storage.loadSessions()
 
     console.log(JSON.stringify({
-      status: response.status,
-      returnedStreaming: returned?.streaming === true,
-      returnedText: returned?.text || null,
-      persistedStreaming: saved?.streaming === true,
-      persistedText: saved?.text || null,
+      fullCount: fullMessages.length,
+      paginatedTexts: paginated.messages.map((message) => message.text),
+      paginatedStartIndex: paginated.startIndex,
+      paginatedTotal: paginated.total,
+      bookmarkPersisted: bookmarked.bookmarked === true,
+      contextClearCountAfterPost,
+      finalKinds: finalMessages.map((message) => message.kind || null),
+      finalBookmarked: finalMessages[1]?.bookmarked === true,
+      blobMessageCount: Array.isArray(sessions.sess_1.messages) ? sessions.sess_1.messages.length : -1,
     }))
-  `, { prefix: 'swarmclaw-chat-messages-route-' })
+  `, { prefix: 'swarmclaw-messages-route-' })
 
-  assert.equal(output.status, 200)
-  assert.equal(output.returnedStreaming, false)
-  assert.equal(output.persistedStreaming, false)
-  assert.equal(output.returnedText, 'partial reply')
-  assert.equal(output.persistedText, 'partial reply')
+  assert.equal(output.fullCount, 3)
+  assert.deepEqual(output.paginatedTexts, ['', 'welcome back'])
+  assert.equal(output.paginatedStartIndex, 1)
+  assert.equal(output.paginatedTotal, 3)
+  assert.equal(output.bookmarkPersisted, true)
+  assert.equal(output.contextClearCountAfterPost, 2)
+  assert.deepEqual(output.finalKinds, [null, null, 'context-clear'])
+  assert.equal(output.finalBookmarked, true)
+  assert.equal(output.blobMessageCount, 1)
 })

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

@@ -6,10 +6,10 @@ import { z } from 'zod'
 import {
   autoStartConnectorIfNeeded,
   createConnector,
+  getConnectorWithRuntime,
   listConnectorsWithRuntime,
 } from '@/lib/server/connectors/connector-service'
 import { ensureDaemonProcessRunning } from '@/lib/server/daemon/controller'
-import { loadConnector } from '@/lib/server/connectors/connector-repository'
 export const dynamic = 'force-dynamic'
 
 export async function GET() {
@@ -29,5 +29,5 @@ export async function POST(req: Request) {
   }
   const connector = createConnector(parsed.data as unknown as Record<string, unknown>)
   await autoStartConnectorIfNeeded(connector, parsed.data as unknown as Record<string, unknown>)
-  return NextResponse.json(loadConnector(connector.id) || connector)
+  return NextResponse.json(await getConnectorWithRuntime(connector.id) || connector)
 }

package/src/app/api/mcp-servers/[id]/test/route.ts

@@ -2,6 +2,7 @@ import { NextResponse } from 'next/server'
 import { loadMcpServers } from '@/lib/server/storage'
 import { notFound } from '@/lib/server/collection-helpers'
 import { connectMcpServer, mcpToolsToLangChain, disconnectMcpServer } from '@/lib/server/mcp-client'
+import { errorMessage } from '@/lib/shared-utils'
 
 export async function POST(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
@@ -15,9 +16,9 @@ export async function POST(_req: Request, { params }: { params: Promise<{ id: st
     const toolNames = tools.map((t: any) => t.name)
     await disconnectMcpServer(client, transport)
     return NextResponse.json({ ok: true, tools: toolNames })
-  } catch (err: any) {
+  } catch (err: unknown) {
     return NextResponse.json(
-      { ok: false, error: err.message || 'Connection failed' },
+      { ok: false, error: errorMessage(err) || 'Connection failed' },
       { status: 500 }
     )
   }

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

@@ -129,6 +129,7 @@ export async function POST(req: Request) {
         locals: result.locals,
         localPrimaryId: result.locals.find((item) => item.isPrimary)?.id || result.local.id,
         token: result.token,
+        gatewayProfileId: result.gatewayProfileId,
       })
     }
 
@@ -156,6 +157,7 @@ export async function POST(req: Request) {
         locals: result.locals,
         localPrimaryId: result.locals.find((item) => item.isPrimary)?.id || result.local.id,
         token: result.token,
+        gatewayProfileId: result.gatewayProfileId,
       })
     }
 

package/src/app/api/portability/export/route.ts

@@ -0,0 +1,8 @@
+import { NextResponse } from 'next/server'
+import { exportConfig } from '@/lib/server/portability/export'
+export const dynamic = 'force-dynamic'
+
+export async function GET() {
+  const manifest = exportConfig()
+  return NextResponse.json(manifest)
+}

package/src/app/api/portability/import/route.test.ts

@@ -0,0 +1,80 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import test from 'node:test'
+
+const repoRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../../../..')
+
+function runWithTempDataDir(script: string) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-portability-import-'))
+  try {
+    const result = spawnSync(process.execPath, ['--import', 'tsx', '--input-type=module', '--eval', script], {
+      cwd: repoRoot,
+      env: {
+        ...process.env,
+        DATA_DIR: path.join(tempDir, 'data'),
+        WORKSPACE_DIR: path.join(tempDir, 'workspace'),
+      },
+      encoding: 'utf-8',
+    })
+    assert.equal(result.status, 0, result.stderr || result.stdout || 'subprocess failed')
+    const lines = (result.stdout || '')
+      .trim()
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+    const jsonLine = [...lines].reverse().find((line) => line.startsWith('{'))
+    return JSON.parse(jsonLine || '{}')
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  }
+}
+
+test('POST /api/portability/import validates manifest arrays before importing', () => {
+  const output = runWithTempDataDir(`
+    const routeMod = await import('./src/app/api/portability/import/route')
+    const route = routeMod.default || routeMod
+
+    const invalidResponse = await route.POST(new Request('http://local/api/portability/import', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ formatVersion: 1, agents: [] }),
+    }))
+    const invalidPayload = await invalidResponse.json()
+
+    const validResponse = await route.POST(new Request('http://local/api/portability/import', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        formatVersion: 1,
+        exportedAt: '2026-03-29T00:00:00.000Z',
+        agents: [],
+        skills: [],
+        schedules: [],
+      }),
+    }))
+    const validPayload = await validResponse.json()
+
+    console.log(JSON.stringify({
+      invalidStatus: invalidResponse.status,
+      invalidError: invalidPayload?.error || null,
+      invalidPaths: Array.isArray(invalidPayload?.issues)
+        ? invalidPayload.issues.map((issue) => issue.path).sort()
+        : [],
+      validStatus: validResponse.status,
+      validAgentsCreated: validPayload?.agents?.created ?? null,
+      validSkillsCreated: validPayload?.skills?.created ?? null,
+      validSchedulesCreated: validPayload?.schedules?.created ?? null,
+    }))
+  `)
+
+  assert.equal(output.invalidStatus, 400)
+  assert.equal(output.invalidError, 'Validation failed')
+  assert.deepEqual(output.invalidPaths, ['schedules', 'skills'])
+  assert.equal(output.validStatus, 200)
+  assert.equal(output.validAgentsCreated, 0)
+  assert.equal(output.validSkillsCreated, 0)
+  assert.equal(output.validSchedulesCreated, 0)
+})

package/src/app/api/portability/import/route.ts

@@ -0,0 +1,28 @@
+import { NextResponse } from 'next/server'
+import { safeParseBody } from '@/lib/server/safe-parse-body'
+import { importConfig } from '@/lib/server/portability/import'
+import type { PortableManifest } from '@/lib/server/portability/export'
+import { PortableManifestSchema, formatZodError } from '@/lib/validation/schemas'
+import { z } from 'zod'
+export const dynamic = 'force-dynamic'
+
+export async function POST(req: Request) {
+  const { data: raw, error } = await safeParseBody(req)
+  if (error) return error
+
+  const parsed = PortableManifestSchema.safeParse(raw)
+  if (!parsed.success) {
+    return NextResponse.json(formatZodError(parsed.error as z.ZodError), { status: 400 })
+  }
+
+  try {
+    const result = importConfig(parsed.data as PortableManifest)
+    return NextResponse.json(result)
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'Failed to import manifest'
+    if (/^Unsupported format version /i.test(message)) {
+      return NextResponse.json({ error: message }, { status: 400 })
+    }
+    return NextResponse.json({ error: message }, { status: 500 })
+  }
+}

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

@@ -141,11 +141,9 @@ export async function PUT(req: Request) {
   settings.taskQualityGateRequireReport = parseBoolSetting(settings.taskQualityGateRequireReport, false)
   settings.taskManagementEnabled = parseBoolSetting(settings.taskManagementEnabled, true)
   settings.projectManagementEnabled = parseBoolSetting(settings.projectManagementEnabled, true)
-  settings.walletApprovalsEnabled = parseBoolSetting(settings.walletApprovalsEnabled, true)
   settings.integrityMonitorEnabled = parseBoolSetting(settings.integrityMonitorEnabled, true)
   settings.daemonAutostartEnabled = parseBoolSetting(settings.daemonAutostartEnabled, true)
   settings.autonomyResumeApprovalsEnabled = parseBoolSetting(settings.autonomyResumeApprovalsEnabled, false)
-  settings.missionHumanLoopEnabled = parseBoolSetting(settings.missionHumanLoopEnabled, false)
   settings.untrustedContentGuardMode = parseGuardMode(settings.untrustedContentGuardMode)
   settings.sessionResetMode = settings.sessionResetMode === 'daily' ? 'daily' : settings.sessionResetMode === 'idle' ? 'idle' : null
   settings.whatsappApprovedContacts = normalizeWhatsAppApprovedContacts(settings.whatsappApprovedContacts)

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

@@ -217,14 +217,14 @@ export async function GET(req: Request) {
   pushCheck(
     checks,
     'docker',
-    'Docker (sandbox runtime)',
+    'Docker (browser sandbox runtime)',
     docker.available ? 'pass' : 'warn',
     docker.available
-      ? `Docker ${docker.version || ''} is available for container sandbox execution.`.trim()
-      : 'Docker is not available. SwarmClaw will fall back to host execution until Docker Desktop is installed.',
+      ? `Docker ${docker.version || ''} is available for sandbox browser execution.`.trim()
+      : 'Docker is not available. SwarmClaw will use the host Playwright runtime unless Docker Desktop is installed.',
   )
   if (!docker.available) {
-    actions.push('Install Docker Desktop if you want shell, browser, and code execution to stay inside containers by default.')
+    actions.push('Install Docker Desktop if you want Playwright browser sessions to use the sandbox browser runtime.')
   }
 
   const gitRootCheck = run('git', ['rev-parse', '--is-inside-work-tree'], 4_000)

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

@@ -1,174 +1,32 @@
 import { NextResponse } from 'next/server'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
-import { loadWallets, upsertWallet, deleteWallet as deleteWalletFromStore, loadAgent, loadAgents, upsertAgent } from '@/lib/server/storage'
-import { notify } from '@/lib/server/ws-hub'
-import { getWalletLimitAtomic, normalizeAtomicString } from '@/lib/wallet/wallet'
-import type { AgentWallet, WalletAssetBalance, WalletPortfolioSummary } from '@/types'
-import { buildEmptyWalletPortfolio, getCachedWalletPortfolio } from '@/lib/server/wallet/wallet-portfolio'
-import {
-  getAgentActiveWalletId,
-  getWalletPortfolioSnapshot,
-  linkWalletToAgent,
-  setAgentActiveWallet,
-  stripWalletPrivateKey,
-  unlinkWalletFromAgent,
-} from '@/lib/server/wallet/wallet-service'
+import { getWalletSafe, removeWallet, updateWallet } from '@/lib/server/wallets/wallet-service'
 export const dynamic = 'force-dynamic'
-const WALLET_DETAIL_PORTFOLIO_TIMEOUT_MS = 2500
 
-function withPortfolio(
-  wallet: AgentWallet,
-  portfolio: {
-    balanceAtomic: string
-    balanceFormatted: string
-    balanceSymbol: string
-    balanceDisplay: string
-    balanceLamports?: number
-    balanceSol?: number
-    assets: WalletAssetBalance[]
-    summary: WalletPortfolioSummary
-  },
-  isActive: boolean,
-) {
-  return {
-    ...stripWalletPrivateKey(wallet as unknown as Record<string, unknown>),
-    balanceAtomic: portfolio.balanceAtomic,
-    balanceFormatted: portfolio.balanceFormatted,
-    balanceSymbol: portfolio.balanceSymbol,
-    balanceDisplay: portfolio.balanceDisplay,
-    balanceLamports: portfolio.balanceLamports,
-    balanceSol: portfolio.balanceSol,
-    assets: portfolio.assets,
-    portfolioSummary: portfolio.summary,
-    isActive,
-  }
-}
-
-export async function GET(req: Request, { params }: { params: Promise<{ id: string }> }) {
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const wallets = loadWallets() as Record<string, AgentWallet>
-  const wallet = wallets[id]
+  const wallet = getWalletSafe(id)
   if (!wallet) return NextResponse.json({ error: 'Wallet not found' }, { status: 404 })
-
-  const url = new URL(req.url)
-  const cachedOnly = url.searchParams.get('cached') === '1'
-  const agents = loadAgents()
-  const isActive = getAgentActiveWalletId(agents[wallet.agentId]) === wallet.id
-
-  if (cachedOnly) {
-    const cached = getCachedWalletPortfolio(wallet)
-    if (!cached) {
-      return NextResponse.json({
-        ...stripWalletPrivateKey(wallet as unknown as Record<string, unknown>),
-        isActive,
-      })
-    }
-    return NextResponse.json(withPortfolio(wallet, cached, isActive))
-  }
-
-  let portfolio = buildEmptyWalletPortfolio(wallet)
-  try {
-    portfolio = await getWalletPortfolioSnapshot(wallet, {
-      timeoutMs: WALLET_DETAIL_PORTFOLIO_TIMEOUT_MS,
-      allowStale: true,
-    })
-  } catch {
-    // RPC failure — return 0
-  }
-
-  return NextResponse.json(withPortfolio(wallet, portfolio, isActive))
+  return NextResponse.json(wallet)
 }
 
 export async function PATCH(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const wallets = loadWallets() as Record<string, AgentWallet>
-  const wallet = wallets[id]
-  if (!wallet) return NextResponse.json({ error: 'Wallet not found' }, { status: 404 })
-
   const { data: body, error } = await safeParseBody(req)
   if (error) return error
-  const shouldMakeActive = body.makeActive === true
-
-  // Reassign wallet to a different agent
-  if (typeof body.agentId === 'string' && body.agentId !== wallet.agentId) {
-    const newAgent = loadAgent(body.agentId)
-    if (!newAgent) return NextResponse.json({ error: 'Agent not found' }, { status: 404 })
-
-    // Only one wallet per chain per agent.
-    const allWallets = loadWallets() as Record<string, AgentWallet>
-    const conflict = Object.values(allWallets).find((w) => w.agentId === body.agentId && w.id !== id && w.chain === wallet.chain)
-    if (conflict) return NextResponse.json({ error: `Target agent already has a ${wallet.chain} wallet` }, { status: 409 })
-
-    const oldAgent = loadAgent(wallet.agentId)
-    if (oldAgent) {
-      unlinkWalletFromAgent(oldAgent as any, id)
-      oldAgent.updatedAt = Date.now()
-      upsertAgent(wallet.agentId, oldAgent)
-    }
-
-    linkWalletToAgent(newAgent as any, id, shouldMakeActive || getAgentActiveWalletId(newAgent as any) == null)
-    newAgent.updatedAt = Date.now()
-    upsertAgent(body.agentId, newAgent)
-    notify('agents')
-
-    wallet.agentId = body.agentId
-  } else if (shouldMakeActive) {
-    const agent = loadAgent(wallet.agentId)
-    if (agent) {
-      setAgentActiveWallet(agent as any, id)
-      agent.updatedAt = Date.now()
-      upsertAgent(wallet.agentId, agent)
-      notify('agents')
-    }
-  }
-
-  if (body.label !== undefined) wallet.label = body.label as string | undefined
-  if (body.spendingLimitAtomic !== undefined || body.spendingLimitLamports !== undefined) {
-    wallet.spendingLimitAtomic = normalizeAtomicString(body.spendingLimitAtomic ?? body.spendingLimitLamports, getWalletLimitAtomic(wallet, 'perTx'))
-  }
-  if (body.dailyLimitAtomic !== undefined || body.dailyLimitLamports !== undefined) {
-    wallet.dailyLimitAtomic = normalizeAtomicString(body.dailyLimitAtomic ?? body.dailyLimitLamports, getWalletLimitAtomic(wallet, 'daily'))
-  }
-  if (typeof body.requireApproval === 'boolean') wallet.requireApproval = body.requireApproval
-  wallet.updatedAt = Date.now()
-
-  upsertWallet(id, wallet)
-  notify('wallets')
-
-  return NextResponse.json(stripWalletPrivateKey(wallet as unknown as Record<string, unknown>))
+  const patch: Record<string, unknown> = {}
+  if (typeof body.label === 'string') patch.label = body.label
+  if (typeof body.spendingLimitUsdc === 'string' || body.spendingLimitUsdc === null) patch.spendingLimitUsdc = body.spendingLimitUsdc
+  if (typeof body.dailyLimitUsdc === 'string' || body.dailyLimitUsdc === null) patch.dailyLimitUsdc = body.dailyLimitUsdc
+  if (typeof body.requireApproval === 'boolean') patch.requireApproval = body.requireApproval
+  const updated = updateWallet(id, patch)
+  if (!updated) return NextResponse.json({ error: 'Wallet not found' }, { status: 404 })
+  return NextResponse.json(updated)
 }
 
 export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const wallets = loadWallets() as Record<string, AgentWallet>
-  const wallet = wallets[id]
-  if (!wallet) return NextResponse.json({ error: 'Wallet not found' }, { status: 404 })
-
-  // Check if balance > 0 and warn
-  let portfolio = buildEmptyWalletPortfolio(wallet)
-  try {
-    portfolio = await getWalletPortfolioSnapshot(wallet, {
-      timeoutMs: WALLET_DETAIL_PORTFOLIO_TIMEOUT_MS,
-      allowStale: true,
-    })
-  } catch { /* ignore */ }
-
-  // Unlink from agent
-  const agent = loadAgent(wallet.agentId)
-  if (agent) {
-    unlinkWalletFromAgent(agent as any, id)
-    agent.updatedAt = Date.now()
-    upsertAgent(wallet.agentId, agent)
-    notify('agents')
-  }
-
-  deleteWalletFromStore(id)
-  notify('wallets')
-
-  return NextResponse.json({
-    ok: true,
-    warning: portfolio.summary.nonZeroAssets > 0
-      ? `Wallet still had ${portfolio.summary.nonZeroAssets} asset${portfolio.summary.nonZeroAssets === 1 ? '' : 's'} remaining, including ${portfolio.balanceDisplay}`
-      : undefined,
-  })
+  const deleted = removeWallet(id)
+  if (!deleted) return NextResponse.json({ error: 'Wallet not found' }, { status: 404 })
+  return NextResponse.json({ ok: true })
 }

package/src/app/api/wallets/generate/route.ts

@@ -0,0 +1,22 @@
+import { NextResponse } from 'next/server'
+import { safeParseBody } from '@/lib/server/safe-parse-body'
+import { generateWallet, WalletServiceError } from '@/lib/server/wallets/wallet-service'
+export const dynamic = 'force-dynamic'
+
+export async function POST(req: Request) {
+  const { data: body, error } = await safeParseBody(req)
+  if (error) return error
+  try {
+    const wallet = await generateWallet({
+      agentId: typeof body.agentId === 'string' ? body.agentId : '',
+      label: typeof body.label === 'string' ? body.label : undefined,
+    })
+    return NextResponse.json(wallet, { status: 201 })
+  } catch (err) {
+    if (err instanceof WalletServiceError) {
+      return NextResponse.json({ error: err.message }, { status: err.status })
+    }
+    const message = err instanceof Error ? err.message : 'Failed to generate wallet'
+    return NextResponse.json({ error: message }, { status: 500 })
+  }
+}