@swarmclawai/swarmclaw 0.7.2 → 0.7.4

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

@@ -1,23 +1,112 @@
 import { z } from 'zod'
 import { tool, type StructuredToolInterface } from '@langchain/core/tools'
 import fs from 'fs'
-import path from 'path'
 import * as os from 'os'
 import type { ToolBuildContext } from './context'
 import { getPluginManager } from '../plugins'
 import type { Plugin, PluginHooks } from '@/types'
 import { safePath, truncate } from './context'
 import { normalizeToolInputArgs } from './normalize-tool-args'
+import { cancelWatchJob, createWatchJob, getWatchJob, listWatchJobs } from '../watch-jobs'
+import { ensureSessionBrowserProfileId, loadBrowserSessionRecord } from '../browser-state'
+
+type WatchKind = 'time' | 'http' | 'file' | 'task' | 'webhook' | 'page'
+
+async function createDurableWatch(
+  normalized: Record<string, unknown>,
+  bctx: { cwd: string; sessionId?: string; agentId?: string | null },
+  explicitType?: WatchKind,
+) {
+  const watchType = (explicitType || String(normalized.watchType || normalized.type || '').trim().toLowerCase()) as WatchKind
+  if (!watchType) return 'Error: watchType is required.'
+  if (!['time', 'http', 'file', 'task', 'webhook', 'page'].includes(watchType)) {
+    return `Error: Unsupported watchType "${watchType}".`
+  }
+
+  const sessionId = typeof normalized.sessionId === 'string' ? normalized.sessionId : bctx.sessionId
+  const agentId = typeof normalized.agentId === 'string' ? normalized.agentId : (bctx.agentId || undefined)
+  const resumeMessage = String(normalized.resumeMessage || normalized.message || '').trim()
+  if (!resumeMessage) return 'Error: resumeMessage is required.'
+
+  const target = (normalized.target ?? normalized.url ?? normalized.path) as string | undefined
+  const delayMinutes = typeof normalized.delayMinutes === 'number' ? normalized.delayMinutes : undefined
+  const runAt = typeof normalized.runAt === 'number'
+    ? normalized.runAt
+    : delayMinutes !== undefined
+      ? Date.now() + Math.max(0, delayMinutes) * 60_000
+      : undefined
+  const intervalMs = typeof normalized.intervalSec === 'number'
+    ? Math.max(15, normalized.intervalSec) * 1000
+    : typeof normalized.intervalMs === 'number'
+      ? Math.max(15_000, normalized.intervalMs)
+      : undefined
+  const timeoutAt = typeof normalized.timeoutMinutes === 'number'
+    ? Date.now() + Math.max(1, normalized.timeoutMinutes) * 60_000
+    : typeof normalized.timeoutAt === 'number'
+      ? normalized.timeoutAt
+      : undefined
+  const browserProfileId = sessionId ? ensureSessionBrowserProfileId(sessionId).profileId : null
+  const targetPath = watchType === 'file' && target ? safePath(bctx.cwd, target) : target
+  const pageUrl = watchType === 'page' && !target && sessionId
+    ? loadBrowserSessionRecord(sessionId)?.currentUrl || undefined
+    : undefined
+  const pageTarget = target || pageUrl
+  if ((watchType === 'http' || watchType === 'page') && !pageTarget) {
+    return `Error: ${watchType === 'page' ? 'url or active browser page' : 'url'} is required.`
+  }
+
+  const job = await createWatchJob({
+    type: watchType,
+    sessionId: sessionId || null,
+    agentId: agentId || null,
+    createdByAgentId: agentId || null,
+    browserProfileId,
+    description: typeof normalized.description === 'string' ? normalized.description : null,
+    resumeMessage,
+    runAt,
+    intervalMs,
+    timeoutAt,
+    target: {
+      url: watchType === 'http' || watchType === 'page' ? pageTarget : undefined,
+      path: watchType === 'file' ? targetPath : undefined,
+      taskId: watchType === 'task' ? String(normalized.taskId || normalized.id || '') : undefined,
+      webhookId: watchType === 'webhook' ? String(normalized.webhookId || normalized.id || '') : undefined,
+      baselineHash: undefined,
+    },
+    condition: {
+      containsText: typeof normalized.containsText === 'string' ? normalized.containsText : undefined,
+      textGone: typeof normalized.textGone === 'string' ? normalized.textGone : undefined,
+      regex: typeof normalized.regex === 'string' ? normalized.regex : undefined,
+      changed: normalized.changed === true,
+      exists: normalized.exists,
+      status: typeof normalized.status === 'number' ? normalized.status : undefined,
+      statusIn: Array.isArray(normalized.statusIn) ? normalized.statusIn : undefined,
+      event: typeof normalized.event === 'string' ? normalized.event : undefined,
+      threshold: typeof normalized.threshold === 'number' ? normalized.threshold : undefined,
+    },
+  })
+  return JSON.stringify(job, null, 2)
+}
+
+function getErrorMessage(err: unknown): string {
+  return err instanceof Error ? err.message : String(err)
+}
 
 /**
  * Unified Monitoring Logic
  */
