@swarmclawai/swarmclaw 0.6.4 → 0.6.7

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

@@ -1,5 +1,5 @@
 import { NextResponse } from 'next/server'
-import { loadChatrooms, saveChatrooms, loadAgents } from '@/lib/server/storage'
+import { loadChatrooms, saveChatrooms, loadAgents, loadConnectors, saveConnectors } from '@/lib/server/storage'
 import { notify } from '@/lib/server/ws-hub'
 import { notFound } from '@/lib/server/collection-helpers'
 import { genId } from '@/lib/id'
@@ -21,16 +21,33 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
 
   if (body.name !== undefined) chatroom.name = body.name
   if (body.description !== undefined) chatroom.description = body.description
+  if (body.chatMode !== undefined) {
+    chatroom.chatMode = body.chatMode === 'parallel' ? 'parallel' : 'sequential'
+  }
+  if (body.autoAddress !== undefined) {
+    chatroom.autoAddress = Boolean(body.autoAddress)
+  }
+  if (body.routingRules !== undefined) {
+    chatroom.routingRules = Array.isArray(body.routingRules) ? body.routingRules : undefined
+  }
 
   // Diff agentIds and inject join/leave system messages
   if (Array.isArray(body.agentIds)) {
+    const agents = loadAgents()
+    const invalidAgentIds = (body.agentIds as string[]).filter((agentId) => !agents[agentId])
+    if (invalidAgentIds.length > 0) {
+      return NextResponse.json(
+        { error: `Unknown chatroom member(s): ${invalidAgentIds.join(', ')}` },
+        { status: 400 },
+      )
+    }
+
     const oldIds = new Set(chatroom.agentIds)
     const newIds = new Set(body.agentIds as string[])
     const added = (body.agentIds as string[]).filter((aid: string) => !oldIds.has(aid))
     const removed = chatroom.agentIds.filter((aid: string) => !newIds.has(aid))
 
     if (added.length > 0 || removed.length > 0) {
-      const agents = loadAgents()
       if (!Array.isArray(chatroom.messages)) chatroom.messages = []
       const now = Date.now()
       let offset = 0
@@ -77,6 +94,21 @@ export async function DELETE(_req: Request, { params }: { params: Promise<{ id:
   const chatrooms = loadChatrooms()
   if (!chatrooms[id]) return notFound()
 
+  // Cascade: null out chatroomId on any connectors that reference this chatroom
+  const connectors = loadConnectors()
+  let connectorsDirty = false
+  for (const connector of Object.values(connectors)) {
+    if (connector.chatroomId === id) {
+      connector.chatroomId = null
+      connector.updatedAt = Date.now()
+      connectorsDirty = true
+    }
+  }
+  if (connectorsDirty) {
+    saveConnectors(connectors)
+    notify('connectors')
+  }
+
   delete chatrooms[id]
   saveChatrooms(chatrooms)
   notify('chatrooms')

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

@@ -2,6 +2,8 @@ import { NextResponse } from 'next/server'
 import { genId } from '@/lib/id'
 import { loadChatrooms, saveChatrooms, loadAgents } from '@/lib/server/storage'
 import { notify } from '@/lib/server/ws-hub'
+import { ChatroomCreateSchema, formatZodError } from '@/lib/validation/schemas'
+import { z } from 'zod'
 import type { Chatroom, ChatroomMessage } from '@/types'
 
 export const dynamic = 'force-dynamic'
@@ -12,15 +14,31 @@ export async function GET() {
 }
 
 export async function POST(req: Request) {
-  const body = await req.json()
+  const raw = await req.json()
+  const parsed = ChatroomCreateSchema.safeParse(raw)
+  if (!parsed.success) {
+    return NextResponse.json(formatZodError(parsed.error as z.ZodError), { status: 400 })
+  }
+  const body = parsed.data
   const chatrooms = loadChatrooms()
   const id = genId()
 
-  const agentIds: string[] = Array.isArray(body.agentIds) ? body.agentIds : []
+  const requestedAgentIds: string[] = body.agentIds
+  const knownAgents = loadAgents()
+  const invalidAgentIds = requestedAgentIds.filter((agentId) => !knownAgents[agentId])
+  if (invalidAgentIds.length > 0) {
+    return NextResponse.json(
+      { error: `Unknown chatroom member(s): ${invalidAgentIds.join(', ')}` },
+      { status: 400 },
+    )
+  }
+  const agentIds: string[] = requestedAgentIds
+  const chatMode = body.chatMode === 'parallel' ? 'parallel' : 'sequential'
+  const autoAddress = Boolean(body.autoAddress)
   const now = Date.now()
 
   // Generate join messages for initial agents
-  const agents = agentIds.length > 0 ? loadAgents() : {}
+  const agents = agentIds.length > 0 ? knownAgents : {}
   const joinMessages: ChatroomMessage[] = agentIds.map((agentId: string, i: number) => ({
     id: genId(),
     senderId: 'system',
@@ -38,6 +56,11 @@ export async function POST(req: Request) {
     description: body.description || '',
     agentIds,
     messages: joinMessages,
+    chatMode,
+    autoAddress,
+    ...(Array.isArray(body.routingRules) && body.routingRules.length > 0
+      ? { routingRules: body.routingRules }
+      : {}),
     createdAt: now,
     updatedAt: now,
   }

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

@@ -0,0 +1,64 @@
+import { NextResponse } from 'next/server'
+import { loadConnectors, loadConnectorHealth } from '@/lib/server/storage'
+import { notFound } from '@/lib/server/collection-helpers'
+import type { ConnectorHealthEvent } from '@/types'
+
+export async function GET(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const connectors = loadConnectors()
+  if (!connectors[id]) return notFound()
+
+  const url = new URL(req.url)
+  const since = url.searchParams.get('since')
+
+  const allHealth = loadConnectorHealth()
+  const events: ConnectorHealthEvent[] = []
+
+  for (const raw of Object.values(allHealth)) {
+    const entry = raw as ConnectorHealthEvent
+    if (entry.connectorId !== id) continue
+    if (since && entry.timestamp < since) continue
+    events.push(entry)
+  }
+
+  // Sort by timestamp ascending
+  events.sort((a, b) => a.timestamp.localeCompare(b.timestamp))
+
+  // Compute uptime percentage
+  const uptimePercent = computeUptime(events)
+
+  return NextResponse.json({ events, uptimePercent })
+}
+
+function computeUptime(events: ConnectorHealthEvent[]): number {
+  if (events.length === 0) return 0
+
+  const firstTime = new Date(events[0].timestamp).getTime()
+  const now = Date.now()
+  const totalMs = now - firstTime
+  if (totalMs <= 0) return 100
+
+  let uptimeMs = 0
+  let lastUpAt: number | null = null
+
+  for (const ev of events) {
+    const t = new Date(ev.timestamp).getTime()
+    if (ev.event === 'started' || ev.event === 'reconnected') {
+      if (lastUpAt === null) {
+        lastUpAt = t
+      }
+    } else if (ev.event === 'stopped' || ev.event === 'error' || ev.event === 'disconnected') {
+      if (lastUpAt !== null) {
+        uptimeMs += t - lastUpAt
+        lastUpAt = null
+      }
+    }
+  }
+
+  // If still up, count time until now
+  if (lastUpAt !== null) {
+    uptimeMs += now - lastUpAt
+  }
+
+  return Math.round((uptimeMs / totalMs) * 10000) / 100
+}

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

@@ -2,6 +2,8 @@ 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 { ConnectorCreateSchema, formatZodError } from '@/lib/validation/schemas'
+import { z } from 'zod'
 import type { Connector } from '@/types'
 export const dynamic = 'force-dynamic'
 
@@ -10,7 +12,7 @@ export async function GET(_req: Request) {
   const connectors = loadConnectors()
   // Merge runtime status from manager
   try {
-    const { getConnectorStatus, isConnectorAuthenticated, hasConnectorCredentials, getConnectorQR } = await import('@/lib/server/connectors/manager')
+    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)
       if (c.platform === 'whatsapp') {
@@ -19,13 +21,26 @@ export async function GET(_req: Request) {
         const qr = getConnectorQR(c.id)
         if (qr) c.qrDataUrl = qr
       }
+      // Surface reconnect state if connector is in a recovery cycle
+      const rState = getReconnectState(c.id)
+      if (rState) {
+        const ext = c as unknown as Record<string, unknown>
+        ext.reconnectAttempts = rState.attempts
+        ext.nextRetryAt = rState.nextRetryAt
+        ext.reconnectError = rState.error
+      }
     }
   } catch { /* manager not loaded yet */ }
   return NextResponse.json(connectors)
 }
 
 export async function POST(req: Request) {
-  const body = await req.json()
+  const raw = await req.json()
+  const parsed = ConnectorCreateSchema.safeParse(raw)
+  if (!parsed.success) {
+    return NextResponse.json(formatZodError(parsed.error as z.ZodError), { status: 400 })
+  }
+  const body = parsed.data
   const connectors = loadConnectors()
   const id = genId()
 

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

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

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

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

package/src/app/api/schedules/[id]/run/route.ts

@@ -53,7 +53,10 @@ export async function POST(_req: Request, { params }: { params: Promise<{ id: st
     existingTask.title = `[Sched] ${schedule.name} (run #${schedule.runNumber})`
     existingTask.result = null
     existingTask.error = null
+    existingTask.outputFiles = []
+    existingTask.artifacts = []
     existingTask.sessionId = null
+    existingTask.completionReportPath = null
     existingTask.updatedAt = now
     existingTask.queuedAt = null
     existingTask.startedAt = null

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,62 @@
+import { NextResponse } from 'next/server'
+import { loadWallets, loadWalletTransactions, upsertWalletTransaction } from '@/lib/server/storage'
+import { sendSol } from '@/lib/server/solana'
+import { notify } from '@/lib/server/ws-hub'
+import type { AgentWallet, WalletTransaction } from '@/types'
+export const dynamic = 'force-dynamic'
+
+export async function POST(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 body = await req.json()
+  const transactionId = typeof body.transactionId === 'string' ? body.transactionId.trim() : ''
+  const decision = body.decision as 'approve' | 'deny'
+
+  if (!transactionId) {
+    return NextResponse.json({ error: 'transactionId is required' }, { status: 400 })
+  }
+  if (decision !== 'approve' && decision !== 'deny') {
+    return NextResponse.json({ error: 'decision must be "approve" or "deny"' }, { status: 400 })
+  }
+
+  const allTxs = loadWalletTransactions() as Record<string, WalletTransaction>
+  const tx = allTxs[transactionId]
+  if (!tx || tx.walletId !== id) {
+    return NextResponse.json({ error: 'Transaction not found' }, { status: 404 })
+  }
+  if (tx.status !== 'pending_approval') {
+    return NextResponse.json({ error: `Transaction is already ${tx.status}` }, { status: 409 })
+  }
+
+  if (decision === 'deny') {
+    tx.status = 'denied'
+    tx.approvedBy = 'user'
+    upsertWalletTransaction(transactionId, tx)
+    notify('wallets')
+    return NextResponse.json({ status: 'denied', transactionId })
+  }
+
+  // Approve — sign and submit
+  try {
+    const { signature, fee } = await sendSol(wallet.encryptedPrivateKey, tx.toAddress, tx.amountLamports)
+    tx.status = 'confirmed'
+    tx.signature = signature
+    tx.feeLamports = fee
+    tx.approvedBy = 'user'
+    upsertWalletTransaction(transactionId, tx)
+    notify('wallets')
+    return NextResponse.json({ status: 'confirmed', transactionId, signature })
+  } catch (err: unknown) {
+    tx.status = 'failed'
+    upsertWalletTransaction(transactionId, tx)
+    notify('wallets')
+    return NextResponse.json({
+      error: err instanceof Error ? err.message : String(err),
+      transactionId,
+      status: 'failed',
+    }, { status: 500 })
+  }
+}

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

@@ -0,0 +1,18 @@
+import { NextResponse } from 'next/server'
+import { loadWallets, loadWalletBalanceHistory } from '@/lib/server/storage'
+import type { AgentWallet, WalletBalanceSnapshot } from '@/types'
+export const dynamic = 'force-dynamic'
+
+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]
+  if (!wallet) return NextResponse.json({ error: 'Wallet not found' }, { status: 404 })
+
+  const allSnapshots = loadWalletBalanceHistory() as Record<string, WalletBalanceSnapshot>
+  const walletSnapshots = Object.values(allSnapshots)
+    .filter((s) => s.walletId === id)
+    .sort((a, b) => a.timestamp - b.timestamp)
+
+  return NextResponse.json(walletSnapshots)
+}