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

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

@@ -82,7 +82,6 @@ export function registerCronDelivery(api: PluginApi) {
         {
           sessionKey: mainSessionKey,
           message: text,
-          label: 'cron',
         },
         api,
       )

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.1",
+  "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}),
+              },
             ],
           }
         }