@swarmclawai/swarmclaw 0.7.8 → 0.8.0

package/src/app/api/setup/check-provider/route.test.ts

@@ -0,0 +1,19 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { normalizeOllamaSetupEndpoint } from './route'
+
+test('normalizeOllamaSetupEndpoint strips local /v1 suffixes but preserves cloud endpoints', () => {
+  assert.equal(
+    normalizeOllamaSetupEndpoint('http://localhost:11434/v1', false),
+    'http://localhost:11434',
+  )
+  assert.equal(
+    normalizeOllamaSetupEndpoint('http://localhost:11434/', false),
+    'http://localhost:11434',
+  )
+  assert.equal(
+    normalizeOllamaSetupEndpoint('https://ollama.com/v1', true),
+    'https://ollama.com/v1',
+  )
+})

package/src/app/api/setup/check-provider/route.ts

@@ -2,6 +2,7 @@ import { NextResponse } from 'next/server'
 import { loadCredentials, decryptKey } from '@/lib/server/storage'
 import { getDeviceId, wsConnect } from '@/lib/providers/openclaw'
 import { OPENAI_COMPATIBLE_DEFAULTS } from '@/lib/server/provider-health'
+import { resolveOllamaRuntimeConfig } from '@/lib/server/ollama-runtime'
 
 type SetupProvider =
   | 'openai'
@@ -28,6 +29,12 @@ function clean(value: unknown): string {
   return typeof value === 'string' ? value.trim() : ''
 }
 
