@swarmclawai/swarmclaw 0.8.4 → 0.8.7

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

@@ -25,6 +25,7 @@ import { applyAgentReactionsFromText } from '@/lib/server/chatroom-orchestration
 import { resolvePrimaryAgentRoute } from '@/lib/server/agent-runtime-config'
 import { shouldSuppressHiddenControlText, stripHiddenControlTokens } from '@/lib/server/assistant-control'
 import type { Chatroom, ChatroomMessage, Agent } from '@/types'
+import { errorMessage } from '@/lib/shared-utils'
 
 export const dynamic = 'force-dynamic'
 export const maxDuration = 300
@@ -283,7 +284,7 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
             writeEvent({ t: 'cr_agent_done', agentId: agent.id, agentName: agent.name })
             return []
           } catch (err: unknown) {
-            const msg = err instanceof Error ? err.message : String(err)
+            const msg = errorMessage(err)
             markProviderFailure(agent.provider, msg)
             writeEvent({ t: 'err', text: `Agent ${agent.name} error: ${msg}`, agentId: agent.id })
             writeEvent({ t: 'cr_agent_done', agentId: agent.id, agentName: agent.name })
@@ -336,7 +337,7 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
       }
 
       processAgents().catch((err) => {
-        const msg = err instanceof Error ? err.message : String(err)
+        const msg = errorMessage(err)
         writeEvent({ t: 'err', text: msg })
         writeEvent({ t: 'done' })
         if (!closed) {

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

@@ -103,12 +103,13 @@ export async function DELETE(_req: Request, { params }: { params: Promise<{ id:
   // 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
-    }
+  for (const rawConnector of Object.values(connectors)) {
+    if (!rawConnector || typeof rawConnector !== 'object') continue
+    const connector = rawConnector as { chatroomId?: string | null; updatedAt?: number }
+    if (connector.chatroomId !== id) continue
+    connector.chatroomId = null
+    connector.updatedAt = Date.now()
+    connectorsDirty = true
   }
   if (connectorsDirty) {
     saveConnectors(connectors)

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

@@ -0,0 +1,496 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { runWithTempDataDir } from '@/lib/server/test-utils/run-with-temp-data-dir'
+
+test('chat route keeps long-lived user runs alive after stream disconnect and records perf', () => {
+  const output = runWithTempDataDir<{
+    responseReturnedBeforeProviderFinished: boolean
+    firstChunk: string
+    assistantReplies: string[]
+    runStatuses: string[]
+    queueLength: number
+    perfLabels: string[]
+  }>(`
+    const storageMod = await import('./src/lib/server/storage')
+    const providersMod = await import('@/lib/providers')
+    const routeMod = await import('./src/app/api/chats/[id]/chat/route')
+    const runsMod = await import('./src/lib/server/session-run-manager')
+    const perfMod = await import('./src/lib/server/perf')
+    const storage = storageMod.default || storageMod
+    const providers = providersMod.default || providersMod
+    const route = routeMod.default || routeMod
+    const runs = runsMod.default || runsMod
+    const perf = perfMod.perf || perfMod.default?.perf || perfMod.default || perfMod
+
+    let providerFinishedAt = 0
+    providers.PROVIDERS['workbench-provider'] = {
+      id: 'workbench-provider',
+      name: 'Workbench Provider',
+      models: ['wb-model'],
+      requiresApiKey: false,
+      requiresEndpoint: false,
+      handler: {
+        streamChat: async (opts) => {
+          await new Promise((resolve) => setTimeout(resolve, 120))
+          const reply = 'Long-lived work finished cleanly.'
+          opts.write('data: ' + JSON.stringify({ t: 'r', text: reply }) + '\\n')
+          providerFinishedAt = Date.now()
+          return reply
+        },
+      },
+    }
+
+    const now = Date.now()
+    storage.saveAgents({
+      agent_1: {
+        id: 'agent_1',
+        name: 'Workbench Agent',
+        provider: 'workbench-provider',
+        model: 'wb-model',
+        plugins: [],
+        createdAt: now,
+        updatedAt: now,
+      },
+    })
+    storage.saveSessions({
+      sess_1: {
+        id: 'sess_1',
+        name: 'Workbench Session',
+        cwd: process.env.WORKSPACE_DIR,
+        user: 'workbench',
+        provider: 'workbench-provider',
+        model: 'wb-model',
+        claudeSessionId: null,
+        messages: [],
+        createdAt: now,
+        lastActiveAt: now,
+        sessionType: 'human',
+        agentId: 'agent_1',
+        plugins: [],
+      },
+    })
+
+    perf.setEnabled(true)
+    perf.clearRecentEntries()
+
+    const startedAt = Date.now()
+    const response = await route.POST(
+      new Request('http://local/api/chats/sess_1/chat', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ message: 'Please run the long-lived task.' }),
+      }),
+      { params: Promise.resolve({ id: 'sess_1' }) },
+    )
+    const returnedAt = Date.now()
+
+    const reader = response.body.getReader()
+    const decoder = new TextDecoder()
+    const firstRead = await reader.read()
+    const firstChunk = decoder.decode(firstRead.value || new Uint8Array())
+    await reader.cancel()
+
+    await new Promise((resolve) => setTimeout(resolve, 220))
+
+    const session = storage.loadSessions().sess_1
+    const assistantReplies = (session.messages || [])
+      .filter((entry) => entry.role === 'assistant')
+      .map((entry) => entry.text)
+    const runStatuses = runs.listRuns({ sessionId: 'sess_1' }).map((entry) => entry.status)
+    const queueState = runs.getSessionExecutionState('sess_1')
+    const perfLabels = perf.getRecentEntries()
+      .filter((entry) => entry.category === 'chat-execution' || entry.category === 'queue')
+      .map((entry) => entry.category + '/' + entry.label)
+
+    console.log(JSON.stringify({
+      responseReturnedBeforeProviderFinished: providerFinishedAt > 0 && returnedAt < providerFinishedAt,
+      firstChunk,
+      assistantReplies,
+      runStatuses,
+      queueLength: queueState.queueLength,
+      perfLabels,
+      responseLatencyMs: returnedAt - startedAt,
+    }))
+  `, { prefix: 'swarmclaw-chat-route-test-' })
+
+  assert.equal(output.responseReturnedBeforeProviderFinished, true)
+  assert.match(output.firstChunk, /\\"status\\":\\"queued\\"/)
+  assert.deepEqual(output.assistantReplies, ['Long-lived work finished cleanly.'])
+  assert.ok(output.runStatuses.includes('completed'))
+  assert.equal(output.queueLength, 0)
+  assert.ok(output.perfLabels.includes('chat-execution/executeSessionChatTurn'))
+  assert.ok(output.perfLabels.includes('chat-execution/llm-round-trip'))
+})
+
+test('chat route heartbeat runs stay internal and do not persist terminal ack text', () => {
+  const output = runWithTempDataDir<{
+    events: Array<{ t?: string; text?: string }>
+    assistantReplies: string[]
+    queueLength: number
+  }>(`
+    const storageMod = await import('./src/lib/server/storage')
+    const providersMod = await import('@/lib/providers')
+    const routeMod = await import('./src/app/api/chats/[id]/chat/route')
+    const runsMod = await import('./src/lib/server/session-run-manager')
+    const storage = storageMod.default || storageMod
+    const providers = providersMod.default || providersMod
+    const route = routeMod.default || routeMod
+    const runs = runsMod.default || runsMod
+
+    providers.PROVIDERS['heartbeat-provider'] = {
+      id: 'heartbeat-provider',
+      name: 'Heartbeat Provider',
+      models: ['hb-model'],
+      requiresApiKey: false,
+      requiresEndpoint: false,
+      handler: {
+        streamChat: async (opts) => {
+          opts.write('data: ' + JSON.stringify({ t: 'r', text: 'HEARTBEAT_OK' }) + '\\n')
+          return 'HEARTBEAT_OK'
+        },
+      },
+    }
+
+    const now = Date.now()
+    storage.saveAgents({
+      agent_1: {
+        id: 'agent_1',
+        name: 'Heartbeat Agent',
+        provider: 'heartbeat-provider',
+        model: 'hb-model',
+        plugins: [],
+        heartbeatEnabled: true,
+        createdAt: now,
+        updatedAt: now,
+      },
+    })
+    storage.saveSessions({
+      sess_1: {
+        id: 'sess_1',
+        name: 'Heartbeat Session',
+        cwd: process.env.WORKSPACE_DIR,
+        user: 'workbench',
+        provider: 'heartbeat-provider',
+        model: 'hb-model',
+        claudeSessionId: null,
+        messages: [],
+        createdAt: now,
+        lastActiveAt: now,
+        sessionType: 'human',
+        agentId: 'agent_1',
+        heartbeatEnabled: true,
+        plugins: [],
+      },
+    })
+
+    async function readSse(response) {
+      const reader = response.body.getReader()
+      const decoder = new TextDecoder()
+      let buffer = ''
+      const events = []
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+        buffer += decoder.decode(value, { stream: true })
+        let idx = buffer.indexOf('\\n\\n')
+        while (idx !== -1) {
+          const chunk = buffer.slice(0, idx)
+          buffer = buffer.slice(idx + 2)
+          const line = chunk
+            .split('\\n')
+            .map((entry) => entry.trim())
+            .find((entry) => entry.startsWith('data: '))
+          if (line) {
+            events.push(JSON.parse(line.slice(6)))
+          }
+          idx = buffer.indexOf('\\n\\n')
+        }
+      }
+      return events
+    }
+
+    const response = await route.POST(
+      new Request('http://local/api/chats/sess_1/chat', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ message: 'SWARM_HEARTBEAT_CHECK', internal: true }),
+      }),
+      { params: Promise.resolve({ id: 'sess_1' }) },
+    )
+
+    const events = await readSse(response)
+    const session = storage.loadSessions().sess_1
+    const assistantReplies = (session.messages || [])
+      .filter((entry) => entry.role === 'assistant')
+      .map((entry) => entry.text)
+
+    console.log(JSON.stringify({
+      events,
+      assistantReplies,
+      queueLength: runs.getSessionExecutionState('sess_1').queueLength,
+    }))
+  `, { prefix: 'swarmclaw-chat-route-heartbeat-' })
+
+  assert.equal(output.events[0]?.t, 'md')
+  assert.match(String(output.events[0]?.text || ''), /"internal":true/)
+  assert.match(String(output.events[0]?.text || ''), /"source":"heartbeat"/)
+  assert.equal(output.events.at(-1)?.t, 'done')
+  assert.equal(output.assistantReplies.some((text) => /HEARTBEAT_OK/i.test(text)), false)
+  assert.equal(output.queueLength, 0)
+})
+
+test('chat route queues a second user message behind the first run and completes both in order', () => {
+  const output = runWithTempDataDir<{
+    firstRunMeta: string
+    secondRunMeta: string
+    assistantReplies: string[]
+    runStatuses: string[]
+  }>(`
+    const storageMod = await import('./src/lib/server/storage')
+    const providersMod = await import('@/lib/providers')
+    const routeMod = await import('./src/app/api/chats/[id]/chat/route')
+    const runsMod = await import('./src/lib/server/session-run-manager')
+    const storage = storageMod.default || storageMod
+    const providers = providersMod.default || providersMod
+    const route = routeMod.default || routeMod
+    const runs = runsMod.default || runsMod
+
+    providers.PROVIDERS['queue-provider'] = {
+      id: 'queue-provider',
+      name: 'Queue Provider',
+      models: ['queue-model'],
+      requiresApiKey: false,
+      requiresEndpoint: false,
+      handler: {
+        streamChat: async (opts) => {
+          await new Promise((resolve) => setTimeout(resolve, 80))
+          const reply = 'Completed: ' + opts.message
+          opts.write('data: ' + JSON.stringify({ t: 'r', text: reply }) + '\\n')
+          return reply
+        },
+      },
+    }
+
+    const now = Date.now()
+    storage.saveAgents({
+      agent_1: {
+        id: 'agent_1',
+        name: 'Queue Agent',
+        provider: 'queue-provider',
+        model: 'queue-model',
+        plugins: [],
+        createdAt: now,
+        updatedAt: now,
+      },
+    })
+    storage.saveSessions({
+      sess_1: {
+        id: 'sess_1',
+        name: 'Queued Session',
+        cwd: process.env.WORKSPACE_DIR,
+        user: 'workbench',
+        provider: 'queue-provider',
+        model: 'queue-model',
+        claudeSessionId: null,
+        messages: [],
+        createdAt: now,
+        lastActiveAt: now,
+        sessionType: 'human',
+        agentId: 'agent_1',
+        plugins: [],
+      },
+    })
+
+    async function readSse(response) {
+      const reader = response.body.getReader()
+      const decoder = new TextDecoder()
+      let buffer = ''
+      const events = []
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+        buffer += decoder.decode(value, { stream: true })
+        let idx = buffer.indexOf('\\n\\n')
+        while (idx !== -1) {
+          const chunk = buffer.slice(0, idx)
+          buffer = buffer.slice(idx + 2)
+          const line = chunk
+            .split('\\n')
+            .map((entry) => entry.trim())
+            .find((entry) => entry.startsWith('data: '))
+          if (line) {
+            events.push(JSON.parse(line.slice(6)))
+          }
+          idx = buffer.indexOf('\\n\\n')
+        }
+      }
+      return events
+    }
+
+    const response1 = await route.POST(
+      new Request('http://local/api/chats/sess_1/chat', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ message: 'first queued message' }),
+      }),
+      { params: Promise.resolve({ id: 'sess_1' }) },
+    )
+    const response2 = await route.POST(
+      new Request('http://local/api/chats/sess_1/chat', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ message: 'second queued message' }),
+      }),
+      { params: Promise.resolve({ id: 'sess_1' }) },
+    )
+
+    const [events1, events2] = await Promise.all([readSse(response1), readSse(response2)])
+    const session = storage.loadSessions().sess_1
+    const assistantReplies = (session.messages || [])
+      .filter((entry) => entry.role === 'assistant')
+      .map((entry) => entry.text)
+    console.log(JSON.stringify({
+      firstRunMeta: events1.find((entry) => entry.t === 'md')?.text || '',
+      secondRunMeta: events2.find((entry) => entry.t === 'md')?.text || '',
+      assistantReplies,
+      runStatuses: runs.listRuns({ sessionId: 'sess_1' }).map((entry) => entry.status),
+    }))
+  `, { prefix: 'swarmclaw-chat-route-plugins-' })
+
+  assert.match(output.firstRunMeta, /"position":0/)
+  assert.match(output.secondRunMeta, /"position":1/)
+  assert.deepEqual(output.assistantReplies, [
+    'Completed: first queued message',
+    'Completed: second queued message',
+  ])
+  assert.deepEqual(output.runStatuses, ['completed', 'completed'])
+})
+
+test('chat route forwards plugin-path tool activity when a plugin-enabled run uses streamAgentChat', () => {
+  const output = runWithTempDataDir<{
+    toolCalls: string[]
+    toolResults: string[]
+    assistantReplies: string[]
+  }>(`
+    const storageMod = await import('./src/lib/server/storage')
+    const providersMod = await import('@/lib/providers')
+    const routeMod = await import('./src/app/api/chats/[id]/chat/route')
+    const streamMod = await import('./src/lib/server/stream-agent-chat')
+    const storage = storageMod.default || storageMod
+    const providers = providersMod.default || providersMod
+    const route = routeMod.default || routeMod
+    const stream = streamMod.default || streamMod
+
+    providers.PROVIDERS['plugin-provider'] = {
+      id: 'plugin-provider',
+      name: 'Plugin Provider',
+      models: ['plugin-model'],
+      requiresApiKey: false,
+      requiresEndpoint: false,
+      handler: { streamChat: async () => '' },
+    }
+
+    const now = Date.now()
+    storage.saveAgents({
+      agent_1: {
+        id: 'agent_1',
+        name: 'Plugin Agent',
+        provider: 'plugin-provider',
+        model: 'plugin-model',
+        plugins: ['web'],
+        createdAt: now,
+        updatedAt: now,
+      },
+    })
+    storage.saveSessions({
+      sess_1: {
+        id: 'sess_1',
+        name: 'Plugin Session',
+        cwd: process.env.WORKSPACE_DIR,
+        user: 'workbench',
+        provider: 'plugin-provider',
+        model: 'plugin-model',
+        claudeSessionId: null,
+        messages: [],
+        createdAt: now,
+        lastActiveAt: now,
+        sessionType: 'human',
+        agentId: 'agent_1',
+        plugins: ['web'],
+      },
+    })
+
+    async function readSse(response) {
+      const reader = response.body.getReader()
+      const decoder = new TextDecoder()
+      let buffer = ''
+      const events = []
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+        buffer += decoder.decode(value, { stream: true })
+        let idx = buffer.indexOf('\\n\\n')
+        while (idx !== -1) {
+          const chunk = buffer.slice(0, idx)
+          buffer = buffer.slice(idx + 2)
+          const line = chunk
+            .split('\\n')
+            .map((entry) => entry.trim())
+            .find((entry) => entry.startsWith('data: '))
+          if (line) {
+            events.push(JSON.parse(line.slice(6)))
+          }
+          idx = buffer.indexOf('\\n\\n')
+        }
+      }
+      return events
+    }
+
+    stream.setStreamAgentChatForTest(async (opts) => {
+      opts.write('data: ' + JSON.stringify({
+        t: 'tool_call',
+        toolName: 'web',
+        toolInput: JSON.stringify({ q: 'queue health' }),
+        toolCallId: 'tool-1',
+      }) + '\\n')
+      opts.write('data: ' + JSON.stringify({
+        t: 'tool_result',
+        toolName: 'web',
+        toolOutput: 'Fetched queue health summary',
+        toolCallId: 'tool-1',
+      }) + '\\n')
+      const reply = 'Queue looks healthy and no plugin errors were observed.'
+      opts.write('data: ' + JSON.stringify({ t: 'r', text: reply }) + '\\n')
+      return { fullText: reply, finalResponse: reply }
+    })
+
+    try {
+      const response = await route.POST(
+        new Request('http://local/api/chats/sess_1/chat', {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ message: 'Check queue health with tools.' }),
+        }),
+        { params: Promise.resolve({ id: 'sess_1' }) },
+      )
+
+      const events = await readSse(response)
+      const session = storage.loadSessions().sess_1
+      const assistantReplies = (session.messages || [])
+        .filter((entry) => entry.role === 'assistant')
+        .map((entry) => entry.text)
+      console.log(JSON.stringify({
+        toolCalls: events.filter((entry) => entry.t === 'tool_call').map((entry) => entry.toolName),
+        toolResults: events.filter((entry) => entry.t === 'tool_result').map((entry) => entry.toolOutput),
+        assistantReplies,
+      }))
+    } finally {
+      stream.setStreamAgentChatForTest(null)
+    }
+  `, { prefix: 'swarmclaw-chat-route-plugin-events-' })
+
+  assert.deepEqual(output.toolCalls, ['web'])
+  assert.deepEqual(output.toolResults, ['Fetched queue health summary'])
+  assert.deepEqual(output.assistantReplies, ['Queue looks healthy and no plugin errors were observed.'])
+})

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

@@ -26,6 +26,7 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
 
   const encoder = new TextEncoder()
   let abortRun: (() => void) | null = null
+  let unsubscribeRun: (() => void) | null = null
   const stream = new ReadableStream({
     start(controller) {
       let closed = false
@@ -54,6 +55,7 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
         callerSignal: internal ? req.signal : undefined,
       })
       abortRun = run.abort
+      unsubscribeRun = run.unsubscribe
 
       log.info('chat', `Enqueued session run ${run.runId}`, {
         sessionId: id,
@@ -91,9 +93,11 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
         })
     },
     cancel() {
-      // Client disconnected. User-facing runs continue in the background so
-      // they can persist results even when the transport drops. Explicit stop
-      // controls still cancel the run through the session run manager.
+      // Client disconnected — always remove this subscriber's listener to
+      // prevent writes to a closed stream (and free the closure).
+      unsubscribeRun?.()
+      // User-facing runs continue in the background so they can persist
+      // results even when the transport drops. Internal runs are aborted.
       if (internal) abortRun?.()
     },
   })

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

@@ -1,20 +1,20 @@
 import { NextResponse } from 'next/server'
-import { loadSessions, saveSessions } from '@/lib/server/storage'
+import { loadSession, upsertSession } from '@/lib/server/storage'
 import { notFound } from '@/lib/server/collection-helpers'
 
 export async function POST(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const sessions = loadSessions()
-  if (!sessions[id]) return notFound()
-  sessions[id].messages = []
-  sessions[id].claudeSessionId = null
-  sessions[id].codexThreadId = null
-  sessions[id].opencodeSessionId = null
-  sessions[id].delegateResumeIds = {
+  const session = loadSession(id)
+  if (!session) return notFound()
+  session.messages = []
+  session.claudeSessionId = null
+  session.codexThreadId = null
+  session.opencodeSessionId = null
+  session.delegateResumeIds = {
     claudeCode: null,
     codex: null,
     opencode: null,
   }
-  saveSessions(sessions)
+  upsertSession(id, session)
   return new NextResponse('OK')
 }

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

@@ -3,6 +3,7 @@ import { spawn } from 'child_process'
 import { loadSessions, devServers, localIP } from '@/lib/server/storage'
 import { notFound } from '@/lib/server/collection-helpers'
 import { resolveDevServerLaunchDir } from '@/lib/server/devserver-launch'
+import { sleep } from '@/lib/shared-utils'
 import net from 'net'
 
 interface DevServerStartResult {
@@ -65,7 +66,7 @@ async function startDevServer(id: string, session: { cwd: string }): Promise<Dev
   devServers.set(id, { proc, url: `http://${localIP()}:${port}` })
   console.log(`[${id}] starting dev server in ${launch.launchDir} (session cwd=${session.cwd})`)
 
-  await new Promise((resolve) => setTimeout(resolve, 4000))
+  await sleep(4000)
   const ds = devServers.get(id)
   if (!ds) {
     return {

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

@@ -1,12 +1,11 @@
 import { NextResponse } from 'next/server'
-import { loadSessions, saveSessions } from '@/lib/server/storage'
+import { loadSession, upsertSession } from '@/lib/server/storage'
 import { notFound } from '@/lib/server/collection-helpers'
 
 export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const body = await req.json().catch(() => ({})) as { messageIndex: number; newText: string }
-  const sessions = loadSessions()
-  const session = sessions[id]
+  const session = loadSession(id)
   if (!session) return notFound()
 
   const { messageIndex, newText } = body
@@ -16,7 +15,7 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
 
   // Truncate messages to messageIndex (discard that msg + everything after)
   session.messages = session.messages.slice(0, messageIndex)
-  saveSessions(sessions)
+  upsertSession(id, session)
 
   return NextResponse.json({ message: newText })
 }

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

@@ -1,13 +1,12 @@
 import { NextResponse } from 'next/server'
 import { randomUUID } from 'node:crypto'
-import { loadSessions, saveSessions } from '@/lib/server/storage'
+import { loadSession, upsertSession } from '@/lib/server/storage'
 import { notFound } from '@/lib/server/collection-helpers'
 
 export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const body = await req.json().catch(() => ({})) as { messageIndex: number }
-  const sessions = loadSessions()
-  const source = sessions[id]
+  const source = loadSession(id)
   if (!source) return notFound()
 
   const { messageIndex } = body
@@ -37,8 +36,7 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
     conversationTone: source.conversationTone,
   }
 
-  sessions[newId] = forked
-  saveSessions(sessions)
+  upsertSession(newId, forked)
 
   return NextResponse.json(forked)
 }