-async function executeMonitorAction(args: any, bctx: { cwd: string }) {
+async function executeMonitorAction(
+  args: Record<string, unknown> | undefined,
+  bctx: { cwd: string; sessionId?: string; agentId?: string | null },
+) {
   const normalized = normalizeToolInputArgs((args ?? {}) as Record<string, unknown>)
   const action = normalized.action as string | undefined
   const target = (normalized.target ?? normalized.url ?? normalized.path) as string | undefined
   const limit = normalized.limit as number | undefined
   const threshold = normalized.threshold as number | undefined
+  const sessionId = typeof normalized.sessionId === 'string' ? normalized.sessionId : bctx.sessionId
+  void limit
+  void sessionId
 
   try {
     switch (action) {
@@ -65,22 +154,72 @@ async function executeMonitorAction(args: any, bctx: { cwd: string }) {
             status: res.status,
             ok: res.ok,
             latency: `${latency}ms`,
+            thresholdExceeded: typeof threshold === 'number' ? latency >= threshold : undefined,
             url
           }, null, 2)
-        } catch (err: any) {
+        } catch (err: unknown) {
           return JSON.stringify({
             status: 'error',
-            error: err.message,
+            error: getErrorMessage(err),
             url
           }, null, 2)
         }
       }
 
+      case 'create_watch': {
+        return createDurableWatch(normalized, bctx)
+      }
+
+      case 'wait_until': {
+        return createDurableWatch(normalized, bctx, 'time')
+      }
+
+      case 'wait_for_http': {
+        return createDurableWatch(normalized, bctx, 'http')
+      }
+
+      case 'wait_for_file': {
+        return createDurableWatch(normalized, bctx, 'file')
+      }
+
+      case 'wait_for_task': {
+        return createDurableWatch(normalized, bctx, 'task')
+      }
+
+      case 'wait_for_webhook': {
+        return createDurableWatch(normalized, bctx, 'webhook')
+      }
+
+      case 'wait_for_page_change': {
+        return createDurableWatch(normalized, bctx, 'page')
+      }
+
+      case 'list_watches': {
+        const filterSessionId = normalized.all === true ? undefined : sessionId
+        return JSON.stringify(listWatchJobs({ sessionId: filterSessionId || null }), null, 2)
+      }
+
+      case 'get_watch': {
+        const id = String(normalized.id || '').trim()
+        if (!id) return 'Error: id is required.'
+        const job = getWatchJob(id)
+        if (!job) return `Error: watch job "${id}" not found.`
+        return JSON.stringify(job, null, 2)
+      }
+
+      case 'cancel_watch': {
+        const id = String(normalized.id || '').trim()
+        if (!id) return 'Error: id is required.'
+        const job = cancelWatchJob(id)
+        if (!job) return `Error: watch job "${id}" not found.`
+        return JSON.stringify(job, null, 2)
+      }
+
       default:
         return `Error: Unknown action "${action}"`
     }
-  } catch (err: any) {
-    return `Error: ${err.message}`
+  } catch (err: unknown) {
+    return `Error: ${getErrorMessage(err)}`
   }
 }
 
