@swarmclawai/swarmclaw 1.3.6 → 1.4.0

package/src/lib/providers/openai.ts

@@ -23,7 +23,7 @@ async function fileToContentParts(filePath: string): Promise<Array<Record<string
   }
   if (filePath.endsWith('.pdf')) {
     try {
-      // @ts-ignore — pdf-parse types
+      // @ts-expect-error — pdf-parse types
       const pdfParse = (await import(/* webpackIgnore: true */ 'pdf-parse')).default
       const buf = await fs.promises.readFile(filePath)
       const result = await pdfParse(buf)
@@ -45,153 +45,157 @@ async function fileToContentParts(filePath: string): Promise<Array<Record<string
 }
 
 export function streamOpenAiChat({ session, message, imagePath, imageUrl, apiKey, systemPrompt, write, active, loadHistory, onUsage, signal }: StreamChatOptions): Promise<string> {
-  return new Promise(async (resolve, reject) => {
-    const messages = await buildMessages(session, message, imagePath, systemPrompt, loadHistory, imageUrl)
-    const model = session.model || 'gpt-4o'
-
-    let fullResponse = ''
-
-    // Support custom base URLs for custom providers
-    const baseUrl = session.apiEndpoint || PROVIDER_DEFAULTS.openai
-    const url = `${baseUrl.replace(/\/+$/, '')}/chat/completions`
-
-    // OpenClaw endpoints behind Hostinger's proxy use express.json() middleware
-    // which consumes the request body before http-proxy-middleware can forward it.
-    // Sending as text/plain bypasses the body parser while the gateway still parses JSON.
-    const contentType = session.contentType || 'application/json'
-
-    const abortController = new AbortController()
-    if (signal) {
-      if (signal.aborted) abortController.abort()
-      else signal.addEventListener('abort', () => abortController.abort(), { once: true })
-    }
-    active.set(session.id, { kill: () => abortController.abort() })
-
-    try {
-      // Try with stream_options first; if the provider rejects with 400, retry without it
-      let res: Response | undefined
-      let usageEnabled = true
-      for (const includeStreamOptions of [true, false]) {
-        const payloadObj: Record<string, unknown> = {
-          model,
-          messages,
-          stream: true,
-        }
-        if (includeStreamOptions) {
-          payloadObj.stream_options = { include_usage: true }
+  return new Promise((resolve, reject) => {
+    ;(async () => {
+      try {
+        const messages = await buildMessages(session, message, imagePath, systemPrompt, loadHistory, imageUrl)
+        const model = session.model || 'gpt-4o'
+
+        let fullResponse = ''
+
+        // Support custom base URLs for custom providers
+        const baseUrl = session.apiEndpoint || PROVIDER_DEFAULTS.openai
+        const url = `${baseUrl.replace(/\/+$/, '')}/chat/completions`
+
+        // OpenClaw endpoints behind Hostinger's proxy use express.json() middleware
+        // which consumes the request body before http-proxy-middleware can forward it.
+        // Sending as text/plain bypasses the body parser while the gateway still parses JSON.
+        const contentType = session.contentType || 'application/json'
+
+        const abortController = new AbortController()
+        if (signal) {
+          if (signal.aborted) abortController.abort()
+          else signal.addEventListener('abort', () => abortController.abort(), { once: true })
         }
-        const payload = JSON.stringify(payloadObj)
-
-        res = await fetch(url, {
-          method: 'POST',
-          headers: {
-            'Authorization': `Bearer ${apiKey}`,
-            'Content-Type': contentType,
-          },
-          body: payload,
-          signal: abortController.signal,
-        })
-
-        if (res.status === 400 && includeStreamOptions) {
-          // Provider likely rejected stream_options — retry without it
-          usageEnabled = false
-          continue
-        }
-        usageEnabled = includeStreamOptions
-        break
-      }
-
-      if (!res) {
-        active.delete(session.id)
-        reject(new Error('No response from provider'))
-        return
-      }
-
-      // Detect HTML responses (e.g. landing page returned instead of API)
-      const resContentType = res.headers.get('content-type') || ''
-      if (resContentType.includes('text/html')) {
-        const msg = 'Received HTML instead of API response. The endpoint may be misconfigured or returning a landing page.'
-        log.error(TAG, `[${session.id}] received HTML instead of API response from ${baseUrl} (provider: ${session.provider})`)
-        writeSSE(write, 'err', msg)
-        active.delete(session.id)
-        reject(new Error(msg))
-        return
-      }
+        active.set(session.id, { kill: () => abortController.abort() })
 
-      if (!res.ok) {
-        const errBody = await res.text().catch(() => '')
-        log.error(TAG, `[${session.id}] openai error ${res.status}:`, errBody.slice(0, 200))
-        let errMsg = `API error (${res.status})`
         try {
-          const parsed = JSON.parse(errBody)
-          if (parsed.error?.message) errMsg = parsed.error.message
-          else if (parsed.message) errMsg = parsed.message
-          else if (parsed.detail) errMsg = parsed.detail
-        } catch {}
-        writeSSE(write, 'err', errMsg)
-        active.delete(session.id)
-        reject(new Error(`OpenAI error ${res.status}: ${errMsg}`))
-        return
-      }
-
-      if (!res.body) {
-        const msg = `No response body from ${baseUrl}`
-        log.error(TAG, `[${session.id}] ${msg}`)
-        active.delete(session.id)
-        reject(new Error(msg))
-        return
-      }
-
-      const reader = res.body.getReader()
-      const decoder = new TextDecoder()
-      let buf = ''
-
-      while (true) {
-        const { done, value } = await reader.read()
-        if (done) break
-        if (abortController.signal.aborted) break
-
-        buf += decoder.decode(value, { stream: true })
-        const lines = buf.split('\n')
-        buf = lines.pop()!
-
-        for (const line of lines) {
-          if (!line.startsWith('data: ')) continue
-          const data = line.slice(6).trim()
-          if (data === '[DONE]') continue
-          try {
-            const parsed = JSON.parse(data)
-            const delta = parsed.choices?.[0]?.delta?.content
-            if (delta) {
-              fullResponse += delta
-              writeSSE(write, 'd', delta)
+          // Try with stream_options first; if the provider rejects with 400, retry without it
+          let res: Response | undefined
+          let usageEnabled = true
+          for (const includeStreamOptions of [true, false]) {
+            const payloadObj: Record<string, unknown> = {
+              model,
+              messages,
+              stream: true,
+            }
+            if (includeStreamOptions) {
+              payloadObj.stream_options = { include_usage: true }
             }
-            // Extract usage from the final chunk (stream_options: include_usage)
-            if (usageEnabled && parsed.usage && onUsage) {
-              onUsage({
-                inputTokens: parsed.usage.prompt_tokens || 0,
-                outputTokens: parsed.usage.completion_tokens || 0,
-              })
+            const payload = JSON.stringify(payloadObj)
+
+            res = await fetch(url, {
+              method: 'POST',
+              headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': contentType,
+              },
+              body: payload,
+              signal: abortController.signal,
+            })
+
+            if (res.status === 400 && includeStreamOptions) {
+              // Provider likely rejected stream_options — retry without it
+              usageEnabled = false
+              continue
             }
-          } catch {}
+            usageEnabled = includeStreamOptions
+            break
+          }
+
+          if (!res) {
+            active.delete(session.id)
+            reject(new Error('No response from provider'))
+            return
+          }
+
+          // Detect HTML responses (e.g. landing page returned instead of API)
+          const resContentType = res.headers.get('content-type') || ''
+          if (resContentType.includes('text/html')) {
+            const msg = 'Received HTML instead of API response. The endpoint may be misconfigured or returning a landing page.'
+            log.error(TAG, `[${session.id}] received HTML instead of API response from ${baseUrl} (provider: ${session.provider})`)
+            writeSSE(write, 'err', msg)
+            active.delete(session.id)
+            reject(new Error(msg))
+            return
+          }
+
+          if (!res.ok) {
+            const errBody = await res.text().catch(() => '')
+            log.error(TAG, `[${session.id}] openai error ${res.status}:`, errBody.slice(0, 200))
+            let errMsg = `API error (${res.status})`
+            try {
+              const parsed = JSON.parse(errBody)
+              if (parsed.error?.message) errMsg = parsed.error.message
+              else if (parsed.message) errMsg = parsed.message
+              else if (parsed.detail) errMsg = parsed.detail
+            } catch {}
+            writeSSE(write, 'err', errMsg)
+            active.delete(session.id)
+            reject(new Error(`OpenAI error ${res.status}: ${errMsg}`))
+            return
+          }
+
+          if (!res.body) {
+            const msg = `No response body from ${baseUrl}`
+            log.error(TAG, `[${session.id}] ${msg}`)
+            active.delete(session.id)
+            reject(new Error(msg))
+            return
+          }
+
+          const reader = res.body.getReader()
+          const decoder = new TextDecoder()
+          let buf = ''
+
+          while (true) {
+            const { done, value } = await reader.read()
+            if (done) break
+            if (abortController.signal.aborted) break
+
+            buf += decoder.decode(value, { stream: true })
+            const lines = buf.split('\n')
+            buf = lines.pop()!
+
+            for (const line of lines) {
+              if (!line.startsWith('data: ')) continue
+              const data = line.slice(6).trim()
+              if (data === '[DONE]') continue
+              try {
+                const parsed = JSON.parse(data)
+                const delta = parsed.choices?.[0]?.delta?.content
+                if (delta) {
+                  fullResponse += delta
+                  writeSSE(write, 'd', delta)
+                }
+                // Extract usage from the final chunk (stream_options: include_usage)
+                if (usageEnabled && parsed.usage && onUsage) {
+                  onUsage({
+                    inputTokens: parsed.usage.prompt_tokens || 0,
+                    outputTokens: parsed.usage.completion_tokens || 0,
+                  })
+                }
+              } catch {}
+            }
+          }
+
+          if (!fullResponse) {
+            log.error(TAG, `[${session.id}] openai stream ended with no content (provider: ${session.provider}, endpoint: ${baseUrl})`)
+          }
+        } catch (err: unknown) {
+          const errObj = err as { name?: string; message?: string }
+          if (errObj.name !== 'AbortError') {
+            log.error(TAG, `[${session.id}] openai request error:`, errObj.message)
+            writeSSE(write, 'err', `Connection failed: ${errObj.message}`)
+          }
+          active.delete(session.id)
+          reject(err)
+          return
         }
-      }
-
-      if (!fullResponse) {
-        log.error(TAG, `[${session.id}] openai stream ended with no content (provider: ${session.provider}, endpoint: ${baseUrl})`)
-      }
-    } catch (err: unknown) {
-      const errObj = err as { name?: string; message?: string }
-      if (errObj.name !== 'AbortError') {
-        log.error(TAG, `[${session.id}] openai request error:`, errObj.message)
-        writeSSE(write, 'err', `Connection failed: ${errObj.message}`)
-      }
-      active.delete(session.id)
-      reject(err)
-      return
-    }
-    active.delete(session.id)
-    resolve(fullResponse)
+        active.delete(session.id)
+        resolve(fullResponse)
+      } catch (err) { reject(err) }
+    })()
   })
 }
 

package/src/lib/server/agents/main-agent-loop.test.ts

@@ -346,6 +346,100 @@ describe('main-agent-loop', () => {
     assert.equal(output.followupMessage, null)
   })
 
+  it('accepts structured autonomy ticks for durable objectives without falling back to legacy tags', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('@/lib/server/storage')
+      const mainLoopMod = await import('@/lib/server/agents/main-agent-loop')
+      const storage = storageMod.default || storageMod
+      const mainLoop = mainLoopMod.default || mainLoopMod
+
+      storage.saveAgents({
+        'agent-a': {
+          id: 'agent-a',
+          name: 'Agent A',
+          provider: 'openai',
+          model: 'gpt-test',
+        },
+      })
+
+      storage.saveSessions({
+        main: {
+          id: 'main',
+          name: 'Main Agent Thread',
+          shortcutForAgentId: 'agent-a',
+          cwd: process.cwd(),
+          user: 'tester',
+          provider: 'openai',
+          model: 'gpt-test',
+          claudeSessionId: null,
+          messages: [],
+          createdAt: 1,
+          lastActiveAt: 1,
+          sessionType: 'human',
+          agentId: 'agent-a',
+          heartbeatEnabled: true,
+          missionId: 'mission-1',
+        },
+      })
+
+      storage.saveMissions({
+        'mission-1': {
+          id: 'mission-1',
+          source: 'heartbeat',
+          objective: 'Ship the autonomy hardening release',
+          status: 'active',
+          phase: 'executing',
+          sessionId: 'main',
+          agentId: 'agent-a',
+          taskIds: [],
+          currentStep: 'Verify the release checklist',
+          plannerSummary: 'Use the durable controller state.',
+          verifierSummary: null,
+          blockerSummary: null,
+          waitState: null,
+          createdAt: 1,
+          updatedAt: Date.now(),
+        },
+      })
+
+      const prompt = mainLoop.buildMainLoopHeartbeatPrompt(storage.loadSessions().main, 'fallback heartbeat')
+      mainLoop.handleMainLoopRunResult({
+        sessionId: 'main',
+        message: 'Heartbeat tick',
+        internal: true,
+        source: 'heartbeat',
+        resultText: [
+          'Validated the release checklist.',
+          '[AUTONOMY_TICK]{"status":"progress","summary":"Release checklist validated.","next_action":"publish release artifacts","plan_steps":["verify artifacts","publish release artifacts"],"current_step":"verify artifacts","completed_steps":["Verify the release checklist"],"review":{"note":"Ready for artifact publication.","confidence":0.88,"needs_replan":false}}',
+        ].join('\\n'),
+      })
+      const state = mainLoop.getMainLoopStateForSession('main')
+
+      console.log(JSON.stringify({
+        promptIncludesAutonomyTick: prompt.includes('[AUTONOMY_TICK]'),
+        promptIncludesLegacyPlanTags: prompt.includes('[MAIN_LOOP_PLAN]'),
+        stateStatus: state?.status || null,
+        stateSummary: state?.summary || null,
+        stateNextAction: state?.nextAction || null,
+        statePlanSteps: state?.planSteps || [],
+        stateCurrentPlanStep: state?.currentPlanStep || null,
+        stateCompletedPlanSteps: state?.completedPlanSteps || [],
+        stateReviewNote: state?.reviewNote || null,
+      }))
+    `)
+
+    assert.equal(output.promptIncludesAutonomyTick, true)
+    assert.equal(output.promptIncludesLegacyPlanTags, false)
+    assert.equal(output.stateStatus, 'progress')
+    assert.match(String(output.stateSummary), /validated/i)
+    assert.equal(output.stateNextAction, 'publish release artifacts')
+    assert.ok((output.statePlanSteps as string[]).includes('verify artifacts'))
+    assert.ok((output.statePlanSteps as string[]).includes('publish release artifacts'))
+    assert.equal(output.stateCurrentPlanStep, 'verify artifacts')
+    assert.ok((output.stateCompletedPlanSteps as string[]).includes('Verify the release checklist'))
+    assert.match(String(output.stateReviewNote), /artifact publication/i)
+  })
+
   it('does not let internal heartbeat prompts rewrite the stored goal contract', () => {
     const output = runWithTempDataDir(`
       const storageMod = await import('@/lib/server/storage')