@swarmclawai/swarmclaw 0.7.8 → 0.8.0

package/src/lib/server/session-run-manager.ts

@@ -219,7 +219,10 @@ export function cancelAllHeartbeatRuns(reason = 'Heartbeat disabled globally'):
 async function drainExecution(executionKey: string): Promise<void> {
   if (state.runningByExecution.has(executionKey)) return
   const q = queueForExecution(executionKey)
-  const next = q.shift()
+  // Priority: user (non-heartbeat) runs go first. If a heartbeat is queued
+  // behind a user run, the user run takes priority.
+  const userIdx = q.findIndex(e => !isInternalHeartbeatRun(e.run.internal, e.run.source))
+  const next = userIdx >= 0 ? q.splice(userIdx, 1)[0] : q.shift()
   if (!next) return
 
   state.runningByExecution.set(executionKey, next)
@@ -416,6 +419,18 @@ export function enqueueSessionRun(input: EnqueueSessionRunInput): EnqueueSession
     cancelPendingForSession(input.sessionId, 'Cancelled by steer mode')
   }
 
+  // Heartbeat preemption: if a user chat arrives while a heartbeat is running,
+  // abort the heartbeat so the user doesn't wait. The heartbeat will retry
+  // on the next tick.
+  if (!internal && source === 'chat') {
+    const running = state.runningByExecution.get(executionKey)
+    if (running && isInternalHeartbeatRun(running.run.internal, running.run.source)) {
+      log.info('session-run', `Preempting heartbeat ${running.run.id} for user chat on ${input.sessionId}`)
+      abortSessionRuntime(running, 'Preempted by user chat')
+      state.runningByExecution.delete(executionKey)
+    }
+  }
+
   const running = state.runningByExecution.get(executionKey)
   const q = queueForExecution(executionKey)
   if (mode === 'collect' && !input.imagePath && !input.imageUrl && !input.attachedFiles?.length) {
@@ -506,15 +521,48 @@ export function enqueueSessionRun(input: EnqueueSessionRunInput): EnqueueSession
 export function getSessionRunState(sessionId: string): {
   runningRunId?: string
   queueLength: number
+} {
+  const summary = getSessionExecutionState(sessionId)
+  return {
+    runningRunId: summary.runningRunId,
+    queueLength: summary.queueLength,
+  }
+}
+
+export function getSessionExecutionState(sessionId: string): {
+  runningRunId?: string
+  queueLength: number
+  hasRunning: boolean
+  hasQueued: boolean
+  hasRunningHeartbeat: boolean
+  hasQueuedHeartbeat: boolean
+  hasRunningNonHeartbeat: boolean
+  hasQueuedNonHeartbeat: boolean
 } {
   const executionKey = executionKeyForSession(sessionId)
   const running = state.runningByExecution.get(executionKey)
-  const queued = queueForExecution(executionKey).filter((entry) => entry.run.sessionId === sessionId).length
+  const runningMatchesSession = running?.run.sessionId === sessionId
+  const runningHeartbeat = Boolean(
+    runningMatchesSession
+    && isInternalHeartbeatRun(running.run.internal, running.run.source),
+  )
+  const runningNonHeartbeat = Boolean(runningMatchesSession && !runningHeartbeat)
+  const queuedEntries = queueForExecution(executionKey).filter((entry) => entry.run.sessionId === sessionId)
+  const queuedHeartbeat = queuedEntries.filter((entry) =>
+    isInternalHeartbeatRun(entry.run.internal, entry.run.source),
+  ).length
+  const queuedNonHeartbeat = queuedEntries.length - queuedHeartbeat
   return {
-    runningRunId: (running?.run.sessionId === sessionId && running.run.status === 'running')
+    runningRunId: (runningMatchesSession && running?.run.status === 'running')
       ? running.run.id
       : undefined,
-    queueLength: queued,
+    queueLength: queuedEntries.length,
+    hasRunning: Boolean(runningMatchesSession),
+    hasQueued: queuedEntries.length > 0,
+    hasRunningHeartbeat: runningHeartbeat,
+    hasQueuedHeartbeat: queuedHeartbeat > 0,
+    hasRunningNonHeartbeat: runningNonHeartbeat,
+    hasQueuedNonHeartbeat: queuedNonHeartbeat > 0,
   }
 }
 

package/src/lib/server/session-tools/canvas.ts

@@ -6,6 +6,7 @@ import type { ToolBuildContext } from './context'
 import type { Plugin, PluginHooks } from '@/types'
 import { getPluginManager } from '../plugins'
 import { normalizeToolInputArgs } from './normalize-tool-args'
+import { normalizeCanvasContent, summarizeCanvasContent } from '@/lib/canvas-content'
 
 /**
  * Core Canvas Execution Logic
@@ -14,6 +15,7 @@ async function executeCanvasAction(args: Record<string, unknown>, context: { ses
   const normalized = normalizeToolInputArgs(args)
   const action = normalized.action as string
   const content = normalized.content as string | undefined
+  const document = normalized.document
   try {
     const sessionId = context.sessionId
     if (!sessionId) return 'Error: no active session for canvas.'
@@ -23,13 +25,18 @@ async function executeCanvasAction(args: Record<string, unknown>, context: { ses
     if (!session) return 'Error: session not found.'
 
     if (action === 'present') {
-      if (!content) return 'Error: content is required for present action.'
-      ;(session as Record<string, unknown>).canvasContent = content
+      const nextContent = normalizeCanvasContent(document ?? content)
+      if (!nextContent) return 'Error: content or document is required for present action.'
+      ;(session as Record<string, unknown>).canvasContent = nextContent
       session.lastActiveAt = Date.now()
       sessions[sessionId] = session
       saveSessions(sessions)
       notify(`canvas:${sessionId}`)
-      return JSON.stringify({ ok: true, action: 'present', contentLength: content.length })
+      return JSON.stringify({
+        ok: true,
+        action: 'present',
+        ...summarizeCanvasContent(nextContent),
+      })
     }
 
     if (action === 'hide') {
@@ -42,14 +49,8 @@ async function executeCanvasAction(args: Record<string, unknown>, context: { ses
     }
 
     if (action === 'snapshot') {
-      const current = (session as Record<string, unknown>).canvasContent
-      return JSON.stringify({
-        ok: true,
-        action: 'snapshot',
-        hasContent: !!current,
-        contentLength: typeof current === 'string' ? current.length : 0,
-        preview: typeof current === 'string' ? current.slice(0, 500) : null,
-      })
+      const current = normalizeCanvasContent((session as Record<string, unknown>).canvasContent)
+      return JSON.stringify({ ok: true, action: 'snapshot', ...summarizeCanvasContent(current) })
     }
 
     return `Unknown canvas action "${action}".`
@@ -73,7 +74,8 @@ const CanvasPlugin: Plugin = {
         type: 'object',
         properties: {
           action: { type: 'string', enum: ['present', 'hide', 'snapshot'] },
-          content: { type: 'string' }
+          content: { type: 'string' },
+          document: { type: 'object', additionalProperties: true },
         },
         required: ['action']
       },

package/src/lib/server/session-tools/connector.test.ts

@@ -0,0 +1,138 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import {
+  CONNECTOR_MESSAGE_TOOL_ACTIONS,
+  CONNECTOR_MESSAGE_TOOL_PARAMETERS,
+  inferConnectorActionName,
+  normalizeConnectorActionInputAliases,
+  normalizeConnectorActionName,
+} from './connector'
+import { getPluginManager } from '../plugins'
+import { buildSessionTools } from './index'
+
+describe('connector_message_tool contract', () => {
+  it('exposes the connector actions and voice-note fields through the plugin schema', () => {
+    const entry = getPluginManager()
+      .getTools(['manage_connectors'])
+      .find((tool) => tool.tool.name === 'connector_message_tool')
+
+    assert.ok(entry, 'connector_message_tool should be registered for manage_connectors')
+
+    const props = (entry!.tool.parameters?.properties ?? {}) as Record<string, { type?: string; enum?: string[] }>
+    assert.deepEqual(props.action?.enum, [...CONNECTOR_MESSAGE_TOOL_ACTIONS])
+    assert.equal(props.approved?.type, 'boolean')
+    assert.equal(props.ptt?.type, 'boolean')
+    assert.equal(props.voiceText?.type, 'string')
+    assert.equal(props.recipientId?.type, 'string')
+    assert.equal(props.channel?.type, 'string')
+    assert.equal(Array.isArray(entry!.tool.parameters?.required), false)
+    assert.equal(Array.isArray((CONNECTOR_MESSAGE_TOOL_PARAMETERS as { required?: unknown }).required), false)
+  })
+
+  it('normalizes legacy rich-message aliases to the current connector actions', () => {
+    assert.equal(normalizeConnectorActionName('message_react'), 'react')
+    assert.equal(normalizeConnectorActionName('message_edit'), 'edit')
+    assert.equal(normalizeConnectorActionName('message_delete'), 'delete')
+    assert.equal(normalizeConnectorActionName('message_pin'), 'pin')
+    assert.equal(normalizeConnectorActionName('send_voice_note'), 'send_voice_note')
+  })
+
+  it('infers send-style actions from partial connector payloads', () => {
+    assert.equal(inferConnectorActionName({ voiceText: 'hello there' }), 'send_voice_note')
+    assert.equal(inferConnectorActionName({ followUpMessage: 'check back later', delaySec: 60 }), 'schedule_followup')
+    assert.equal(inferConnectorActionName({ message: 'plain text message' }), 'send')
+    assert.equal(inferConnectorActionName({}), null)
+  })
+
+  it('normalizes connector and target aliases from model-generated delivery calls', () => {
+    const running = [{ id: 'd81cd63b', name: 'Main Whatsapp connection' }]
+
+    assert.deepEqual(
+      normalizeConnectorActionInputAliases({
+        action: 'send_voice_note',
+        channel: 'Main Whatsapp connection',
+        recipientId: '07958148127',
+      }, running),
+      {
+        action: 'send_voice_note',
+        channel: 'Main Whatsapp connection',
+        recipientId: '07958148127',
+        connectorId: 'd81cd63b',
+        to: '07958148127',
+      },
+    )
+
+    assert.deepEqual(
+      normalizeConnectorActionInputAliases({
+        action: 'send_voice_note',
+        id: 'd81cd63b',
+        target: '199900000001@lid',
+      }, running),
+      {
+        action: 'send_voice_note',
+        id: 'd81cd63b',
+        target: '199900000001@lid',
+        connectorId: 'd81cd63b',
+        to: '199900000001@lid',
+      },
+    )
+  })
+
+  it('treats raw id as messageId for message actions instead of as a target alias', () => {
+    assert.deepEqual(
+      normalizeConnectorActionInputAliases({
+        action: 'react',
+        id: 'msg-123',
+        emoji: '👍',
+      }, [{ id: 'conn-1', name: 'Primary connector' }]),
+      {
+        action: 'react',
+        id: 'msg-123',
+        emoji: '👍',
+        messageId: 'msg-123',
+      },
+    )
+  })
+
+  it('buildSessionTools exposes the native connector schema instead of the legacy passthrough bridge', async () => {
+    const built = await buildSessionTools(process.cwd(), ['manage_connectors'], {
+      sessionId: 'connector-native-schema-test',
+      agentId: 'default',
+      platformAssignScope: 'self',
+    })
+
+    try {
+      const connectorTool = built.tools.find((tool) => tool.name === 'connector_message_tool')
+      assert.ok(connectorTool, 'connector_message_tool should be available when manage_connectors is enabled')
+
+      const schema = (connectorTool as { schema?: { safeParse: (value: unknown) => { success: boolean } } }).schema
+      assert.ok(schema, 'connector_message_tool should expose a validation schema')
+      assert.equal(schema.safeParse({ action: 'send_voice_note', approved: true, ptt: true }).success, true)
+      assert.equal(schema.safeParse({ voiceText: 'hello', recipientId: '07958148127', channel: 'Main Whatsapp connection' }).success, true)
+      assert.equal(schema.safeParse({ action: 'message_react' }).success, true)
+      assert.equal(schema.safeParse({}).success, true)
+      assert.equal(schema.safeParse({ action: 'bogus_action' }).success, false)
+    } finally {
+      await built.cleanup()
+    }
+  })
+
+  it('loads connector_message_tool when a session only has the tool-level grant alias', async () => {
+    const built = await buildSessionTools(process.cwd(), ['connector_message_tool'], {
+      sessionId: 'connector-tool-alias-test',
+      agentId: 'default',
+      platformAssignScope: 'self',
+    })
+
+    try {
+      assert.equal(
+        built.tools.some((tool) => tool.name === 'connector_message_tool'),
+        true,
+        'connector_message_tool should load from its persisted approval alias',
+      )
+    } finally {
+      await built.cleanup()
+    }
+  })
+})