@swarmclawai/swarmclaw 1.2.8 → 1.2.9

package/src/lib/server/chat-execution/stream-continuation.test.ts

@@ -46,36 +46,6 @@ describe('stream-continuation', () => {
     })
   })
 
-  // ---- looksLikeExternalWalletTask ----
-  describe('looksLikeExternalWalletTask', () => {
-    it('matches wallet keywords', () => {
-      assert.equal(mod.looksLikeExternalWalletTask('swap 100 USDC on Arbitrum'), true)
-      assert.equal(mod.looksLikeExternalWalletTask('check my wallet balance'), true)
-      assert.equal(mod.looksLikeExternalWalletTask('trade ETH for SOL'), true)
-    })
-
-    it('returns false for empty/unrelated text', () => {
-      assert.equal(mod.looksLikeExternalWalletTask(''), false)
-      assert.equal(mod.looksLikeExternalWalletTask('write me a poem about cats'), false)
-    })
-  })
-
-  // ---- looksLikeBoundedExternalExecutionTask ----
-  describe('looksLikeBoundedExternalExecutionTask', () => {
-    it('requires wallet keywords + action verbs', () => {
-      assert.equal(mod.looksLikeBoundedExternalExecutionTask('swap 100 USDC on Arbitrum'), true)
-      assert.equal(mod.looksLikeBoundedExternalExecutionTask('buy ETH on the exchange'), true)
-    })
-
-    it('returns false without action verbs', () => {
-      assert.equal(mod.looksLikeBoundedExternalExecutionTask('check my wallet balance'), false)
-    })
-
-    it('returns false for non-wallet text', () => {
-      assert.equal(mod.looksLikeBoundedExternalExecutionTask('execute the test suite'), false)
-    })
-  })
-
   // ---- looksLikeOpenEndedDeliverableTask ----
   describe('looksLikeOpenEndedDeliverableTask', () => {
     it('matches deliverable patterns', () => {
@@ -112,24 +82,6 @@ describe('stream-continuation', () => {
     })
   })
 
-  // ---- hasStateChangingWalletEvidence ----
-  describe('hasStateChangingWalletEvidence', () => {
-    it('detects send_transaction action in wallet_tool', () => {
-      const events = [{ name: 'wallet_tool', input: '{"action":"send_transaction"}', output: '{}' }]
-      assert.equal(mod.hasStateChangingWalletEvidence(events), true)
-    })
-
-    it('returns false for non-wallet tools', () => {
-      const events = [{ name: 'web', input: 'search', output: 'results' }]
-      assert.equal(mod.hasStateChangingWalletEvidence(events), false)
-    })
-
-    it('returns false for read-only wallet actions', () => {
-      const events = [{ name: 'wallet_tool', input: '{"action":"balance"}', output: '{}' }]
-      assert.equal(mod.hasStateChangingWalletEvidence(events), false)
-    })
-  })
-
   // ---- countExternalExecutionResearchSteps ----
   describe('countExternalExecutionResearchSteps', () => {
     it('counts http/web/browser tools', () => {
@@ -141,12 +93,12 @@ describe('stream-continuation', () => {
       assert.equal(mod.countExternalExecutionResearchSteps(events), 2)
     })
 
-    it('counts read-only wallet actions', () => {
+    it('does not count non-research tools', () => {
       const events = [
-        { name: 'wallet_tool', input: '{"action":"balance"}', output: '{}' },
-        { name: 'wallet_tool', input: '{"action":"send_transaction"}', output: '{}' },
+        { name: 'shell', input: 'ls', output: 'files' },
+        { name: 'files', input: 'read', output: 'content' },
       ]
-      assert.equal(mod.countExternalExecutionResearchSteps(events), 1)
+      assert.equal(mod.countExternalExecutionResearchSteps(events), 0)
     })
   })
 

package/src/lib/server/chat-execution/stream-continuation.ts

@@ -194,25 +194,9 @@ function getRequestedArtifactStatus(params: {
 // Tool evidence analysis
 // ---------------------------------------------------------------------------
 
-export function hasStateChangingWalletEvidence(toolEvents: MessageToolEvent[]): boolean {
-  return toolEvents.some((event) => {
-    const input = `${event.input || ''}\n${event.output || ''}`
-    return event.name === 'wallet_tool' && (
-      /"action":"send_transaction"/.test(input)
-      || /"action":"send"/.test(input)
-      || /"action":"sign_transaction"/.test(input)
-      || /"type":"extension_wallet_action_request"/.test(input)
-      || /"type":"extension_wallet_transfer_request"/.test(input)
-      || /"status":"broadcast"/.test(input)
-    )
-  })
-}
-
 export function countExternalExecutionResearchSteps(toolEvents: MessageToolEvent[]): number {
   return toolEvents.filter((event) => {
-    if (['http_request', 'web', 'web_search', 'web_fetch', 'browser'].includes(event.name)) return true
-    if (event.name !== 'wallet_tool') return false
-    return /"action":"(balance|address|transactions|call_contract|encode_contract_call)"/.test(event.input || '')
+    return ['http_request', 'web', 'web_search', 'web_fetch', 'browser'].includes(event.name)
   }).length
 }
 
@@ -238,49 +222,24 @@ export function countDistinctExternalResearchHosts(toolEvents: MessageToolEvent[
 // Continuation decision helpers
 // ---------------------------------------------------------------------------
 
-export function shouldForceExternalExecutionFollowthrough(params: {
+export function shouldForceExternalExecutionFollowthrough(_params: {
   userMessage: string
   finalResponse: string
   hasToolCalls: boolean
   toolEvents: MessageToolEvent[]
   classification?: MessageClassification | null
 }): boolean {
-  const isTransactional = params.classification?.walletIntent === 'transactional'
-  if (!isTransactional) return false
-  if (!params.hasToolCalls || params.toolEvents.length < 4) return false
-  if (hasStateChangingWalletEvidence(params.toolEvents)) return false
-  const distinctHosts = countDistinctExternalResearchHosts(params.toolEvents)
-  const trimmed = params.finalResponse.trim()
-  if (!trimmed) return countExternalExecutionResearchSteps(params.toolEvents) >= 4 || distinctHosts >= 3
-  if (/\b(last reversible step|exact blocker|safest next action|blocked|cannot|can't|missing capability|no-key route unavailable)\b/i.test(trimmed)) {
-    return false
-  }
-  if (countExternalExecutionResearchSteps(params.toolEvents) < 4 && distinctHosts < 3) return false
-  return /(let me|i'll|i will|trying|research|query|check|look|promising|now let me|good -|good,)/i.test(trimmed) || trimmed.length < 500
+  return false
 }
 
-export function shouldForceExternalExecutionKickoffFollowthrough(params: {
+export function shouldForceExternalExecutionKickoffFollowthrough(_params: {
   userMessage: string
   finalResponse: string
   hasToolCalls: boolean
   toolEvents: MessageToolEvent[]
   classification?: MessageClassification | null
 }): boolean {
-  const isTransactional = params.classification?.walletIntent === 'transactional'
-  if (!isTransactional) return false
-  if (params.hasToolCalls || params.toolEvents.length > 0) return false
-
-  const trimmed = params.finalResponse.trim()
-  if (!trimmed) return true
-  if (/^(?:HEARTBEAT_OK|NO_MESSAGE)\b/i.test(trimmed)) return false
-  if (/\?\s*$/.test(trimmed)) return false
-  if (/\b(last reversible step|exact blocker|blocked|cannot|can't|missing capability|need approval|requires approval|approval boundary|requires human|ask_human|credential|authentication|login|2fa|mfa|captcha)\b/i.test(trimmed)) {
-    return false
-  }
-  if (/\b(done|completed|finished|sent|broadcast|minted|purchased|bought|swapped|claimed)\b/i.test(trimmed)) {
-    return false
-  }
-  return looksLikeIncompleteDeliverableResponse(trimmed) || trimmed.length < 220
+  return false
 }
 
 export function shouldForceDeliverableFollowthrough(params: {
@@ -454,8 +413,7 @@ function buildExternalExecutionFollowthroughPrompt(params: {
     'You are in a bounded external execution task and have already done enough research.',
     'Do not restart broad discovery. Do not ask the user for another prompt.',
     'Do not spend this continuation on more venue shopping. Use the already confirmed route unless one last fetch is strictly required to prepare execution.',
-    'If several venue or aggregator APIs already failed, stop searching for more venues. Either use a direct onchain read path with the available wallet tools, or state the blocker.',
-    'A prose approval request does not count as completion. If the next step is a sign/send/approve action, call the real wallet tool action so the runtime can create the approval request.',
+    'If several venue or aggregator APIs already failed, stop searching for more venues and state the blocker.',
     'Do not mutate already confirmed token addresses, router addresses, spender addresses, or network identifiers unless newer tool evidence proves the earlier value was wrong.',
     'Within this continuation, do exactly one of the following:',
     '1. Take the next concrete execution step now using the existing tools and stop at the first approval boundary for a state-changing action.',

package/src/lib/server/chatrooms/session-mailbox.ts

@@ -1,7 +1,6 @@
 import { genId } from '@/lib/id'
 import type { MailboxEnvelope } from '@/types'
 import { loadSession, patchSession } from '@/lib/server/sessions/session-repository'
-import { requestMissionTicksForHumanReply } from '@/lib/server/missions/mission-service'
 
 interface MailboxOptions {
   limit?: number
@@ -167,15 +166,6 @@ export function sendMailboxEnvelope(input: {
       lastActiveAt: now,
     }
   })
-  if (envelope.type === 'human_reply') {
-    requestMissionTicksForHumanReply({
-      sessionId: input.toSessionId,
-      correlationId: envelope.correlationId || null,
-      envelopeId: envelope.id,
-      payload: envelope.payload,
-      fromSessionId: envelope.fromSessionId || null,
-    })
-  }
   import('@/lib/server/runtime/watch-jobs')
     .then(({ triggerMailboxWatchJobs }) => {
       triggerMailboxWatchJobs({ sessionId: input.toSessionId, envelope })

package/src/lib/server/chats/chat-session-service.ts

@@ -7,7 +7,6 @@ import { buildAgentDisabledMessage, isAgentDisabled } from '@/lib/server/agents/
 import { loadAgent } from '@/lib/server/agents/agent-repository'
 import { clearMainLoopStateForSession } from '@/lib/server/agents/main-agent-loop'
 import { applyResolvedRoute, resolvePrimaryAgentRoute } from '@/lib/server/agents/agent-runtime-config'
-import { enrichSessionWithMissionSummary } from '@/lib/server/missions/mission-service'
 import { cleanupSessionProcesses } from '@/lib/server/runtime/process-manager'
 import { stopActiveSessionProcess } from '@/lib/server/runtime/runtime-state'
 import {
@@ -60,7 +59,7 @@ export function listChatsForApi(): Record<string, ReturnType<typeof buildSession
     sessions[id].currentRunId = run.runningRunId || null
   }
   return Object.fromEntries(
-    Object.entries(sessions).map(([id, session]) => [id, buildSessionListSummary(enrichSessionWithMissionSummary(session))]),
+    Object.entries(sessions).map(([id, session]) => [id, buildSessionListSummary(session)]),
   )
 }
 
@@ -72,7 +71,7 @@ export function getChatSessionForApi(sessionId: string): Session | null {
   session.active = !!run.runningRunId
   session.queuedCount = queue.queueLength
   session.currentRunId = run.runningRunId || null
-  return enrichSessionWithMissionSummary(session)
+  return session
 }
 
 export function createChatSession(input: Record<string, unknown>): ServiceResult<Session> {
@@ -285,7 +284,7 @@ export function updateChatSession(sessionId: string, updates: Record<string, unk
 
   saveSession(sessionId, original)
   notify('sessions')
-  return enrichSessionWithMissionSummary(original)
+  return original
 }
 
 export function deleteChatSession(sessionId: string): boolean {
@@ -320,7 +319,6 @@ export function queueChatMessage(sessionId: string, body: Record<string, unknown
   }
   const queued = enqueueSessionRun({
     sessionId,
-    missionId: session.missionId || null,
     message,
     imagePath,
     imageUrl,

package/src/lib/server/connectors/connector-inbound.ts

@@ -1095,7 +1095,6 @@ If media sending fails, report the exact error and retry with a corrected path/t
 
     const queued = enqueueSessionRun({
       sessionId: session.id,
-      missionId: session.missionId || null,
       message: modelInputText,
       imagePath: firstImagePath,
       imageUrl: firstImageUrl,

package/src/lib/server/connectors/connector-lifecycle.ts

@@ -19,6 +19,7 @@ import {
   setReconnectState,
 } from './reconnect-state'
 import { connectorRuntimeState, runningConnectors } from './runtime-state'
+import { ensureSwarmdockConnectorCredential } from './swarmdock-secret'
 
 const TAG = 'connector-lifecycle'
 
@@ -70,6 +71,7 @@ export async function getPlatform(platform: string) {
     case 'googlechat': return (await import('./googlechat')).default
     case 'matrix':    return (await import('./matrix')).default
     case 'email':     return (await import('./email')).default
+    case 'swarmdock': return (await import('./swarmdock')).default
   }
 
   // 2. Check Extension-provided connectors
@@ -134,8 +136,9 @@ async function _startConnectorImpl(connectorId: string): Promise<void> {
   }
 
   const connectors = loadConnectors()
-  const connector = connectors[connectorId] as Connector | undefined
-  if (!connector) throw new Error('Connector not found')
+  const storedConnector = connectors[connectorId] as Connector | undefined
+  if (!storedConnector) throw new Error('Connector not found')
+  let connector: Connector = storedConnector
 
   // Starting a connector expresses durable intent: keep it enabled across
   // transient failures so daemon recovery and server restarts can retry it.
@@ -148,6 +151,16 @@ async function _startConnectorImpl(connectorId: string): Promise<void> {
   }
 
   try {
+    let swarmdockFallbackPrivateKey: string | null = null
+    if (connector.platform === 'swarmdock') {
+      const prepared = ensureSwarmdockConnectorCredential(connector, {
+        allowMigrationFailureFallback: true,
+      })
+      connector = prepared.connector
+      connectors[connectorId] = connector
+      swarmdockFallbackPrivateKey = prepared.fallbackPrivateKey
+    }
+
     // Resolve bot token from credential
     let botToken = ''
     if (connector.credentialId) {
@@ -164,8 +177,11 @@ async function _startConnectorImpl(connectorId: string): Promise<void> {
     if (!botToken && connector.platform === 'bluebubbles' && connector.config.password) {
       botToken = connector.config.password
     }
+    if (!botToken && swarmdockFallbackPrivateKey) {
+      botToken = swarmdockFallbackPrivateKey
+    }
 
-    if (!botToken && connector.platform !== 'whatsapp' && connector.platform !== 'openclaw' && connector.platform !== 'signal' && connector.platform !== 'email') {
+    if (!botToken && connector.platform !== 'whatsapp' && connector.platform !== 'openclaw' && connector.platform !== 'signal' && connector.platform !== 'email' && connector.platform !== 'swarmdock') {
       throw new Error('No bot token configured')
     }
 

package/src/lib/server/connectors/connector-service.ts

@@ -43,6 +43,11 @@ import type {
 } from '@/types'
 import type { ServiceResult } from '@/lib/server/service-result'
 import type { DaemonConnectorRuntimeState } from '@/lib/server/daemon/types'
+import {
+  ensureSwarmdockConnectorCredential,
+  prepareSwarmdockConnectorInput,
+  redactConnectorSecrets,
+} from './swarmdock-secret'
 
 function cloneConnector<T extends Connector>(connector: T): T {
   return {
@@ -124,35 +129,52 @@ function requireSenderId(body: Record<string, unknown>): string {
 export async function listConnectorsWithRuntime(): Promise<Record<string, Connector>> {
   await ensureDaemonProcessRunning('api/connectors:get')
   const connectors = Object.fromEntries(
-    Object.entries(loadConnectors()).map(([id, connector]) => [id, cloneConnector(connector)]),
+    Object.entries(loadConnectors()).map(([id, connector]) => {
+      const prepared = ensureSwarmdockConnectorCredential(connector, {
+        allowMigrationFailureFallback: true,
+      })
+      return [id, cloneConnector(prepared.connector)]
+    }),
   ) as Record<string, Connector>
   const runtimeByConnector = await listDaemonConnectorRuntime()
   for (const connector of Object.values(connectors)) {
     applyRuntimeFields(connector, runtimeByConnector[connector.id] || null)
   }
-  return connectors
+  return Object.fromEntries(
+    Object.entries(connectors).map(([id, connector]) => [id, redactConnectorSecrets(connector)]),
+  )
 }
 
 export async function getConnectorWithRuntime(id: string): Promise<Connector | null> {
   await ensureDaemonProcessRunning('api/connectors/[id]:get')
   const connector = loadConnector(id)
   if (!connector) return null
-  const current = cloneConnector(connector)
-  return applyRuntimeFields(current, await getDaemonConnectorRuntime(id))
+  const prepared = ensureSwarmdockConnectorCredential(connector, {
+    allowMigrationFailureFallback: true,
+  })
+  const current = cloneConnector(prepared.connector)
+  return redactConnectorSecrets(applyRuntimeFields(current, await getDaemonConnectorRuntime(id)))
 }
 
 export function createConnector(body: Record<string, unknown>): Connector {
   const id = genId()
+  const rawConfig = body.config && typeof body.config === 'object' && !Array.isArray(body.config)
+    ? body.config as Record<string, string>
+    : {}
+  const prepared = prepareSwarmdockConnectorInput({
+    platform: body.platform as Connector['platform'],
+    name: (body.name as string) || `${String(body.platform || '')} Connector`,
+    credentialId: (body.credentialId as string | null | undefined) || null,
+    config: rawConfig,
+  })
   const connector: Connector = {
     id,
     name: (body.name as string) || `${String(body.platform || '')} Connector`,
     platform: body.platform as Connector['platform'],
     agentId: (body.agentId as string | null | undefined) || null,
     chatroomId: (body.chatroomId as string | null | undefined) || null,
-    credentialId: (body.credentialId as string | null | undefined) || null,
-    config: body.config && typeof body.config === 'object' && !Array.isArray(body.config)
-      ? body.config as Record<string, string>
-      : {},
+    credentialId: prepared.credentialId,
+    config: prepared.config,
     isEnabled: false,
     status: 'stopped',
     lastError: null,
@@ -210,6 +232,14 @@ export async function updateConnectorFromRoute(id: string, body: Record<string,
   if (body.credentialId !== undefined) next.credentialId = typeof body.credentialId === 'string' || body.credentialId === null ? body.credentialId : next.credentialId
   if (body.config !== undefined) next.config = body.config && typeof body.config === 'object' && !Array.isArray(body.config) ? body.config as Record<string, string> : next.config
   if (body.isEnabled !== undefined) next.isEnabled = typeof body.isEnabled === 'boolean' ? body.isEnabled : next.isEnabled
+  const prepared = prepareSwarmdockConnectorInput({
+    platform: next.platform,
+    name: next.name,
+    credentialId: next.credentialId || null,
+    config: next.config,
+  })
+  next.credentialId = prepared.credentialId
+  next.config = prepared.config
   persistConnector(next)
 
   try {
@@ -235,7 +265,7 @@ export async function updateConnectorFromRoute(id: string, body: Record<string,
   }
 
   notify('connectors')
-  return serviceOk(await getConnectorWithRuntime(id) || next)
+  return serviceOk(await getConnectorWithRuntime(id) || redactConnectorSecrets(next))
 }
 
 export async function deleteConnectorFromRoute(id: string): Promise<ServiceResult<{ ok: true }>> {

package/src/lib/server/connectors/swarmdock-bidding.ts

@@ -0,0 +1,74 @@
+import { log } from '@/lib/server/logger'
+import type { BidCreateInput } from '@swarmdock/shared'
+
+const TAG = 'swarmdock-bid'
+
+interface SwarmDockTask {
+  id: string
+  title: string
+  skillRequirements: string[]
+  budgetMax: string
+}
+
+interface SwarmDockConfig {
+  skills: string
+  maxBudget: string
+  autoDiscover: boolean
+}
+
+/**
+ * Determine if the agent should auto-bid on a discovered task.
+ * Checks skill overlap and budget limits.
+ */
+export function shouldAutoBid(task: SwarmDockTask, config: SwarmDockConfig): boolean {
+  if (!config.autoDiscover) return false
+
+  // Check budget
+  const maxBudget = BigInt(config.maxBudget || '0')
+  if (maxBudget > BigInt(0)) {
+    const taskBudget = BigInt(task.budgetMax || '0')
+    if (taskBudget > maxBudget) {
+      log.debug(TAG, `Skipping "${task.title}" — budget ${task.budgetMax} exceeds max ${config.maxBudget}`)
+      return false
+    }
+  }
+
+  // Check skill overlap
+  const agentSkills = new Set(
+    config.skills.split(',').map((s) => s.trim().toLowerCase()).filter(Boolean),
+  )
+  if (agentSkills.size === 0) return false
+
+  const hasMatchingSkill = task.skillRequirements.some(
+    (req) => agentSkills.has(req.toLowerCase()),
+  )
+  if (!hasMatchingSkill) {
+    log.debug(TAG, `Skipping "${task.title}" — no matching skills`)
+    return false
+  }
+
+  return true
+}
+
+/**
+ * Submit an auto-bid on a SwarmDock task.
+ * Uses the task's max budget as the proposed price (simple strategy).
+ */
+export async function submitAutoBid(
+  client: { tasks: { bid: (taskId: string, input: BidCreateInput) => Promise<unknown> } },
+  taskId: string,
+  config: SwarmDockConfig,
+): Promise<void> {
+  const agentSkills = config.skills.split(',').map((s) => s.trim()).filter(Boolean)
+
+  const bid: BidCreateInput = {
+    proposedPrice: config.maxBudget || '1000000',
+    confidenceScore: 0.8,
+    proposal: `SwarmClaw agent with skills: ${agentSkills.join(', ')}. Ready to start immediately.`,
+    portfolioRefs: [],
+  }
+
+  await client.tasks.bid(taskId, bid)
+
+  log.info(TAG, `Auto-bid submitted for task ${taskId}`)
+}

package/src/lib/server/connectors/swarmdock-payloads.test.ts

@@ -0,0 +1,85 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { submitAutoBid } from '@/lib/server/connectors/swarmdock-bidding'
+import { submitSwarmdockTaskResult } from '@/lib/server/connectors/swarmdock'
+
+test('submitAutoBid includes empty portfolio refs for SDK compatibility', async () => {
+  const seen: {
+    taskId?: string
+    bid?: { proposedPrice: string; portfolioRefs: string[] }
+  } = {}
+
+  await submitAutoBid(
+    {
+      tasks: {
+        bid: async (taskId, input) => {
+          seen.taskId = taskId
+          seen.bid = {
+            proposedPrice: input.proposedPrice,
+            portfolioRefs: [...input.portfolioRefs],
+          }
+        },
+      },
+    },
+    'task-123',
+    {
+      skills: 'typescript,automation',
+      maxBudget: '2500000',
+      autoDiscover: true,
+    },
+  )
+
+  assert.equal(seen.taskId, 'task-123')
+  assert.deepEqual(seen.bid, {
+    proposedPrice: '2500000',
+    portfolioRefs: [],
+  })
+})
+
+test('submitSwarmdockTaskResult includes empty files and propagates submit errors', async () => {
+  const seen: {
+    taskId?: string
+    payload?: { files: unknown[]; artifacts: Array<{ type: string; content: string }> }
+  } = {}
+
+  await submitSwarmdockTaskResult(
+    {
+      tasks: {
+        submit: async (taskId, input) => {
+          seen.taskId = taskId
+          seen.payload = {
+            files: [...input.files],
+            artifacts: input.artifacts.map((artifact) => ({
+              type: artifact.type,
+              content: String(artifact.content),
+            })),
+          }
+        },
+      },
+    },
+    'task-456',
+    'Result body',
+  )
+
+  assert.equal(seen.taskId, 'task-456')
+  assert.deepEqual(seen.payload, {
+    files: [],
+    artifacts: [{ type: 'text/markdown', content: 'Result body' }],
+  })
+
+  await assert.rejects(
+    submitSwarmdockTaskResult(
+      {
+        tasks: {
+          submit: async () => {
+            throw new Error('submit failed')
+          },
+        },
+      },
+      'task-456',
+      'Result body',
+    ),
+    /submit failed/,
+  )
+})