@swarmclawai/swarmclaw 1.4.0 → 1.4.2

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

@@ -0,0 +1,97 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { runWithTempDataDir } from '@/lib/server/test-utils/run-with-temp-data-dir'
+
+test('connector doctor route rejects malformed JSON with a 400', () => {
+  const output = runWithTempDataDir<{
+    status: number
+    payload: { error?: string }
+  }>(`
+    const repoMod = await import('./src/lib/server/connectors/connector-repository')
+    const routeMod = await import('./src/app/api/connectors/[id]/doctor/route')
+    const repo = repoMod.default || repoMod
+    const route = routeMod.default || routeMod
+
+    repo.saveConnectors({
+      conn_1: {
+        id: 'conn_1',
+        name: 'Doctor Test',
+        platform: 'discord',
+        agentId: 'agent_1',
+        chatroomId: null,
+        credentialId: null,
+        config: {},
+        isEnabled: true,
+        status: 'running',
+        createdAt: 1,
+        updatedAt: 1,
+      },
+    })
+
+    const response = await route.POST(new Request('http://local/api/connectors/conn_1/doctor', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: '{bad-json',
+    }), { params: Promise.resolve({ id: 'conn_1' }) })
+
+    console.log(JSON.stringify({
+      status: response.status,
+      payload: await response.json(),
+    }))
+  `, { prefix: 'swarmclaw-connector-doctor-route-' })
+
+  assert.equal(output.status, 400)
+  assert.equal(output.payload.error, 'Invalid or missing request body')
+})
+
+test('connector doctor route returns a preview report for valid input', () => {
+  const output = runWithTempDataDir<{
+    status: number
+    payload: { warnings?: string[]; policy?: { mode?: string } }
+  }>(`
+    const repoMod = await import('./src/lib/server/connectors/connector-repository')
+    const routeMod = await import('./src/app/api/connectors/[id]/doctor/route')
+    const repo = repoMod.default || repoMod
+    const route = routeMod.default || routeMod
+
+    repo.saveConnectors({
+      conn_1: {
+        id: 'conn_1',
+        name: 'Doctor Test',
+        platform: 'discord',
+        agentId: 'agent_1',
+        chatroomId: null,
+        credentialId: null,
+        config: {},
+        isEnabled: true,
+        status: 'running',
+        createdAt: 1,
+        updatedAt: 1,
+      },
+    })
+
+    const response = await route.POST(new Request('http://local/api/connectors/conn_1/doctor', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        sampleMsg: {
+          channelId: 'channel-1',
+          channelName: 'general',
+          senderId: 'user-1',
+          senderName: 'User',
+          text: 'hello',
+        },
+      }),
+    }), { params: Promise.resolve({ id: 'conn_1' }) })
+
+    console.log(JSON.stringify({
+      status: response.status,
+      payload: await response.json(),
+    }))
+  `, { prefix: 'swarmclaw-connector-doctor-route-' })
+
+  assert.equal(output.status, 200)
+  assert.ok(Array.isArray(output.payload.warnings))
+  assert.ok(output.payload.policy)
+})

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

@@ -1,10 +1,34 @@
 import { NextResponse } from 'next/server'
+import { z } from 'zod'
+
 import { notFound } from '@/lib/server/collection-helpers'
 import { buildConnectorDoctorPreview, buildConnectorDoctorReport, type ConnectorDoctorPreviewInput } from '@/lib/server/connectors/doctor'
 import { loadConnectors } from '@/lib/server/connectors/connector-repository'
+import { safeParseBody } from '@/lib/server/safe-parse-body'
 
 export const dynamic = 'force-dynamic'
 
