@2en/clawly-plugins 1.24.7-beta.0 → 1.24.7-beta.2

package/cron-hook.ts

@@ -2,8 +2,8 @@
  * before_tool_call hook for cron (action=add) — ensures delivery fields are
  * always set correctly, even when the LLM omits them.
  *
- * Forces: delivery.mode = "none" (agent uses clawly_send_message tool)
- * Appends: delivery instructions to payload.message
+ * Forces: delivery.mode = "none" (delivery is handled by the cron-delivery
+ * agent_end hook which injects results into the main session via chat.inject)
  * Patches: payload.kind "systemEvent" → "agentTurn"
  *
  * The cron tool name is "cron" (not "cron.create"). The LLM passes
@@ -19,27 +19,14 @@ function isRecord(v: unknown): v is UnknownRecord {
   return typeof v === 'object' && v !== null && !Array.isArray(v)
 }
 
-const DELIVERY_SUFFIX = [
-  '',
-  '---',
-  'DELIVERY INSTRUCTIONS (mandatory):',
-  'When done, you MUST deliver your result to the user:',
-  '1. Call the clawly_send_message tool with role="assistant" and a brief, natural summary of your result.',
-].join('\n')
-
 function patchJob(job: UnknownRecord): UnknownRecord {
   const patched: UnknownRecord = {...job}
 
-  // Force delivery.mode = "none" — agent reports via tools explicitly
-  patched.delivery = {mode: 'none'}
-
-  // Append delivery instructions to payload.message
-  if (isRecord(job.payload) && typeof job.payload.message === 'string') {
-    patched.payload = {
-      ...job.payload,
-      message: job.payload.message + DELIVERY_SUFFIX,
-    }
-  }
+  // Force delivery.mode = "none" — delivery is handled by the cron-delivery
+  // agent_end hook (injects result into main session via chat.inject)
+  // Preserve other delivery fields (e.g. channel) if the agent set them
+  const existing = isRecord(job.delivery) ? job.delivery : {}
+  patched.delivery = {...existing, mode: 'none'}
 
   // Patch payload.kind: systemEvent → agentTurn
   if (isRecord(patched.payload) && (patched.payload as UnknownRecord).kind === 'systemEvent') {
@@ -73,5 +60,5 @@ export function registerCronHook(api: PluginApi) {
     return {params}
   })
 
-  api.logger.info('hook: registered before_tool_call for cron add delivery enforcement')
+  api.logger.info('hook: registered before_tool_call for cron add (none + agentTurn enforcement)')
 }

package/gateway/config-repair.ts

@@ -91,28 +91,23 @@ export function registerConfigRepair(api: PluginApi) {
       return
     }
 
-    // Repair: derive models from agents.defaults (same logic as model-gateway-setup)
+    // Repair: derive models from agents.defaults (same logic as model-gateway-setup).
+    // Image fallback is handled server-side by the model-gateway proxy, so only
+    // the default chat model is registered (with image support).
     const defaultModelFull: string = (config.agents as any)?.defaults?.model?.primary ?? ''
-    const imageModelFull: string = (config.agents as any)?.defaults?.imageModel?.primary ?? ''
 
     const prefix = `${PROVIDER_NAME}/`
     const defaultModel = defaultModelFull.startsWith(prefix)
       ? defaultModelFull.slice(prefix.length)
       : defaultModelFull
-    const imageModel = imageModelFull.startsWith(prefix)
-      ? imageModelFull.slice(prefix.length)
-      : imageModelFull
 
-    const extraModels = EXTRA_GATEWAY_MODELS.map(({id, name, input}) => ({id, name, input}))
+    const defaultIds = new Set([defaultModel])
+    const extraModels = EXTRA_GATEWAY_MODELS.filter((m) => !defaultIds.has(m.id)).map(
+      ({id, name, input}) => ({id, name, input}),
+    )
     const models = !defaultModel
       ? (provider?.models ?? [])
-      : defaultModel === imageModel || !imageModel
-        ? [{id: defaultModel, name: defaultModel, input: ['text', 'image']}, ...extraModels]
-        : [
-            {id: defaultModel, name: defaultModel, input: ['text']},
-            {id: imageModel, name: imageModel, input: ['text', 'image']},
-            ...extraModels,
-          ]
+      : [{id: defaultModel, name: defaultModel, input: ['text', 'image']}, ...extraModels]
 
     if (!config.models) config.models = {}
     if (!(config.models as any).providers) (config.models as any).providers = {}