@@ -89,22 +228,29 @@ async function executeMonitorAction(args: any, bctx: { cwd: string }) {
  */
 const MonitorPlugin: Plugin = {
   name: 'Core Monitor',
-  description: 'System observability: check resource usage, watch logs, and ping endpoints.',
+  description: 'System observability and durable watch jobs: inspect system state, monitor files/endpoints/tasks, and resume agents when conditions trigger.',
   hooks: {} as PluginHooks,
   tools: [
     {
       name: 'monitor_tool',
-      description: 'Observe system health, log activity, or endpoint availability.',
+      description: 'Observe system health, inspect logs/endpoints, or create durable waits like wait_for_http, wait_for_file, wait_for_webhook, and wait_for_page_change.',
       parameters: {
         type: 'object',
         properties: {
-          action: { type: 'string', enum: ['sys_info', 'watch_log', 'ping'] },
+          action: { type: 'string', enum: ['sys_info', 'watch_log', 'ping', 'create_watch', 'wait_until', 'wait_for_http', 'wait_for_file', 'wait_for_task', 'wait_for_webhook', 'wait_for_page_change', 'list_watches', 'get_watch', 'cancel_watch'] },
           target: { type: 'string', description: 'Log file path (for watch_log) or URL (for ping)' },
-          limit: { type: 'number', description: 'Number of lines or bytes to retrieve' }
+          limit: { type: 'number', description: 'Number of lines or bytes to retrieve' },
+          watchType: { type: 'string', enum: ['time', 'http', 'file', 'task', 'webhook', 'page'] },
+          resumeMessage: { type: 'string', description: 'Message injected when the watch triggers and the agent wakes up.' },
+          regex: { type: 'string', description: 'Regex pattern used by file/page/http watchers.' },
         },
         required: ['action']
       },
-      execute: async (args, context) => executeMonitorAction(args, { cwd: context.session.cwd || process.cwd() })
+      execute: async (args, context) => executeMonitorAction(args, {
+        cwd: context.session.cwd || process.cwd(),
+        sessionId: context.session.id,
+        agentId: context.session.agentId,
+      })
     }
   ]
 }
@@ -115,7 +261,11 @@ export function buildMonitorTools(bctx: ToolBuildContext): StructuredToolInterfa
   if (!bctx.hasPlugin('monitor')) return []
   return [
     tool(
-      async (args) => executeMonitorAction(args, { cwd: bctx.cwd }),
+      async (args) => executeMonitorAction(args, {
+        cwd: bctx.cwd,
+        sessionId: bctx.ctx?.sessionId || undefined,
+        agentId: bctx.ctx?.agentId || undefined,
+      }),
       {
         name: 'monitor_tool',
         description: MonitorPlugin.tools![0].description,

package/src/lib/server/session-tools/normalize-tool-args.ts

@@ -1,4 +1,5 @@
 export type ToolArgsRecord = Record<string, unknown>
+const NESTED_WRAPPER_KEYS = ['input', 'args', 'arguments', 'payload', 'parameters'] as const
 
 function parseRecordCandidate(value: unknown): ToolArgsRecord | null {
   if (!value) return null
@@ -26,22 +27,24 @@ function parseRecordCandidate(value: unknown): ToolArgsRecord | null {
  * as either objects or JSON strings.
  */
 export function normalizeToolInputArgs(rawArgs: ToolArgsRecord): ToolArgsRecord {
-  const nestedSources: Array<ToolArgsRecord | null> = [
-    parseRecordCandidate(rawArgs.input),
-    parseRecordCandidate(rawArgs.args),
-    parseRecordCandidate(rawArgs.arguments),
-    parseRecordCandidate(rawArgs.payload),
-  ]
-
   const normalized: ToolArgsRecord = {}
-  for (const nested of nestedSources) {
-    if (!nested) continue
-    Object.assign(normalized, nested)
-  }
+  const queue: ToolArgsRecord[] = [rawArgs]
+  const visited = new Set<ToolArgsRecord>()
+
+  while (queue.length > 0) {
+    const current = queue.shift()
+    if (!current || visited.has(current)) continue
+    visited.add(current)
 
-  for (const [key, value] of Object.entries(rawArgs)) {
-    if (value === undefined || value === null) continue
-    normalized[key] = value
+    for (const key of NESTED_WRAPPER_KEYS) {
+      const nested = parseRecordCandidate(current[key])
+      if (nested) queue.push(nested)
+    }
+
+    for (const [key, value] of Object.entries(current)) {
+      if (value === undefined || value === null) continue
+      normalized[key] = value
+    }
   }
 
   return normalized

package/src/lib/server/session-tools/openclaw-nodes.test.ts

@@ -0,0 +1,111 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { executeNodesAction } from './openclaw-nodes'
+import type { OpenClawGateway } from '../openclaw-gateway'
+
+test('executeNodesAction returns not_connected when no gateway is available', async () => {
+  const raw = await executeNodesAction(
+    { action: 'list', profileId: 'gateway-1' },
+    { ensureGatewayConnected: async () => null },
+  )
+  const result = JSON.parse(raw)
+  assert.equal(result.status, 'not_connected')
+  assert.match(result.message, /gateway not connected/i)
+})
+
+test('executeNodesAction lists nodes against the selected gateway profile', async () => {
+  const calls: Array<{ method: string; params: unknown }> = []
+  const gateway = {
+    rpc: async (method: string, params?: unknown) => {
+      calls.push({ method, params })
+      return { ts: 1, nodes: [{ nodeId: 'node-1' }] }
+    },
+  }
+
+  const raw = await executeNodesAction(
+    { action: 'list', profileId: 'gateway-1' },
+    { ensureGatewayConnected: async () => gateway as unknown as OpenClawGateway },
+  )
+  const result = JSON.parse(raw)
+  assert.equal(result.status, 'ok')
+  assert.equal(calls[0]?.method, 'node.list')
+  assert.deepEqual(calls[0]?.params, { profileId: 'gateway-1' })
+  assert.equal(result.result.nodes[0].nodeId, 'node-1')
+})
+
+test('executeNodesAction aggregates node and device pairings', async () => {
+  const calls: string[] = []
+  const gateway = {
+    rpc: async (method: string) => {
+      calls.push(method)
+      if (method === 'node.pair.list') return { pending: [{ requestId: 'node-req-1' }] }
+      if (method === 'device.pair.list') return { pending: [{ requestId: 'device-req-1' }], paired: [{ deviceId: 'device-1' }] }
+      throw new Error(`Unexpected RPC ${method}`)
+    },
+  }
+
+  const raw = await executeNodesAction(
+    { action: 'pairings', profileId: 'gateway-1' },
+    { ensureGatewayConnected: async () => gateway as unknown as OpenClawGateway },
+  )
+  const result = JSON.parse(raw)
+  assert.equal(result.status, 'ok')
+  assert.deepEqual(calls, ['node.pair.list', 'device.pair.list'])
+  assert.equal(result.result.nodePairings.pending[0].requestId, 'node-req-1')
+  assert.equal(result.result.devicePairings.paired[0].deviceId, 'device-1')
+})
+
+test('executeNodesAction routes device pairing approvals to the device RPC surface', async () => {
+  const calls: Array<{ method: string; params: unknown }> = []
+  const gateway = {
+    rpc: async (method: string, params?: unknown) => {
+      calls.push({ method, params })
+      return { ok: true }
+    },
+  }
+
+  const raw = await executeNodesAction(
+    { action: 'approve_pairing', pairingType: 'device', requestId: 'req-1', profileId: 'gateway-1' },
+    { ensureGatewayConnected: async () => gateway as unknown as OpenClawGateway },
+  )
+  const result = JSON.parse(raw)
+  assert.equal(result.status, 'ok')
+  assert.equal(calls[0]?.method, 'device.pair.approve')
+  assert.deepEqual(calls[0]?.params, { requestId: 'req-1', profileId: 'gateway-1' })
+})
+
+test('executeNodesAction forwards notify payloads through node.invoke with a generated idempotency key', async () => {
+  const calls: Array<{ method: string; params: unknown }> = []
+  const gateway = {
+    rpc: async (method: string, params?: unknown) => {
+      calls.push({ method, params })
+      return { delivered: true }
+    },
+  }
+
+  const raw = await executeNodesAction(
+    {
+      action: 'notify',
+      profileId: 'gateway-1',
+      nodeId: 'node-42',
+      message: 'hello from test',
+      params: { urgency: 'high' },
+      timeoutMs: 5000,
+    },
+    {
+      ensureGatewayConnected: async () => gateway as unknown as OpenClawGateway,
+      generateId: () => 'fixed-id',
+    },
+  )
+  const result = JSON.parse(raw)
+  assert.equal(result.status, 'ok')
+  assert.equal(calls[0]?.method, 'node.invoke')
+  assert.deepEqual(calls[0]?.params, {
+    nodeId: 'node-42',
+    command: 'notify',
+    params: { urgency: 'high', message: 'hello from test' },
+    timeoutMs: 5000,
+    idempotencyKey: 'fixed-id',
+    profileId: 'gateway-1',
+  })
+})

package/src/lib/server/session-tools/openclaw-nodes.ts

@@ -1,46 +1,105 @@
 import { z } from 'zod'
+import { randomUUID } from 'crypto'
 import { tool, type StructuredToolInterface } from '@langchain/core/tools'
 import type { ToolBuildContext } from './context'
 import type { Plugin, PluginHooks } from '@/types'
 import { getPluginManager } from '../plugins'
 import { normalizeToolInputArgs } from './normalize-tool-args'
+import { ensureGatewayConnected } from '../openclaw-gateway'
+
+interface OpenClawNodesDeps {
+  ensureGatewayConnected?: typeof ensureGatewayConnected
+  generateId?: () => string
+}
 
 /**
  * Core OpenClaw Nodes Execution Logic
  */
-async function executeNodesAction(args: any) {
+export async function executeNodesAction(args: any, deps: OpenClawNodesDeps = {}) {
   const normalized = normalizeToolInputArgs((args ?? {}) as Record<string, unknown>)
   const action = normalized.action as string | undefined
   const nodeId = (normalized.nodeId ?? normalized.node_id) as string | undefined
+  const deviceId = (normalized.deviceId ?? normalized.device_id) as string | undefined
+  const requestId = (normalized.requestId ?? normalized.request_id) as string | undefined
   const message = normalized.message as string | undefined
   const params = normalized.params as Record<string, unknown> | undefined
+  const command = (normalized.command ?? params?.command ?? params?.action) as string | undefined
+  const pairingType = typeof normalized.pairingType === 'string' ? normalized.pairingType : (typeof normalized.kind === 'string' ? normalized.kind : 'node')
+  const profileId = (normalized.profileId ?? normalized.gatewayProfileId ?? normalized.gateway_profile_id) as string | undefined
+  const agentId = (normalized.agentId ?? normalized.agent_id) as string | undefined
+  const timeoutMs = typeof normalized.timeoutMs === 'number'
+    ? normalized.timeoutMs
+    : (typeof params?.timeoutMs === 'number' ? params.timeoutMs : undefined)
+  const ensureGatewayConnectedFn = deps.ensureGatewayConnected ?? ensureGatewayConnected
+  const generateId = deps.generateId ?? randomUUID
   try {
-    const { listRunningConnectors, getRunningInstance } = await import('../connectors/manager')
-    const openclawConnectors = listRunningConnectors('openclaw')
-    if (!openclawConnectors.length) {
+    const gateway = await ensureGatewayConnectedFn({ profileId, agentId })
+    if (!gateway) {
       return JSON.stringify({
         status: 'not_connected',
-        message: 'No running OpenClaw connector found.',
-        hint: 'Start an OpenClaw connector in the Connectors panel, then retry.',
+        message: 'OpenClaw gateway not connected.',
+        hint: 'Connect an OpenClaw gateway profile in Providers, then retry.',
       })
     }
-    const inst = getRunningInstance(openclawConnectors[0].id)
-    if (!inst) {
+
+    if (action === 'list') {
+      const result = await gateway.rpc('node.list', { profileId })
+      return JSON.stringify({ status: 'ok', action, result })
+    }
+    if (action === 'describe') {
+      if (!nodeId) return JSON.stringify({ status: 'error', error: 'nodeId is required for describe.' })
+      const result = await gateway.rpc('node.describe', { nodeId, profileId })
+      return JSON.stringify({ status: 'ok', action, nodeId, result })
+    }
+    if (action === 'pairings') {
+      const [nodePairings, devicePairings] = await Promise.all([
+        gateway.rpc('node.pair.list', { profileId }),
+        gateway.rpc('device.pair.list', { profileId }),
+      ])
       return JSON.stringify({
-        status: 'not_connected',
-        message: 'OpenClaw connector instance not accessible.',
-        connectorId: openclawConnectors[0].id,
+        status: 'ok',
+        action,
+        result: {
+          nodePairings,
+          devicePairings,
+        },
       })
     }
-
-    if (action === 'list') {
-      return JSON.stringify({ status: 'nodes.list not supported on gateway yet', connectorId: openclawConnectors[0].id })
+    if (action === 'approve_pairing') {
+      if (!requestId) return JSON.stringify({ status: 'error', error: 'requestId is required for approve_pairing.' })
+      const method = pairingType === 'device' ? 'device.pair.approve' : 'node.pair.approve'
+      const result = await gateway.rpc(method, { requestId, profileId })
+      return JSON.stringify({ status: 'ok', action, pairingType, requestId, result })
+    }
+    if (action === 'reject_pairing') {
+      if (!requestId) return JSON.stringify({ status: 'error', error: 'requestId is required for reject_pairing.' })
+      const method = pairingType === 'device' ? 'device.pair.reject' : 'node.pair.reject'
+      const result = await gateway.rpc(method, { requestId, profileId })
+      return JSON.stringify({ status: 'ok', action, pairingType, requestId, result })
     }
-    if (action === 'notify') {
-      return JSON.stringify({ status: 'nodes.notify not supported on gateway yet', nodeId, message })
+    if (action === 'remove_device') {
+      if (!deviceId) return JSON.stringify({ status: 'error', error: 'deviceId is required for remove_device.' })
+      const result = await gateway.rpc('device.pair.remove', { deviceId, profileId })
+      return JSON.stringify({ status: 'ok', action, deviceId, result })
     }
-    if (action === 'invoke') {
-      return JSON.stringify({ status: 'nodes.invoke not supported on gateway yet', nodeId, invokeAction: params?.action })
+    if (action === 'notify' || action === 'invoke') {
+      if (!nodeId) return JSON.stringify({ status: 'error', error: 'nodeId is required for invoke.' })
+      const invokeCommand = typeof command === 'string' && command.trim()
+        ? command.trim()
+        : (action === 'notify' ? 'notify' : '')
+      if (!invokeCommand) return JSON.stringify({ status: 'error', error: 'command is required for invoke.' })
+      const invokeParams = action === 'notify'
+        ? { ...(params || {}), message }
+        : (params || {})
+      const result = await gateway.rpc('node.invoke', {
+        nodeId,
+        command: invokeCommand,
+        params: invokeParams,
+        timeoutMs,
+        idempotencyKey: generateId(),
+        profileId,
+      })
+      return JSON.stringify({ status: 'ok', action, nodeId, command: invokeCommand, result })
     }
 
     return JSON.stringify({ status: 'error', error: `Unknown nodes action "${action}".` })
@@ -63,10 +122,17 @@ const NodesPlugin: Plugin = {
       parameters: {
         type: 'object',
         properties: {
-          action: { type: 'string', enum: ['list', 'notify', 'invoke'] },
+          action: { type: 'string', enum: ['list', 'describe', 'pairings', 'approve_pairing', 'reject_pairing', 'remove_device', 'notify', 'invoke'] },
           nodeId: { type: 'string' },
+          deviceId: { type: 'string' },
+          requestId: { type: 'string' },
+          pairingType: { type: 'string', enum: ['node', 'device'] },
+          profileId: { type: 'string' },
+          agentId: { type: 'string' },
+          command: { type: 'string' },
           message: { type: 'string' },
-          params: { type: 'object' }
+          params: { type: 'object' },
+          timeoutMs: { type: 'number' },
         },
         required: ['action']
       },

package/src/lib/server/session-tools/platform-normalize.test.ts

@@ -0,0 +1,142 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { normalizePlatformActionArgs } from './platform'
+
+describe('normalizePlatformActionArgs', () => {
+  it('packs top-level create fields into data', () => {
+    const out = normalizePlatformActionArgs({
+      resource: 'tasks',
+      action: 'create',
+      title: 'Write docs',
+      agentId: 'default',
+    })
+
+    assert.equal(out.resource, 'tasks')
+    assert.equal(out.action, 'create')
+    assert.deepEqual(JSON.parse(String(out.data)), {
+      title: 'Write docs',
+      agentId: 'default',
+    })
+  })
+
+  it('merges object data with top-level overrides', () => {
+    const out = normalizePlatformActionArgs({
+      resource: 'tasks',
+      action: 'create',
+      data: { title: 'Old title', agentId: 'coder' },
+      title: 'New title',
+    })
+
+    assert.deepEqual(JSON.parse(String(out.data)), {
+      title: 'New title',
+      agentId: 'coder',
+    })
+  })
+
+  it('normalizes legacy resources envelope with parameters payload', () => {
+    const out = normalizePlatformActionArgs({
+      input: JSON.stringify({
+        resources: [
+          {
+            resource: 'tasks',
+            action: 'create',
+            parameters: {
+              title: 'Legacy task',
+              assigned_agent: 'default',
+            },
+          },
+        ],
+      }),
+    })
+
+    assert.equal(out.resource, 'tasks')
+    assert.equal(out.action, 'create')
+    assert.deepEqual(JSON.parse(String(out.data)), {
+      title: 'Legacy task',
+      assigned_agent: 'default',
+    })
+  })
+
+  it('normalizes singular resource names and resource payload objects', () => {
+    const out = normalizePlatformActionArgs({
+      input: JSON.stringify({
+        resource: 'task',
+        action: 'create',
+        task: {
+          title: 'Legacy singular task',
+          assigned_to: 'default',
+        },
+      }),
+    })
+
+    assert.equal(out.resource, 'tasks')
+    assert.equal(out.action, 'create')
+    assert.deepEqual(JSON.parse(String(out.data)), {
+      title: 'Legacy singular task',
+      assigned_to: 'default',
+    })
+  })
+
+  it('normalizes legacy backlog task resource names to tasks', () => {
+    const out = normalizePlatformActionArgs({
+      input: JSON.stringify({
+        resource: 'backlog_task',
+        action: 'create',
+        backlog_task: {
+          title: 'Legacy backlog task',
+          description: 'Keep the intended task payload',
+        },
+      }),
+    })
+
+    assert.equal(out.resource, 'tasks')
+    assert.equal(out.action, 'create')
+    assert.deepEqual(JSON.parse(String(out.data)), {
+      title: 'Legacy backlog task',
+      description: 'Keep the intended task payload',
+    })
+  })
+
+  it('normalizes resources entries that use type instead of resource', () => {
+    const out = normalizePlatformActionArgs({
+      input: JSON.stringify({
+        action: 'create',
+        resources: [
+          {
+            type: 'task',
+            parameters: {
+              title: 'Typed task resource',
+              description: 'Created through a typed resources envelope',
+            },
+          },
+        ],
+      }),
+    })
+
+    assert.equal(out.resource, 'tasks')
+    assert.equal(out.action, 'create')
+    assert.deepEqual(JSON.parse(String(out.data)), {
+      title: 'Typed task resource',
+      description: 'Created through a typed resources envelope',
+    })
+  })
+
+  it('infers schedules resource from create_schedule style actions', () => {
+    const out = normalizePlatformActionArgs({
+      input: JSON.stringify({
+        action: 'create_schedule',
+        data: {
+          name: 'Surgery check-in',
+          scheduleType: 'once',
+        },
+      }),
+    })
+
+    assert.equal(out.resource, 'schedules')
+    assert.equal(out.action, 'create')
+    assert.deepEqual(JSON.parse(String(out.data)), {
+      name: 'Surgery check-in',
+      scheduleType: 'once',
+    })
+  })
+})