+const ConnectorDoctorPreviewSchema: z.ZodType<ConnectorDoctorPreviewInput> = z.object({
+  id: z.unknown().optional(),
+  name: z.unknown().optional(),
+  platform: z.unknown().optional(),
+  agentId: z.unknown().optional(),
+  chatroomId: z.unknown().optional(),
+  credentialId: z.unknown().optional(),
+  config: z.record(z.string(), z.unknown()).optional(),
+  sampleMsg: z.object({
+    channelId: z.string().optional(),
+    channelName: z.string().optional(),
+    senderId: z.string().optional(),
+    senderName: z.string().optional(),
+    text: z.string().optional(),
+    isGroup: z.boolean().optional(),
+    messageId: z.string().optional(),
+    replyToMessageId: z.string().optional(),
+    threadId: z.string().optional(),
+  }).passthrough().nullable().optional(),
+}).passthrough()
+
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const connectors = loadConnectors()
@@ -20,7 +44,8 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
   const baseConnector = connectors[id]
   if (!baseConnector) return notFound()
 
-  const body = await req.json().catch(() => ({})) as ConnectorDoctorPreviewInput
+  const { data: body, error } = await safeParseBody(req, ConnectorDoctorPreviewSchema)
+  if (error) return error
   const connector = buildConnectorDoctorPreview({ baseConnector, input: body, fallbackId: id })
   return NextResponse.json(buildConnectorDoctorReport(connector, body.sampleMsg, { baseConnector }))
 }

package/src/app/api/connectors/connector-doctor-route.test.ts

@@ -0,0 +1 @@
+import './[id]/doctor/route.test'

package/src/app/api/logs/route.test.ts

@@ -0,0 +1,61 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { runWithTempDataDir } from '@/lib/server/test-utils/run-with-temp-data-dir'
+
+test('logs route accepts client-side error reports and persists them', () => {
+  const output = runWithTempDataDir<{
+    status: number
+    payload: { ok?: boolean }
+    entries: Array<{ tag?: string; message?: string; data?: string }>
+  }>(`
+    const routeMod = await import('./src/app/api/logs/route')
+    const route = routeMod.default || routeMod
+
+    const postResponse = await route.POST(new Request('http://local/api/logs', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        source: 'error-boundary',
+        message: 'Client render failed',
+        componentStack: 'at DemoComponent',
+      }),
+    }))
+
+    const getResponse = await route.GET(new Request('http://local/api/logs?lines=5&search=Client%20render%20failed'))
+
+    console.log(JSON.stringify({
+      status: postResponse.status,
+      payload: await postResponse.json(),
+      entries: (await getResponse.json()).entries,
+    }))
+  `, { prefix: 'swarmclaw-logs-route-' })
+
+  assert.equal(output.status, 200)
+  assert.equal(output.payload.ok, true)
+  assert.ok(output.entries.some((entry) => entry.tag === 'error-boundary' && entry.message === 'Client render failed'))
+})
+
+test('logs route rejects malformed client error payloads with a 400', () => {
+  const output = runWithTempDataDir<{
+    status: number
+    payload: { error?: string }
+  }>(`
+    const routeMod = await import('./src/app/api/logs/route')
+    const route = routeMod.default || routeMod
+
+    const response = await route.POST(new Request('http://local/api/logs', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: '{bad-json',
+    }))
+
+    console.log(JSON.stringify({
+      status: response.status,
+      payload: await response.json(),
+    }))
+  `, { prefix: 'swarmclaw-logs-route-' })
+
+  assert.equal(output.status, 400)
+  assert.equal(output.payload.error, 'Invalid or missing request body')
+})

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

@@ -1,10 +1,25 @@
 import { NextResponse } from 'next/server'
 import fs from 'fs'
+import { z } from 'zod'
+
 import { APP_LOG_PATH } from '@/lib/server/data-dir'
+import { log } from '@/lib/server/logger'
+import { safeParseBody } from '@/lib/server/safe-parse-body'
 
 /** Max bytes to read from the tail of the log file (256 KB). */
 const TAIL_BYTES = 256 * 1024
 
+const ClientLogSchema = z.object({
+  source: z.string().trim().min(1).max(120).optional().default('client'),
+  message: z.string().trim().min(1).max(1000),
+  stack: z.string().max(8000).optional(),
+  componentStack: z.string().max(8000).optional(),
+  digest: z.string().max(200).optional(),
+  url: z.string().max(2000).optional(),
+  pathname: z.string().max(1000).optional(),
+  userAgent: z.string().max(1000).optional(),
+})
+
 export async function GET(req: Request) {
   const { searchParams } = new URL(req.url)
   const lines = parseInt(searchParams.get('lines') || '200', 10)
@@ -76,6 +91,26 @@ export async function DELETE() {
   }
 }
 