@@ -130,9 +125,6 @@ export function registerConfigRepair(api: PluginApi) {
       const defaults = agents.defaults ?? {}
       const modelsMap: Record<string, {alias: string}> = {
         [`${PROVIDER_NAME}/${defaultModel}`]: {alias: defaultModel},
-        ...(imageModel && imageModel !== defaultModel
-          ? {[`${PROVIDER_NAME}/${imageModel}`]: {alias: imageModel}}
-          : {}),
       }
       for (const m of EXTRA_GATEWAY_MODELS) {
         modelsMap[`${PROVIDER_NAME}/${m.id}`] = {alias: m.alias}

package/gateway/cron-delivery.ts

@@ -0,0 +1,98 @@
+/**
+ * Cron delivery via agent_end hook — injects cron session results into the
+ * main chat session programmatically via `chat.inject`.
+ *
+ * When a cron job completes in an isolated session, this hook:
+ * 1. Detects cron sessions via `ctx.sessionKey.startsWith('agent:clawly:cron:')`
+ * 2. Extracts the last assistant message (raw, preserving formatting)
+ * 3. Filters noise (empty, NO_REPLY, heartbeat-only, system message leak)
+ * 4. Resolves the main session key via `sessions.resolve`
+ * 5. Injects the result into the main session via `chat.inject`
+ *
+ * This runs independently of offline-push — both fire on agent_end but serve
+ * different purposes. `chat.inject` does NOT trigger a new agent_end (it's a
+ * transcript injection, not an agent turn), so no infinite loop risk.
+ */
+
+import type {PluginApi} from '../types'
+import {injectAssistantMessage, resolveSessionKey} from './inject'
+import {shouldSkipPushForMessage} from './offline-push'
+
+/**
+ * Extract the last assistant message's full text from a messages array.
+ * Preserves original formatting (newlines, whitespace) — unlike the
+ * collapsed version in offline-push used for notification previews.
+ */
+function getRawLastAssistantText(messages: unknown): string | null {
+  if (!Array.isArray(messages)) return null
+
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i]
+    if (typeof msg !== 'object' || msg === null) continue
+    if ((msg as any).role !== 'assistant') continue
+
+    const content = (msg as any).content
+    if (typeof content === 'string') return content.trim()
+    if (Array.isArray(content)) {
+      const text = content
+        .filter((p: any) => typeof p === 'object' && p !== null && p.type === 'text')
+        .map((p: any) => p.text)
+        .join('')
+      return text.trim()
+    }
+    return null
+  }
+
+  return null
+}
+
+export function registerCronDelivery(api: PluginApi) {
+  api.on('agent_end', async (event: Record<string, unknown>, ctx?: Record<string, unknown>) => {
+    const sessionKey = typeof ctx?.sessionKey === 'string' ? ctx.sessionKey : undefined
+    const agentId = typeof ctx?.agentId === 'string' ? ctx.agentId : undefined
+
+    // Only fire for cron sessions
+    if (!sessionKey?.startsWith('agent:clawly:cron:')) return
+
+    try {
+      // Extract raw assistant text (preserving formatting)
+      const text = getRawLastAssistantText(event.messages)
+      if (text == null) {
+        api.logger.info('cron-delivery: skipped (no assistant message)')
+        return
+      }
+
+      // Filter noise — reuse the same logic as offline-push
+      const reason = shouldSkipPushForMessage(text)
+      if (reason) {
+        api.logger.info(`cron-delivery: skipped (filtered: ${reason})`)
+        return
+      }
+
+      // Resolve main session key for this agent
+      if (!agentId) {
+        api.logger.error('cron-delivery: skipped (no agentId on ctx)')
+        return
+      }
+
+      const mainSessionKey = await resolveSessionKey(agentId, api)
+
+      // Inject the cron result into the main session
+      const result = await injectAssistantMessage(
+        {
+          sessionKey: mainSessionKey,
+          message: text,
+        },
+        api,
+      )
+
+      api.logger.info(
+        `cron-delivery: injected into ${mainSessionKey} (messageId=${result.messageId})`,
+      )
+    } catch (err) {
+      api.logger.error(`cron-delivery: ${err instanceof Error ? err.message : String(err)}`)
+    }
+  })
+
+  api.logger.info('cron-delivery: registered agent_end hook')
+}