+export function normalizeOllamaSetupEndpoint(endpoint: string, useCloud: boolean): string {
+  const normalized = endpoint.replace(/\/+$/, '')
+  if (useCloud) return normalized
+  return normalized.replace(/\/v1$/i, '')
+}
+
 function parseBody(input: unknown): SetupCheckBody {
   if (!input || typeof input !== 'object' || Array.isArray(input)) return {}
   return input as SetupCheckBody
@@ -101,9 +108,28 @@ async function checkAnthropic(apiKey: string, modelRaw: string): Promise<{ ok: b
   return { ok: true, message: text ? `Connected to Anthropic. Sample: ${text.slice(0, 120)}` : 'Connected to Anthropic.' }
 }
 
-async function checkOllama(endpointRaw: string): Promise<{ ok: boolean; message: string; normalizedEndpoint: string; recommendedModel?: string }> {
-  const normalizedEndpoint = (endpointRaw || 'http://localhost:11434').replace(/\/+$/, '')
-  const res = await fetch(`${normalizedEndpoint}/api/tags`, {
+async function checkOllama(params: {
+  endpointRaw: string
+  modelRaw: string
+  apiKey?: string
+}): Promise<{ ok: boolean; message: string; normalizedEndpoint: string; recommendedModel?: string }> {
+  const runtime = resolveOllamaRuntimeConfig({
+    model: params.modelRaw,
+    apiKey: params.apiKey,
+    apiEndpoint: params.endpointRaw,
+  })
+  const normalizedEndpoint = normalizeOllamaSetupEndpoint(runtime.endpoint, runtime.useCloud)
+  const tagsPath = runtime.useCloud ? '/v1/models' : '/api/tags'
+  const headers = runtime.apiKey ? { authorization: `Bearer ${runtime.apiKey}` } : undefined
+  if (runtime.useCloud && !runtime.apiKey) {
+    return {
+      ok: false,
+      message: 'Ollama Cloud model requires an API key. Set OLLAMA_API_KEY or attach an Ollama credential.',
+      normalizedEndpoint,
+    }
+  }
+  const res = await fetch(`${normalizedEndpoint}${tagsPath}`, {
+    headers,
     signal: AbortSignal.timeout(8_000),
     cache: 'no-store',
   })
@@ -112,20 +138,24 @@ async function checkOllama(endpointRaw: string): Promise<{ ok: boolean; message:
     return { ok: false, message: detail, normalizedEndpoint }
   }
   const payload = await res.json().catch(() => ({} as any))
-  const models = Array.isArray(payload?.models) ? payload.models : []
-  const firstModel = typeof models[0]?.name === 'string'
-    ? String(models[0].name).replace(/:latest$/, '')
-    : undefined
+  const models = runtime.useCloud
+    ? (Array.isArray(payload?.data) ? payload.data : [])
+    : (Array.isArray(payload?.models) ? payload.models : [])
+  const firstModel = runtime.useCloud
+    ? (typeof models[0]?.id === 'string' ? String(models[0].id) : undefined)
+    : (typeof models[0]?.name === 'string' ? String(models[0].name).replace(/:latest$/, '') : undefined)
   if (models.length === 0) {
     return {
       ok: true,
-      message: 'Connected to Ollama, but no models are installed yet. Run `ollama pull <model>` to add one.',
+      message: runtime.useCloud
+        ? 'Connected to Ollama Cloud, but no models were returned.'
+        : 'Connected to Ollama, but no models are installed yet. Run `ollama pull <model>` to add one.',
       normalizedEndpoint,
     }
   }
   return {
     ok: true,
-    message: `Connected to Ollama. ${models.length} model(s) available.`,
+    message: `Connected to ${runtime.useCloud ? 'Ollama Cloud' : 'Ollama'}. ${models.length} model(s) available.`,
     normalizedEndpoint,
     recommendedModel: firstModel,
   }
@@ -205,7 +235,7 @@ export async function POST(req: Request) {
         return NextResponse.json(result)
       }
       case 'ollama': {
-        const result = await checkOllama(endpoint)
+        const result = await checkOllama({ endpointRaw: endpoint, modelRaw: model, apiKey })
         return NextResponse.json(result)
       }
       case 'openclaw': {

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

@@ -31,6 +31,18 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
       content: normalized.content,
       sourceUrl: normalized.sourceUrl,
       sourceFormat: normalized.sourceFormat,
+      author: normalized.author ?? skill.author,
+      tags: normalized.tags ?? skill.tags,
+      version: normalized.version ?? null,
+      homepage: normalized.homepage ?? null,
+      primaryEnv: normalized.primaryEnv ?? null,
+      skillKey: normalized.skillKey ?? null,
+      always: typeof normalized.always === 'boolean' ? normalized.always : false,
+      installOptions: normalized.installOptions,
+      skillRequirements: normalized.skillRequirements,
+      detectedEnvVars: normalized.detectedEnvVars,
+      security: normalized.security,
+      frontmatter: normalized.frontmatter,
       scope: updatedScope,
       agentIds: updatedAgentIds,
       id,

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

@@ -1,6 +1,4 @@
-import { genId } from '@/lib/id'
 import { NextResponse } from 'next/server'
-import { loadSkills, saveSkills } from '@/lib/server/storage'
 import { normalizeSkillPayload } from '@/lib/server/skills-normalize'
 
 const MAX_SKILL_BYTES = 2 * 1024 * 1024
@@ -46,22 +44,26 @@ export async function POST(req: Request) {
       sourceUrl: url,
     })
 
-    const skills = loadSkills()
-    const id = genId()
-    skills[id] = {
-      id,
+    return NextResponse.json({
       name: normalized.name,
       filename: normalized.filename,
       description: normalized.description,
       content: normalized.content,
       sourceUrl: normalized.sourceUrl,
       sourceFormat: normalized.sourceFormat,
-      createdAt: Date.now(),
-      updatedAt: Date.now(),
-    }
-    saveSkills(skills)
-
-    return NextResponse.json(skills[id])
+      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,
+    })
   } catch (err: unknown) {
     const message = err instanceof Error ? err.message : 'Failed to import skill'
     return NextResponse.json({ error: message }, { status: 400 })

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

@@ -5,7 +5,7 @@ import { normalizeSkillPayload } from '@/lib/server/skills-normalize'
 export const dynamic = 'force-dynamic'
 
 
-export async function GET(_req: Request) {
+export async function GET() {
   return NextResponse.json(loadSkills())
 }
 
@@ -26,6 +26,18 @@ export async function POST(req: Request) {
     description: normalized.description || '',
     sourceUrl: normalized.sourceUrl,
     sourceFormat: normalized.sourceFormat,
+    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,
     scope,
     agentIds,
     createdAt: Date.now(),

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

@@ -126,7 +126,16 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
       enqueueSystemEvent(tasks[id].sessionId, `Task ${tasks[id].status}: ${tasks[id].title}`)
     }
     if (tasks[id].agentId) {
-      requestHeartbeatNow({ agentId: tasks[id].agentId, reason: 'task-completed' })
+      requestHeartbeatNow({
+        agentId: tasks[id].agentId,
+        eventId: `task:${id}:${tasks[id].status}`,
+        reason: 'task-completed',
+        source: `task:${id}`,
+        resumeMessage: `Task ${tasks[id].status}: ${tasks[id].title}`,
+        detail: tasks[id].status === 'failed'
+          ? String(tasks[id].error || '').slice(0, 400)
+          : JSON.stringify(tasks[id].result || '').slice(0, 400),
+      })
     }
   }
 

package/src/app/api/tasks/import/github/route.test.ts

@@ -0,0 +1,65 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import {
+  buildGitHubIssueTaskDescription,
+  buildGitHubIssueTaskTags,
+  buildGitHubIssueTaskTitle,
+  parseGitHubRepoInput,
+} from './route'
+
+test('parseGitHubRepoInput accepts repo slugs and GitHub URLs', () => {
+  assert.deepEqual(parseGitHubRepoInput('swarmclawai/swarmclaw'), {
+    owner: 'swarmclawai',
+    repo: 'swarmclaw',
+    fullName: 'swarmclawai/swarmclaw',
+  })
+
+  assert.deepEqual(parseGitHubRepoInput('https://github.com/swarmclawai/swarmclaw/issues'), {
+    owner: 'swarmclawai',
+    repo: 'swarmclaw',
+    fullName: 'swarmclawai/swarmclaw',
+  })
+
+  assert.equal(parseGitHubRepoInput('not-a-repo'), null)
+  assert.equal(parseGitHubRepoInput('https://example.com/swarmclawai/swarmclaw'), null)
+})
+
+test('GitHub issue mapping builds a source-aware task payload shape', () => {
+  const issue = {
+    id: 12345,
+    number: 87,
+    title: 'Import GitHub issues into the board',
+    body: 'Bring open issues into SwarmClaw tasks.',
+    state: 'open',
+    html_url: 'https://github.com/swarmclawai/swarmclaw/issues/87',
+    labels: [{ name: 'feature' }, { name: 'task board' }, { name: 'feature' }],
+    assignee: { login: 'waydelyle' },
+    user: { login: 'octocat' },
+  }
+
+  assert.equal(
+    buildGitHubIssueTaskTitle(issue, 'swarmclawai/swarmclaw'),
+    '[swarmclawai/swarmclaw#87] Import GitHub issues into the board',
+  )
+
+  assert.equal(
+    buildGitHubIssueTaskDescription(issue, 'swarmclawai/swarmclaw'),
+    [
+      'Imported from GitHub issue swarmclawai/swarmclaw#87',
+      'URL: https://github.com/swarmclawai/swarmclaw/issues/87',
+      'State: open',
+      'Labels: feature, task board, feature',
+      'Assignee: waydelyle',
+      'Opened by: octocat',
+      '',
+      'Bring open issues into SwarmClaw tasks.',
+    ].join('\n'),
+  )
+
+  assert.deepEqual(buildGitHubIssueTaskTags(issue, 'swarmclawai/swarmclaw'), [
+    'github',
+    'swarmclawai/swarmclaw',
+    'feature',
+    'task board',
+  ])
+})

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

@@ -0,0 +1,337 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import { genId } from '@/lib/id'
+import { computeTaskFingerprint } from '@/lib/task-dedupe'
+import { formatZodError } from '@/lib/validation/schemas'
+import { loadSettings, loadTasks, logActivity, upsertStoredItems } from '@/lib/server/storage'
+import { notify } from '@/lib/server/ws-hub'
+import type { BoardTask } from '@/types'
+
+const MAX_IMPORT_LIMIT = 200
+const BODY_CHAR_LIMIT = 12_000
+
+const GitHubIssueImportSchema = z.object({
+  repo: z.string().trim().min(1, 'Repository is required'),
+  token: z.string().trim().optional().default(''),
+  state: z.enum(['open', 'closed', 'all']).optional().default('open'),
+  limit: z.coerce.number().int().min(1).max(MAX_IMPORT_LIMIT).optional().default(25),
+  labels: z.array(z.string()).optional().default([]),
+  projectId: z.string().trim().nullable().optional().default(null),
+  agentId: z.string().trim().nullable().optional().default(null),
+})
+
+type GitHubIssueLabel = string | { name?: string | null }
+
+interface GitHubIssueRecord {
+  id: number | string
+  number: number
+  title: string
+  body?: string | null
+  state?: string | null
+  html_url?: string | null
+  labels?: GitHubIssueLabel[]
+  assignee?: { login?: string | null } | null
+  user?: { login?: string | null } | null
+  pull_request?: unknown
+}
+
+interface ParsedRepo {
+  owner: string
+  repo: string
+  fullName: string
+}
+
+function getGitHubToken(explicitToken: string): string {
+  return explicitToken.trim()
+    || process.env.GITHUB_TOKEN
+    || process.env.GH_TOKEN
+    || process.env.GITHUB_PERSONAL_ACCESS_TOKEN
+    || ''
+}
+
+function normalizeLabelName(label: GitHubIssueLabel): string {
+  if (typeof label === 'string') return label.trim()
+  return String(label?.name || '').trim()
+}
+
+function normalizeTag(value: string): string {
+  return value.trim().replace(/\s+/g, ' ').slice(0, 60)
+}
+
+function toIssueSummary(issue: GitHubIssueRecord, taskId?: string) {
+  return {
+    taskId,
+    number: issue.number,
+    title: issue.title || `Issue ${issue.number}`,
+    url: issue.html_url || null,
+  }
+}
+
+export function parseGitHubRepoInput(input: string): ParsedRepo | null {
+  const trimmed = input.trim().replace(/\.git$/i, '')
+  if (!trimmed) return null
+
+  if (/^https?:\/\//i.test(trimmed)) {
+    try {
+      const url = new URL(trimmed)
+      if (!/github\.com$/i.test(url.hostname)) return null
+      const parts = url.pathname.split('/').filter(Boolean)
+      if (parts.length < 2) return null
+      const owner = parts[0]
+      const repo = parts[1].replace(/\.git$/i, '')
+      if (!owner || !repo) return null
+      return { owner, repo, fullName: `${owner}/${repo}` }
+    } catch {
+      return null
+    }
+  }
+
+  const compact = trimmed.replace(/^github\.com\//i, '')
+  const parts = compact.split('/').filter(Boolean)
+  if (parts.length < 2) return null
+  const owner = parts[0]
+  const repo = parts[1].replace(/\.git$/i, '')
+  if (!owner || !repo) return null
+  return { owner, repo, fullName: `${owner}/${repo}` }
+}
+
+export function buildGitHubIssueTaskTitle(issue: GitHubIssueRecord, repoFullName: string): string {
+  const title = issue.title?.trim() || `Issue ${issue.number}`
+  return `[${repoFullName}#${issue.number}] ${title}`
+}
+
+export function buildGitHubIssueTaskDescription(issue: GitHubIssueRecord, repoFullName: string): string {
+  const labels = (issue.labels || [])
+    .map(normalizeLabelName)
+    .filter(Boolean)
+  const header = [
+    `Imported from GitHub issue ${repoFullName}#${issue.number}`,
+    issue.html_url ? `URL: ${issue.html_url}` : '',
+    issue.state ? `State: ${issue.state}` : '',
+    labels.length > 0 ? `Labels: ${labels.join(', ')}` : '',
+    issue.assignee?.login ? `Assignee: ${issue.assignee.login}` : '',
+    issue.user?.login ? `Opened by: ${issue.user.login}` : '',
+  ]
+    .filter(Boolean)
+    .join('\n')
+
+  const rawBody = String(issue.body || '').trim()
+  if (!rawBody) return header
+
+  const body = rawBody.length > BODY_CHAR_LIMIT
+    ? `${rawBody.slice(0, BODY_CHAR_LIMIT).trimEnd()}\n\n[Truncated during import]`
+    : rawBody
+
+  return `${header}\n\n${body}`
+}
+
+export function buildGitHubIssueTaskTags(issue: GitHubIssueRecord, repoFullName: string): string[] {
+  const raw = [
+    'github',
+    repoFullName,
+    ...(issue.labels || []).map(normalizeLabelName),
+  ]
+  return Array.from(new Set(raw.map(normalizeTag).filter(Boolean))).slice(0, 8)
+}
+
+function findExistingImportedTask(
+  tasks: Record<string, BoardTask>,
+  repoFullName: string,
+  issueNumber: number,
+): BoardTask | null {
+  for (const task of Object.values(tasks)) {
+    if (task.sourceType !== 'import') continue
+    if (task.externalSource?.source !== 'github') continue
+    if (task.externalSource?.repo !== repoFullName) continue
+    if (task.externalSource?.number !== issueNumber) continue
+    return task
+  }
+  return null
+}
+
+async function fetchGitHubIssues(args: {
+  owner: string
+  repo: string
+  state: 'open' | 'closed' | 'all'
+  limit: number
+  labels: string[]
+  token: string
+}): Promise<GitHubIssueRecord[]> {
+  const headers: Record<string, string> = {
+    Accept: 'application/vnd.github+json',
+    'User-Agent': 'SwarmClaw',
+    'X-GitHub-Api-Version': '2022-11-28',
+  }
+  if (args.token) headers.Authorization = `Bearer ${args.token}`
+
+  const results: GitHubIssueRecord[] = []
+  const perPage = Math.min(100, Math.max(30, args.limit))
+  const maxPages = Math.max(1, Math.ceil(args.limit / 100) + 2)
+
+  for (let page = 1; page <= maxPages && results.length < args.limit; page++) {
+    const url = new URL(`https://api.github.com/repos/${args.owner}/${args.repo}/issues`)
+    url.searchParams.set('state', args.state)
+    url.searchParams.set('per_page', String(perPage))
+    url.searchParams.set('page', String(page))
+    if (args.labels.length > 0) url.searchParams.set('labels', args.labels.join(','))
+
+    const response = await fetch(url, {
+      headers,
+      cache: 'no-store',
+    })
+
+    if (!response.ok) {
+      const payload = await response.json().catch(() => null) as { message?: unknown } | null
+      const message = typeof payload?.message === 'string'
+        ? payload.message
+        : `GitHub request failed (${response.status})`
+      const err = new Error(message) as Error & { status?: number }
+      err.status = response.status
+      throw err
+    }
+
+    const payload = await response.json().catch(() => null) as unknown
+    if (!Array.isArray(payload)) {
+      throw new Error('GitHub returned an unexpected response.')
+    }
+
+    const pageIssues = payload
+      .filter((entry): entry is GitHubIssueRecord => !!entry && typeof entry === 'object')
+      .filter((entry) => !entry.pull_request)
+
+    results.push(...pageIssues)
+    if (payload.length < perPage) break
+  }
+
+  return results.slice(0, args.limit)
+}
+
+export async function POST(req: Request) {
+  const raw = await req.json().catch(() => null)
+  const parsed = GitHubIssueImportSchema.safeParse(raw)
+  if (!parsed.success) {
+    return NextResponse.json(formatZodError(parsed.error), { status: 400 })
+  }
+
+  const repo = parseGitHubRepoInput(parsed.data.repo)
+  if (!repo) {
+    return NextResponse.json({ error: 'Use a GitHub repo like owner/repo or a github.com URL.' }, { status: 400 })
+  }
+
+  const labels = parsed.data.labels
+    .map((value) => String(value || '').trim())
+    .filter(Boolean)
+
+  let issues: GitHubIssueRecord[]
+  try {
+    issues = await fetchGitHubIssues({
+      owner: repo.owner,
+      repo: repo.repo,
+      state: parsed.data.state,
+      limit: parsed.data.limit,
+      labels,
+      token: getGitHubToken(parsed.data.token),
+    })
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'GitHub import failed.'
+    const status = typeof (err as { status?: unknown })?.status === 'number'
+      ? Number((err as { status?: number }).status)
+      : 500
+    const responseStatus = [400, 401, 403, 404, 429].includes(status) ? status : 502
+    return NextResponse.json({ error: message }, { status: responseStatus })
+  }
+
+  const tasks = loadTasks() as Record<string, BoardTask>
+  const settings = loadSettings()
+  const now = Date.now()
+  const maxAttempts = Math.max(1, Math.min(20, Math.trunc(Number(settings.defaultTaskMaxAttempts ?? 3))))
+  const retryBackoffSec = Math.max(1, Math.min(3600, Math.trunc(Number(settings.taskRetryBackoffSec ?? 30))))
+  const projectId = parsed.data.projectId || undefined
+  const agentId = parsed.data.agentId || ''
+
+  const created: Array<ReturnType<typeof toIssueSummary>> = []
+  const skipped: Array<ReturnType<typeof toIssueSummary>> = []
+  const taskEntries: Array<[string, BoardTask]> = []
+
+  for (const issue of issues) {
+    const existing = findExistingImportedTask(tasks, repo.fullName, issue.number)
+    if (existing) {
+      skipped.push(toIssueSummary(issue, existing.id))
+      continue
+    }
+
+    const id = genId()
+    const title = buildGitHubIssueTaskTitle(issue, repo.fullName)
+    const task: BoardTask = {
+      id,
+      title,
+      description: buildGitHubIssueTaskDescription(issue, repo.fullName),
+      status: 'backlog',
+      agentId,
+      projectId,
+      result: null,
+      error: null,
+      outputFiles: [],
+      artifacts: [],
+      createdAt: now,
+      updatedAt: now,
+      queuedAt: null,
+      startedAt: null,
+      completedAt: null,
+      archivedAt: null,
+      attempts: 0,
+      maxAttempts,
+      retryBackoffSec,
+      retryScheduledAt: null,
+      deadLetteredAt: null,
+      checkpoint: null,
+      blockedBy: [],
+      blocks: [],
+      tags: buildGitHubIssueTaskTags(issue, repo.fullName),
+      sourceType: 'import',
+      externalSource: {
+        source: 'github',
+        id: String(issue.id),
+        repo: repo.fullName,
+        number: issue.number,
+        state: issue.state || null,
+        labels: (issue.labels || []).map(normalizeLabelName).filter(Boolean),
+        assignee: issue.assignee?.login || null,
+        url: issue.html_url || null,
+      },
+      fingerprint: computeTaskFingerprint(title, agentId),
+    }
+
+    tasks[id] = task
+    taskEntries.push([id, task])
+    created.push(toIssueSummary(issue, id))
+  }
+
+  if (taskEntries.length > 0) {
+    upsertStoredItems('tasks', taskEntries)
+    notify('tasks')
+  }
+
+  logActivity({
+    entityType: 'task',
+    entityId: created[0]?.taskId || `github:${repo.fullName}`,
+    action: 'imported',
+    actor: 'user',
+    summary: `GitHub import from ${repo.fullName}: ${created.length} created, ${skipped.length} skipped`,
+    detail: {
+      repo: repo.fullName,
+      state: parsed.data.state,
+      labels,
+      created: created.length,
+      skipped: skipped.length,
+    },
+  })
+
+  return NextResponse.json({
+    repo: repo.fullName,
+    state: parsed.data.state,
+    fetched: issues.length,
+    created,
+    skipped,
+  })
+}

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

@@ -1,8 +1,9 @@
 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'
+import { getWalletAtomicAmount } from '@/lib/wallet'
+import { sendWalletNativeAsset, validateWalletSendLimits } from '@/lib/server/wallet-service'
 export const dynamic = 'force-dynamic'
 
 export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
@@ -41,10 +42,23 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
 
   // Approve — sign and submit
   try {
-    const { signature, fee } = await sendSol(wallet.encryptedPrivateKey, tx.toAddress, tx.amountLamports)
+    const limitError = validateWalletSendLimits({ wallet, amountAtomic: getWalletAtomicAmount(tx), excludeTransactionId: transactionId })
+    if (limitError) {
+      tx.status = 'failed'
+      upsertWalletTransaction(transactionId, tx)
+      notify('wallets')
+      return NextResponse.json({
+        error: limitError,
+        transactionId,
+        status: 'failed',
+      }, { status: limitError === 'Amount must be positive' ? 400 : 403 })
+    }
+
+    const { signature, feeAtomic } = await sendWalletNativeAsset(wallet, tx.toAddress, getWalletAtomicAmount(tx))
     tx.status = 'confirmed'
     tx.signature = signature
-    tx.feeLamports = fee
+    tx.feeAtomic = feeAtomic
+    tx.feeLamports = wallet.chain === 'solana' && feeAtomic ? Number.parseInt(feeAtomic, 10) : undefined
     tx.approvedBy = 'user'
     upsertWalletTransaction(transactionId, tx)
     notify('wallets')