+export async function POST(req: Request) {
+  const { data: body, error } = await safeParseBody(req, ClientLogSchema)
+  if (error) return error
+
+  try {
+    log.error(body.source, body.message, {
+      stack: body.stack,
+      componentStack: body.componentStack,
+      digest: body.digest,
+      url: body.url,
+      pathname: body.pathname,
+      userAgent: body.userAgent,
+    })
+    return NextResponse.json({ ok: true })
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err)
+    return NextResponse.json({ error: message }, { status: 500 })
+  }
+}
+
 function parseLine(line: string) {
   // Format: [2026-02-19T17:06:00.000Z] [INFO] [tag] message | data
   const match = line.match(/^\[([^\]]+)\]\s+\[(\w+)\]\s+\[([^\]]+)\]\s+(.*)$/)

package/src/app/api/tts/route.test.ts

@@ -0,0 +1,82 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { runWithTempDataDir } from '@/lib/server/test-utils/run-with-temp-data-dir'
+
+test('tts routes reject malformed JSON with a 400', () => {
+  const output = runWithTempDataDir<{
+    ttsStatus: number
+    ttsPayload: { error?: string }
+    streamStatus: number
+    streamPayload: { error?: string }
+  }>(`
+    const ttsRouteMod = await import('./src/app/api/tts/route')
+    const ttsStreamRouteMod = await import('./src/app/api/tts/stream/route')
+    const ttsRoute = ttsRouteMod.default || ttsRouteMod
+    const ttsStreamRoute = ttsStreamRouteMod.default || ttsStreamRouteMod
+
+    const ttsResponse = await ttsRoute.POST(new Request('http://local/api/tts', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: '{bad-json',
+    }))
+
+    const ttsStreamResponse = await ttsStreamRoute.POST(new Request('http://local/api/tts/stream', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: '{bad-json',
+    }))
+
+    console.log(JSON.stringify({
+      ttsStatus: ttsResponse.status,
+      ttsPayload: await ttsResponse.json(),
+      streamStatus: ttsStreamResponse.status,
+      streamPayload: await ttsStreamResponse.json(),
+    }))
+  `, { prefix: 'swarmclaw-tts-route-' })
+
+  assert.equal(output.ttsStatus, 400)
+  assert.equal(output.ttsPayload.error, 'Invalid or missing request body')
+  assert.equal(output.streamStatus, 400)
+  assert.equal(output.streamPayload.error, 'Invalid or missing request body')
+})
+
+test('tts routes reject empty text with a validation error', () => {
+  const output = runWithTempDataDir<{
+    ttsStatus: number
+    ttsPayload: { error?: string; issues?: Array<{ path: string; message: string }> }
+    streamStatus: number
+    streamPayload: { error?: string; issues?: Array<{ path: string; message: string }> }
+  }>(`
+    const ttsRouteMod = await import('./src/app/api/tts/route')
+    const ttsStreamRouteMod = await import('./src/app/api/tts/stream/route')
+    const ttsRoute = ttsRouteMod.default || ttsRouteMod
+    const ttsStreamRoute = ttsStreamRouteMod.default || ttsStreamRouteMod
+
+    const ttsResponse = await ttsRoute.POST(new Request('http://local/api/tts', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ text: '   ' }),
+    }))
+
+    const ttsStreamResponse = await ttsStreamRoute.POST(new Request('http://local/api/tts/stream', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ text: '   ' }),
+    }))
+
+    console.log(JSON.stringify({
+      ttsStatus: ttsResponse.status,
+      ttsPayload: await ttsResponse.json(),
+      streamStatus: ttsStreamResponse.status,
+      streamPayload: await ttsStreamResponse.json(),
+    }))
+  `, { prefix: 'swarmclaw-tts-route-' })
+
+  assert.equal(output.ttsStatus, 400)
+  assert.equal(output.ttsPayload.error, 'Validation failed')
+  assert.deepEqual(output.ttsPayload.issues, [{ path: 'text', message: 'No text provided' }])
+  assert.equal(output.streamStatus, 400)
+  assert.equal(output.streamPayload.error, 'Validation failed')
+  assert.deepEqual(output.streamPayload.issues, [{ path: 'text', message: 'No text provided' }])
+})

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