package/gateway/index.ts

@@ -2,6 +2,7 @@ import type {PluginApi} from '../types'
 import {registerAgentSend} from './agent'
 import {registerClawhub2gateway} from './clawhub2gateway'
 import {registerConfigRepair} from './config-repair'
+import {registerCronDelivery} from './cron-delivery'
 import {registerPairing} from './pairing'
 import {registerMemoryBrowser} from './memory'
 import {registerNotification} from './notification'
@@ -18,6 +19,7 @@ export function registerGateway(api: PluginApi) {
   registerClawhub2gateway(api)
   registerPlugins(api)
   registerOfflinePush(api)
+  registerCronDelivery(api)
   registerConfigRepair(api)
   registerPairing(api)
   registerVersion(api)

package/gateway/offline-push.test.ts

@@ -92,7 +92,10 @@ describe('offline-push', () => {
     await handlers.get('agent_end')!({}, {sessionKey: 'agent:clawly:main'})
 
     expect(logs.filter((l) => l.msg.includes('notified'))).toHaveLength(0)
-    expect(logs.filter((l) => l.msg.includes('skipped'))).toHaveLength(0)
+    expect(logs).toContainEqual({
+      level: 'info',
+      msg: expect.stringContaining('skipped (client online)'),
+    })
   })
 
   test('sends push for consecutive calls on same session', async () => {

package/gateway/offline-push.ts

@@ -104,7 +104,10 @@ export function registerOfflinePush(api: PluginApi) {
     try {
       // Skip if client is still connected — they got the response in real-time.
       const online = await isClientOnline()
-      if (online) return
+      if (online) {
+        api.logger.info('offline-push: skipped (client online)')
+        return
+      }
 
       // Extract full assistant text for filtering and preview.
       const fullText = getLastAssistantText(event.messages)

package/gateway/presence.test.ts

@@ -6,8 +6,8 @@ describe('isOnlineEntry', () => {
     expect(isOnlineEntry({host: 'openclaw-ios', reason: 'foreground'})).toBe(true)
   })
 
-  test('returns true for reason "connect" (backward compat)', () => {
-    expect(isOnlineEntry({host: 'openclaw-ios', reason: 'connect'})).toBe(true)
+  test('returns false for reason "connect" (gateway WS state, not reliable for app foreground)', () => {
+    expect(isOnlineEntry({host: 'openclaw-ios', reason: 'connect'})).toBe(false)
   })
 
   test('returns false for reason "background"', () => {

package/gateway/presence.ts

@@ -19,10 +19,12 @@ interface PresenceEntry {
   reason?: string
 }
 
-/** Returns true if the presence entry indicates the client is actively connected. */
+/** Returns true if the presence entry indicates the client is actively in the foreground.
+ *  Only trusts the explicit 'foreground' signal from the mobile app — 'connect'
+ *  (gateway WS state) can linger after the app backgrounds, causing false positives. */
 export function isOnlineEntry(entry: PresenceEntry | undefined): boolean {
   if (!entry) return false
-  return entry.reason === 'foreground' || entry.reason === 'connect'
+  return entry.reason === 'foreground'
 }
 
 /**

package/index.ts

@@ -25,7 +25,7 @@
  * - before_message_write — restores original /skill command in user messages (undoes gateway rewrite)
  * - tool_result_persist   — copies TTS audio to persistent outbound directory
  * - before_tool_call      — enforces delivery fields on cron.create
- * - agent_end             — sends push notification when client is offline
+ * - agent_end             — sends push notification when client is offline; injects cron results into main session
  * - gateway_start         — auto-approves device pairing for Clawly mobile clients (clientId: openclaw-ios)
  * - gateway_start         — registers auto-update cron job (0 3 * * *) for clawly-plugins
  */

package/model-gateway-setup.ts

@@ -1,7 +1,7 @@
 /**
  * On plugin init, patches openclaw.json to add the `clawly-model-gateway`
  * model provider entry.  Credentials come from pluginConfig; the model list
- * is derived from `agents.defaults.model` / `agents.defaults.imageModel`
+ * is derived from `agents.defaults.model`
  * already present in the config.
  *
  * This runs synchronously during plugin registration (before gateway_start).
@@ -159,30 +159,22 @@ export function patchModelGateway(config: Record<string, unknown>, api: PluginAp
     return false
   }
 
-  // Derive model IDs from agents.defaults
+  // Derive default model ID from agents.defaults.
+  // Image fallback is handled server-side by the model-gateway proxy, so only
+  // the default chat model needs to be registered in the provider's model list.
   const defaultModelFull: string = (config.agents as any)?.defaults?.model?.primary ?? ''
-  const imageModelFull: string = (config.agents as any)?.defaults?.imageModel?.primary ?? ''
 
   const prefix = `${PROVIDER_NAME}/`
   const defaultModel = defaultModelFull.startsWith(prefix)
     ? defaultModelFull.slice(prefix.length)
     : defaultModelFull
-  const imageModel = imageModelFull.startsWith(prefix)
-    ? imageModelFull.slice(prefix.length)
-    : imageModelFull
 
   if (!defaultModel) {
     api.logger.warn('No default model found in agents.defaults — model gateway setup skipped.')
     return false
   }
 
-  const defaultModels =
-    defaultModel === imageModel || !imageModel
-      ? [{id: defaultModel, name: defaultModel, input: ['text', 'image']}]
-      : [
-          {id: defaultModel, name: defaultModel, input: ['text']},
-          {id: imageModel, name: imageModel, input: ['text', 'image']},
-        ]
+  const defaultModels = [{id: defaultModel, name: defaultModel, input: ['text', 'image']}]
 
   const defaultIds = new Set(defaultModels.map((m) => m.id))
   const models = [
@@ -208,9 +200,6 @@ export function patchModelGateway(config: Record<string, unknown>, api: PluginAp
   const defaults = agents.defaults ?? {}
   const modelsMap: Record<string, {alias: string}> = {
     [`${PROVIDER_NAME}/${defaultModel}`]: {alias: defaultModel},
-    ...(imageModel && imageModel !== defaultModel
-      ? {[`${PROVIDER_NAME}/${imageModel}`]: {alias: imageModel}}
-      : {}),
   }
   for (const m of EXTRA_GATEWAY_MODELS) {
     modelsMap[`${PROVIDER_NAME}/${m.id}`] = {alias: m.alias}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2en/clawly-plugins",
-  "version": "1.24.7-beta.0",
+  "version": "1.24.7-beta.2",
   "module": "index.ts",
   "type": "module",
   "repository": {

package/tools/clawly-send-message.test.ts

@@ -0,0 +1,247 @@
+import {beforeEach, describe, expect, mock, test} from 'bun:test'
+import type {PluginApi} from '../types'
+import {registerSendMessageTool} from './clawly-send-message'
+
+// ── Mocks ────────────────────────────────────────────────────────
+
+let mockOnline = false
+let mockPushSent = true
+let mockInjectResult = {ok: true, messageId: 'msg-123'}
+let mockResolvedSessionKey = 'agent:clawly:main'
+let mockAgentResult = {ok: true, runId: 'run-456', error: undefined as string | undefined}
+
+let lastInjectParams: {sessionKey: string; message: string; label?: string} | null = null
+let lastPushOpts: {
+  body: string
+  agentId?: string
+  data?: Record<string, unknown>
+} | null = null
+let lastAgentParams: {message: string; agentId: string} | null = null
+
+mock.module('../gateway/presence', () => ({
+  isClientOnline: async () => mockOnline,
+}))
+
+mock.module('../gateway/notification', () => ({
+  sendPushNotification: async (
+    opts: {body: string; agentId?: string; data?: Record<string, unknown>},
+    _api: PluginApi,
+  ) => {
+    lastPushOpts = opts
+    return mockPushSent
+  },
+}))
+
+mock.module('../gateway/inject', () => ({
+  resolveSessionKey: async () => mockResolvedSessionKey,
+  injectAssistantMessage: async (params: {sessionKey: string; message: string; label?: string}) => {
+    lastInjectParams = params
+    return mockInjectResult
+  },
+}))
+
+mock.module('../gateway/agent', () => ({
+  callAgentGateway: async (params: {message: string; agentId: string}) => {
+    lastAgentParams = params
+    return mockAgentResult
+  },
+}))
+
+// ── Helpers ──────────────────────────────────────────────────────
+
+type ToolExecute = (
+  toolCallId: string,
+  params: Record<string, unknown>,
+) => Promise<{content: {type: string; text: string}[]}>
+
+function createMockApi(): {
+  api: PluginApi
+  logs: {level: string; msg: string}[]
+  execute: ToolExecute
+} {
+  const logs: {level: string; msg: string}[] = []
+  let registeredExecute: ToolExecute | null = null
+
+  const api = {
+    id: 'test',
+    name: 'test',
+    logger: {
+      info: (msg: string) => logs.push({level: 'info', msg}),
+      warn: (msg: string) => logs.push({level: 'warn', msg}),
+      error: (msg: string) => logs.push({level: 'error', msg}),
+    },
+    registerTool: (tool: {execute: ToolExecute}) => {
+      registeredExecute = tool.execute
+    },
+  } as unknown as PluginApi
+
+  registerSendMessageTool(api)
+
+  return {api, logs, execute: registeredExecute!}
+}
+
+function parseResult(res: {content: {type: string; text: string}[]}): Record<string, unknown> {
+  return JSON.parse(res.content[0].text)
+}
+
+// ── Tests ────────────────────────────────────────────────────────
+
+beforeEach(() => {
+  mockOnline = false
+  mockPushSent = true
+  mockInjectResult = {ok: true, messageId: 'msg-123'}
+  mockResolvedSessionKey = 'agent:clawly:main'
+  mockAgentResult = {ok: true, runId: 'run-456', error: undefined}
+  lastInjectParams = null
+  lastPushOpts = null
+  lastAgentParams = null
+})
+
+describe('clawly_send_message', () => {
+  describe('role: assistant (default)', () => {
+    test('injects message and resolves session key', async () => {
+      mockOnline = true
+      const {execute} = createMockApi()
+
+      const res = parseResult(await execute('tc-1', {message: 'Hello from cron'}))
+
+      expect(res.sent).toBe(true)
+      expect(res.messageId).toBe('msg-123')
+      expect(lastInjectParams).toEqual({
+        sessionKey: 'agent:clawly:main',
+        message: 'Hello from cron',
+      })
+    })
+
+    test('uses explicit sessionKey when provided', async () => {
+      mockOnline = true
+      const {execute} = createMockApi()
+
+      await execute('tc-1', {message: 'Hi', sessionKey: 'agent:clawly:custom'})
+
+      expect(lastInjectParams?.sessionKey).toBe('agent:clawly:custom')
+    })
+
+    test('uses custom agent ID', async () => {
+      mockOnline = true
+      const {execute} = createMockApi()
+
+      await execute('tc-1', {message: 'Hi', agent: 'luna'})
+
+      // resolveSessionKey is called with 'luna' — mock always returns mockResolvedSessionKey
+      expect(lastInjectParams?.sessionKey).toBe('agent:clawly:main')
+    })
+
+    test('sends push when client is offline', async () => {
+      mockOnline = false
+      const {execute} = createMockApi()
+
+      const res = parseResult(await execute('tc-1', {message: 'Weather report'}))
+
+      expect(res.sent).toBe(true)
+      expect(res.pushSent).toBe(true)
+      expect(lastPushOpts).toEqual({
+        body: 'Weather report',
+        agentId: 'clawly',
+        data: {type: 'send_message'},
+      })
+    })
+
+    test('does not send push when client is online', async () => {
+      mockOnline = true
+      const {execute} = createMockApi()
+
+      const res = parseResult(await execute('tc-1', {message: 'Weather report'}))
+
+      expect(res.sent).toBe(true)
+      expect(res.pushSent).toBe(false)
+      expect(lastPushOpts).toBeNull()
+    })
+
+    test('truncates push body to 140 chars', async () => {
+      mockOnline = false
+      const {execute} = createMockApi()
+
+      const longMessage = 'a'.repeat(200)
+      await execute('tc-1', {message: longMessage})
+
+      expect(lastPushOpts!.body.length).toBe(141) // 140 + "…"
+      expect(lastPushOpts!.body.endsWith('…')).toBe(true)
+    })
+
+    test('push failure does not fail the tool call', async () => {
+      mockOnline = false
+      mockPushSent = false
+      const {execute, logs} = createMockApi()
+
+      const res = parseResult(await execute('tc-1', {message: 'Hi'}))
+
+      expect(res.sent).toBe(true)
+      expect(res.pushSent).toBe(false)
+      expect(logs).toContainEqual({
+        level: 'info',
+        msg: expect.stringContaining('push failed'),
+      })
+    })
+
+    test('returns pushSent false when push throws', async () => {
+      // Override the mock to throw — re-mock would conflict, so test the
+      // catch path indirectly: mockOnline=true means no push attempt at all.
+      mockOnline = true
+      const {execute} = createMockApi()
+
+      const res = parseResult(await execute('tc-1', {message: 'Hi'}))
+
+      expect(res.sent).toBe(true)
+      expect(res.pushSent).toBe(false)
+    })
+  })
+
+  describe('role: user', () => {
+    test('triggers agent turn via gateway', async () => {
+      const {execute} = createMockApi()
+
+      const res = parseResult(await execute('tc-1', {message: 'Do something', role: 'user'}))
+
+      expect(res.sent).toBe(true)
+      expect(res.runId).toBe('run-456')
+      expect(lastAgentParams).toEqual({message: 'Do something', agentId: 'clawly'})
+    })
+
+    test('returns error when gateway fails', async () => {
+      mockAgentResult = {ok: false, runId: undefined as any, error: 'agent busy'}
+      const {execute} = createMockApi()
+
+      const res = parseResult(await execute('tc-1', {message: 'Do something', role: 'user'}))
+
+      expect(res.sent).toBe(false)
+      expect(res.error).toBe('agent busy')
+    })
+  })
+
+  describe('validation', () => {
+    test('returns error for empty message', async () => {
+      const {execute} = createMockApi()
+
+      const res = parseResult(await execute('tc-1', {message: ''}))
+
+      expect(res.error).toBe('message is required')
+    })
+
+    test('returns error for missing message', async () => {
+      const {execute} = createMockApi()
+
+      const res = parseResult(await execute('tc-1', {}))
+
+      expect(res.error).toBe('message is required')
+    })
+
+    test('trims whitespace-only message as empty', async () => {
+      const {execute} = createMockApi()
+
+      const res = parseResult(await execute('tc-1', {message: '   '}))
+
+      expect(res.error).toBe('message is required')
+    })
+  })
+})

package/tools/clawly-send-message.ts

@@ -10,6 +10,8 @@
 import type {PluginApi} from '../types'
 import {callAgentGateway} from '../gateway/agent'
 import {injectAssistantMessage, resolveSessionKey} from '../gateway/inject'
+import {sendPushNotification} from '../gateway/notification'
+import {isClientOnline} from '../gateway/presence'
 
 const TOOL_NAME = 'clawly_send_message'
 
@@ -57,9 +59,30 @@ export function registerSendMessageTool(api: PluginApi) {
           api.logger.info(
             `${TOOL_NAME}: injected assistant message (${message.length} chars) into session ${sessionKey}`,
           )
+
+          // Send push notification if user is offline
+          let pushSent = false
+          try {
+            const online = await isClientOnline()
+            if (!online) {
+              const preview = message.length > 140 ? `${message.slice(0, 140)}…` : message
+              pushSent =
+                (await sendPushNotification(
+                  {body: preview, agentId: agent, data: {type: 'send_message'}},
+                  api,
+                )) ?? false
+              api.logger.info(`${TOOL_NAME}: push ${pushSent ? 'sent' : 'failed'} (client offline)`)
+            }
+          } catch {
+            // Push is best-effort — don't fail the tool call
+          }
+
           return {
             content: [
-              {type: 'text', text: JSON.stringify({sent: true, messageId: result.messageId})},
+              {
+                type: 'text',
+                text: JSON.stringify({sent: true, messageId: result.messageId, pushSent}),
+              },
             ],
           }
         }