@@ -1,14 +1,21 @@
 import { NextResponse } from 'next/server'
+import { z } from 'zod'
+
 import { explainElevenLabsError, resolveElevenLabsConfig, synthesizeElevenLabsMp3 } from '@/lib/server/elevenlabs'
+import { safeParseBody } from '@/lib/server/safe-parse-body'
+
+const TtsRequestSchema = z.object({
+  text: z.string().trim().min(1, 'No text provided'),
+  voiceId: z.string().nullable().optional(),
+})
 
 export async function POST(req: Request) {
+  const { data: body, error } = await safeParseBody(req, TtsRequestSchema)
+  if (error) return error
+
   try {
-    const { text, voiceId } = await req.json()
-    if (!String(text || '').trim()) {
-      return new NextResponse('No text provided', { status: 400 })
-    }
-    resolveElevenLabsConfig(voiceId)
-    const audioBuffer = await synthesizeElevenLabsMp3({ text: String(text || ''), voiceId })
+    resolveElevenLabsConfig(body.voiceId)
+    const audioBuffer = await synthesizeElevenLabsMp3({ text: body.text, voiceId: body.voiceId })
     return new NextResponse(new Uint8Array(audioBuffer), {
       headers: {
         'Content-Type': 'audio/mpeg',

package/src/app/api/tts/stream/route.ts

@@ -1,12 +1,19 @@
+import { z } from 'zod'
+
 import { explainElevenLabsError, requestElevenLabsMp3Stream } from '@/lib/server/elevenlabs'
+import { safeParseBody } from '@/lib/server/safe-parse-body'
+
+const TtsStreamRequestSchema = z.object({
+  text: z.string().trim().min(1, 'No text provided'),
+  voiceId: z.string().nullable().optional(),
+})
 
 export async function POST(req: Request) {
+  const { data: body, error } = await safeParseBody(req, TtsStreamRequestSchema)
+  if (error) return error
+
   try {
-    const { text, voiceId } = await req.json()
-    if (!String(text || '').trim()) {
-      return new Response('No text provided', { status: 400 })
-    }
-    const apiRes = await requestElevenLabsMp3Stream({ text: String(text || ''), voiceId })
+    const apiRes = await requestElevenLabsMp3Stream({ text: body.text, voiceId: body.voiceId })
     return new Response(apiRes.body, {
       headers: {
         'Content-Type': 'audio/mpeg',

package/src/app/error.tsx

@@ -0,0 +1,32 @@
+'use client'
+
+import { useEffect } from 'react'
+
+import { ErrorFallback } from '@/components/layout/error-fallback'
+import { reportClientError } from '@/lib/app/report-client-error'
+
+export default function AppError({
+  error,
+  reset,
+}: {
+  error: Error & { digest?: string }
+  reset: () => void
+}) {
+  useEffect(() => {
+    reportClientError({
+      source: 'app-error',
+      error,
+      digest: error.digest,
+    })
+  }, [error])
+
+  return (
+    <ErrorFallback
+      message="A route-level error interrupted the current view. Try the request again or reload the app."
+      primaryLabel="Try Again"
+      onPrimaryAction={() => reset()}
+      secondaryLabel="Reload"
+      onSecondaryAction={() => window.location.reload()}
+    />
+  )
+}

package/src/app/global-error.tsx

@@ -0,0 +1,33 @@
+'use client'
+
+import { useEffect } from 'react'
+
+import './globals.css'
+
+import { ErrorFallback } from '@/components/layout/error-fallback'
+import { reportClientError } from '@/lib/app/report-client-error'
+
+export default function GlobalError({
+  error,
+}: {
+  error: Error & { digest?: string }
+}) {
+  useEffect(() => {
+    reportClientError({
+      source: 'global-error',
+      error,
+      digest: error.digest,
+    })
+  }, [error])
+
+  return (
+    <html lang="en" className="dark">
+      <body className="antialiased">
+        <ErrorFallback
+          message="A fatal application error occurred before the normal shell could recover. Reload the app to continue."
+          onPrimaryAction={() => window.location.reload()}
+        />
+      </body>
+    </html>
+  )
+}

package/src/cli/index.js

@@ -298,6 +298,9 @@ const COMMAND_GROUPS = [
     commands: [
       cmd('list', 'GET', '/logs', 'List logs (use --query lines=200, --query level=INFO,ERROR)'),
       cmd('clear', 'DELETE', '/logs', 'Clear logs file'),
+      cmd('report', 'POST', '/logs', 'Write a client/browser error entry to the application log', {
+        expectsJsonBody: true,
+      }),
     ],
   },
   {

package/src/cli/spec.js

@@ -215,6 +215,7 @@ const COMMAND_GROUPS = {
     commands: {
       list: { description: 'Fetch logs (supports --query lines=200,level=INFO)', method: 'GET', path: '/logs' },
       clear: { description: 'Clear log file', method: 'DELETE', path: '/logs' },
+      report: { description: 'Write a client/browser error entry to the application log', method: 'POST', path: '/logs' },
     },
   },
 

package/src/components/layout/error-boundary.tsx

@@ -3,6 +3,9 @@
 import { Component } from 'react'
 import type { ReactNode, ErrorInfo } from 'react'
 
+import { reportClientError } from '@/lib/app/report-client-error'
+import { ErrorFallback } from '@/components/layout/error-fallback'
+
 export class ErrorBoundary extends Component<{ children: ReactNode }, { hasError: boolean }> {
   constructor(props: { children: ReactNode }) {
     super(props)
@@ -15,41 +18,20 @@ export class ErrorBoundary extends Component<{ children: ReactNode }, { hasError
   }
 
   componentDidCatch(error: Error, info: ErrorInfo) {
-    console.error('ErrorBoundary caught:', error, info)
+    reportClientError({
+      source: 'error-boundary',
+      error,
+      componentStack: info.componentStack,
+    })
   }
 
   render() {
     if (this.state.hasError) {
       return (
-        <div className="flex-1 flex flex-col items-center justify-center px-8 bg-bg">
-          <div className="text-center max-w-[400px]">
-            <div className="w-14 h-14 rounded-[16px] bg-red-500/10 border border-red-500/20 flex items-center justify-center mx-auto mb-5">
-              <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.5" strokeLinecap="round" className="text-red-400">
-                <circle cx="12" cy="12" r="10" />
-                <line x1="12" y1="8" x2="12" y2="12" />
-                <line x1="12" y1="16" x2="12.01" y2="16" />
-              </svg>
-            </div>
-            <h2 className="font-display text-[22px] font-700 text-text mb-2 tracking-[-0.02em]">
-              Something went wrong
-            </h2>
-            <p className="text-[14px] text-text-3 mb-6">
-              An unexpected error occurred. Try reloading the page.
-            </p>
-            <button
-              onClick={() => window.location.reload()}
-              className="inline-flex items-center gap-2 px-6 py-3 rounded-[12px] border-none bg-accent-bright text-white text-[14px] font-600 cursor-pointer
-                hover:brightness-110 active:scale-[0.97] transition-all shadow-[0_4px_16px_rgba(99,102,241,0.2)]"
-              style={{ fontFamily: 'inherit' }}
-            >
-              <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5" strokeLinecap="round">
-                <polyline points="23 4 23 10 17 10" />
-                <path d="M20.49 15a9 9 0 1 1-2.12-9.36L23 10" />
-              </svg>
-              Reload
-            </button>
-          </div>
-        </div>
+        <ErrorFallback
+          message="An unexpected dashboard error occurred. Reload the page to recover."
+          onPrimaryAction={() => window.location.reload()}
+        />
       )
     }
 

package/src/components/layout/error-fallback.tsx

@@ -0,0 +1,61 @@
+'use client'
+
+type ErrorFallbackProps = {
+  title?: string
+  message?: string
+  primaryLabel?: string
+  onPrimaryAction?: () => void
+  secondaryLabel?: string
+  onSecondaryAction?: () => void
+}
+
+export function ErrorFallback({
+  title = 'Something went wrong',
+  message = 'An unexpected error occurred. Try again or reload the page.',
+  primaryLabel = 'Reload',
+  onPrimaryAction,
+  secondaryLabel,
+  onSecondaryAction,
+}: ErrorFallbackProps) {
+  return (
+    <div className="flex min-h-[50vh] flex-1 flex-col items-center justify-center bg-bg px-8">
+      <div className="max-w-[420px] text-center">
+        <div className="mx-auto mb-5 flex h-14 w-14 items-center justify-center rounded-[16px] border border-red-500/20 bg-red-500/10">
+          <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.5" strokeLinecap="round" className="text-red-400">
+            <circle cx="12" cy="12" r="10" />
+            <line x1="12" y1="8" x2="12" y2="12" />
+            <line x1="12" y1="16" x2="12.01" y2="16" />
+          </svg>
+        </div>
+        <h2 className="mb-2 font-display text-[22px] font-700 tracking-[-0.02em] text-text">
+          {title}
+        </h2>
+        <p className="mb-6 text-[14px] text-text-3">
+          {message}
+        </p>
+        <div className="flex flex-wrap items-center justify-center gap-3">
+          <button
+            onClick={onPrimaryAction}
+            className="inline-flex cursor-pointer items-center gap-2 rounded-[12px] border-none bg-accent-bright px-6 py-3 text-[14px] font-600 text-white shadow-[0_4px_16px_rgba(99,102,241,0.2)] transition-all hover:brightness-110 active:scale-[0.97]"
+            style={{ fontFamily: 'inherit' }}
+          >
+            <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5" strokeLinecap="round">
+              <polyline points="23 4 23 10 17 10" />
+              <path d="M20.49 15a9 9 0 1 1-2.12-9.36L23 10" />
+            </svg>
+            {primaryLabel}
+          </button>
+          {secondaryLabel && onSecondaryAction ? (
+            <button
+              onClick={onSecondaryAction}
+              className="inline-flex cursor-pointer items-center rounded-[12px] border border-border bg-transparent px-5 py-3 text-[14px] font-600 text-text transition-colors hover:bg-panel/60"
+              style={{ fontFamily: 'inherit' }}
+            >
+              {secondaryLabel}
+            </button>
+          ) : null}
+        </div>
+      </div>
+    </div>
+  )
+}

package/src/features/swarmfeed/queries.ts

@@ -10,16 +10,16 @@ export async function fetchFeed(
   if (params?.channelId) searchParams.set('channelId', params.channelId)
   if (params?.cursor) searchParams.set('cursor', params.cursor)
   if (params?.limit) searchParams.set('limit', String(params.limit))
-  return api<{ posts: SwarmFeedPost[]; nextCursor?: string }>('GET', `/api/swarmfeed?${searchParams.toString()}`)
+  return api<{ posts: SwarmFeedPost[]; nextCursor?: string }>('GET', `/swarmfeed?${searchParams.toString()}`)
 }
 
 export async function fetchChannels(): Promise<SwarmFeedChannel[]> {
-  const result = await api<{ channels: SwarmFeedChannel[] }>('GET', '/api/swarmfeed/channels')
+  const result = await api<{ channels: SwarmFeedChannel[] }>('GET', '/swarmfeed/channels')
   return result.channels
 }
 
 export async function submitPost(agentId: string, content: string, channelId?: string, parentId?: string): Promise<SwarmFeedPost> {
-  return api<SwarmFeedPost>('POST', '/api/swarmfeed/posts', {
+  return api<SwarmFeedPost>('POST', '/swarmfeed/posts', {
     agentId,
     content,
     channelId,