@2en/clawly-plugins 1.29.0-beta.1 → 1.29.0-beta.4

package/gateway/audit.ts

@@ -7,7 +7,7 @@
  */
 
 import {$} from 'zx'
-import {stripCliLogsFull} from '../lib/stripCliLogs'
+import {stripCliLogs} from '../lib/stripCliLogs'
 import type {PluginApi} from '../types'
 
 const TIMEOUT_MS = 30_000
@@ -27,7 +27,7 @@ export function registerAudit(api: PluginApi) {
         })
         return
       }
-      const json = stripCliLogsFull(result.stdout)
+      const json = stripCliLogs(result.stdout)
       respond(true, JSON.parse(json))
     } catch (err) {
       respond(false, undefined, {message: err instanceof Error ? err.message : 'Unknown error'})

package/gateway/config-repair.ts

@@ -83,11 +83,31 @@ export function registerConfigRepair(api: PluginApi) {
 
     const defaultIds = new Set([defaultModel])
     const extraModels = EXTRA_GATEWAY_MODELS.filter((m) => !defaultIds.has(m.id)).map(
-      ({id, name, input}) => ({id, name, input}),
+      ({id, name, input, contextWindow, maxTokens, api}) => ({
+        id,
+        name,
+        input,
+        contextWindow,
+        maxTokens,
+        ...(api ? {api} : {}),
+      }),
     )
+    const extraMatch = EXTRA_GATEWAY_MODELS.find((m) => m.id === defaultModel)
     const models = !defaultModel
       ? (provider?.models ?? [])
-      : [{id: defaultModel, name: defaultModel, input: ['text', 'image']}, ...extraModels]
+      : [
+          {
+            id: defaultModel,
+            name: defaultModel,
+            input: extraMatch ? [...extraMatch.input] : (['text', 'image'] as string[]),
+            ...(extraMatch && {
+              contextWindow: extraMatch.contextWindow,
+              maxTokens: extraMatch.maxTokens,
+            }),
+            ...(extraMatch?.api ? {api: extraMatch.api} : {}),
+          },
+          ...extraModels,
+        ]
 
     if (!config.models) config.models = {}
     if (!(config.models as any).providers) (config.models as any).providers = {}

package/gateway/cron-delivery.test.ts

@@ -0,0 +1,385 @@
+import {beforeEach, describe, expect, mock, test} from 'bun:test'
+import type {PluginApi} from '../types'
+
+// ── Mocks ────────────────────────────────────────────────────────
+
+let mockResolvedKey = 'agent:clawly:main'
+let mockInjectResult = {ok: true, messageId: 'msg-001'}
+let mockResolveError: Error | null = null
+let mockInjectError: Error | null = null
+let resolveSessionKeyCalls: string[] = []
+let injectCalls: {sessionKey: string; message: string}[] = []
+
+mock.module('./inject', () => ({
+  resolveSessionKey: async (agentId: string) => {
+    resolveSessionKeyCalls.push(agentId)
+    if (mockResolveError) throw mockResolveError
+    return mockResolvedKey
+  },
+  injectAssistantMessage: async (params: {sessionKey: string; message: string}) => {
+    injectCalls.push(params)
+    if (mockInjectError) throw mockInjectError
+    return mockInjectResult
+  },
+}))
+
+// Do NOT mock cron-telemetry — it uses module-internal state (Maps) that
+// cron-telemetry.test.ts depends on, and Bun's mock.module contaminates
+// across test files in the same process. Assert on logs + inject calls instead.
+
+// autoUpdateJobId is a `let` export — ESM namespace objects are frozen,
+// so we can't mutate it between tests. We set it to 'test-auto-update-id'
+// and test the job-ID matching path using a sessionKey that embeds this ID.
+const MOCK_AUTO_UPDATE_ID = 'test-auto-update-id'
+
+mock.module('../internal/hooks/auto-update', () => ({
+  autoUpdateJobId: MOCK_AUTO_UPDATE_ID,
+  JOB_NAME: 'Clawly Plugins Auto-Update',
+}))
+
+// Must import after mocks
+const {registerCronDelivery} = await import('./cron-delivery')
+
+// ── Helpers ──────────────────────────────────────────────────────
+
+type Handler = (event: Record<string, unknown>, ctx?: Record<string, unknown>) => Promise<void>
+
+function createMockApi(): {
+  api: PluginApi
+  logs: {level: string; msg: string}[]
+  handlers: Map<string, Handler>
+} {
+  const logs: {level: string; msg: string}[] = []
+  const handlers = new Map<string, Handler>()
+  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}),
+    },
+    on: (hookName: string, handler: (...args: any[]) => any) => {
+      handlers.set(hookName, handler as any)
+    },
+  } as unknown as PluginApi
+  return {api, logs, handlers}
+}
+
+function makeMessages(assistantContent: string | object[]) {
+  return [
+    {role: 'user', content: 'trigger message'},
+    {role: 'assistant', content: assistantContent},
+  ]
+}
+
+// ── Tests ────────────────────────────────────────────────────────
+
+beforeEach(() => {
+  mockResolvedKey = 'agent:clawly:main'
+  mockInjectResult = {ok: true, messageId: 'msg-001'}
+  mockResolveError = null
+  mockInjectError = null
+  resolveSessionKeyCalls = []
+  injectCalls = []
+})
+
+describe('cron-delivery', () => {
+  describe('session filtering', () => {
+    test('skips non-cron sessions (main)', async () => {
+      const {api, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('Hello!')},
+        {sessionKey: 'agent:clawly:main', agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(0)
+      expect(resolveSessionKeyCalls).toHaveLength(0)
+    })
+
+    test('skips non-cron sessions (telegram)', async () => {
+      const {api, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('Hello!')},
+        {sessionKey: 'agent:clawly:telegram:12345', agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(0)
+    })
+
+    test('skips when sessionKey is missing', async () => {
+      const {api, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!({messages: makeMessages('Hello!')}, {})
+
+      expect(injectCalls).toHaveLength(0)
+    })
+  })
+
+  describe('assistant text extraction', () => {
+    test('skips when no assistant message in event', async () => {
+      const {api, logs, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: [{role: 'user', content: 'Hello'}]},
+        {sessionKey: 'agent:clawly:cron:weather-check', agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(0)
+      expect(logs).toContainEqual({
+        level: 'info',
+        msg: 'cron-delivery: skipped (no assistant message)',
+      })
+    })
+
+    test('skips when messages is undefined', async () => {
+      const {api, logs, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {},
+        {sessionKey: 'agent:clawly:cron:weather-check', agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(0)
+      expect(logs).toContainEqual({
+        level: 'info',
+        msg: 'cron-delivery: skipped (no assistant message)',
+      })
+    })
+
+    test('extracts string content', async () => {
+      const {api, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('Weather is sunny today!')},
+        {sessionKey: 'agent:clawly:cron:weather-check', agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(1)
+      expect(injectCalls[0].message).toBe('Weather is sunny today!')
+    })
+
+    test('extracts array content (multi-part text)', async () => {
+      const {api, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {
+          messages: makeMessages([
+            {type: 'text', text: 'Part 1 '},
+            {type: 'text', text: 'Part 2'},
+          ]),
+        },
+        {sessionKey: 'agent:clawly:cron:weather-check', agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(1)
+      expect(injectCalls[0].message).toBe('Part 1 Part 2')
+    })
+
+    test('preserves raw formatting (newlines)', async () => {
+      const {api, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('Line one\n\nLine two')},
+        {sessionKey: 'agent:clawly:cron:weather-check', agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(1)
+      // cron-delivery uses getRawLastAssistantText which preserves newlines
+      expect(injectCalls[0].message).toBe('Line one\n\nLine two')
+    })
+  })
+
+  describe('auto-update filtering', () => {
+    test('skips by job ID match in sessionKey', async () => {
+      const {api, logs, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      // sessionKey embeds MOCK_AUTO_UPDATE_ID — matches the primary job-ID check
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('Update complete')},
+        {sessionKey: `agent:clawly:cron:${MOCK_AUTO_UPDATE_ID}`, agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(0)
+      expect(logs).toContainEqual({level: 'info', msg: 'cron-delivery: skipped (auto-update job)'})
+    })
+
+    test('skips by JOB_NAME text match (fallback)', async () => {
+      const {api, logs, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      // sessionKey does NOT match the job ID — falls through to text-based detection
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('Clawly Plugins Auto-Update completed successfully')},
+        {sessionKey: 'agent:clawly:cron:some-other-id', agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(0)
+      expect(logs).toContainEqual({level: 'info', msg: 'cron-delivery: skipped (auto-update job)'})
+    })
+  })
+
+  describe('noise filtering', () => {
+    test('skips NO_REPLY', async () => {
+      const {api, logs, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('NO_REPLY')},
+        {sessionKey: 'agent:clawly:cron:weather-check', agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(0)
+      expect(logs).toContainEqual({
+        level: 'info',
+        msg: expect.stringContaining('skipped (filtered: silent reply)'),
+      })
+    })
+
+    test('skips HEARTBEAT_OK (bare)', async () => {
+      const {api, logs, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('HEARTBEAT_OK')},
+        {sessionKey: 'agent:clawly:cron:weather-check', agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(0)
+      expect(logs).toContainEqual({
+        level: 'info',
+        msg: expect.stringContaining('skipped (filtered: heartbeat ack)'),
+      })
+    })
+
+    test('skips empty text', async () => {
+      const {api, logs, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('   ')},
+        {sessionKey: 'agent:clawly:cron:weather-check', agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(0)
+      expect(logs).toContainEqual({
+        level: 'info',
+        msg: expect.stringContaining('skipped (filtered: empty assistant)'),
+      })
+    })
+
+    test('does not skip meaningful content ending with HEARTBEAT_OK', async () => {
+      const {api, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('Weather is good today. HEARTBEAT_OK')},
+        {sessionKey: 'agent:clawly:cron:weather-check', agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(1)
+    })
+  })
+
+  describe('agentId validation', () => {
+    test('skips when agentId is missing', async () => {
+      const {api, logs, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('Weather report')},
+        {sessionKey: 'agent:clawly:cron:weather-check'},
+      )
+
+      expect(injectCalls).toHaveLength(0)
+      expect(resolveSessionKeyCalls).toHaveLength(0)
+      expect(logs).toContainEqual({
+        level: 'error',
+        msg: 'cron-delivery: skipped (no agentId on ctx)',
+      })
+    })
+  })
+
+  describe('happy path', () => {
+    test('resolves session key and injects message', async () => {
+      const {api, logs, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('Weather is sunny today!')},
+        {sessionKey: 'agent:clawly:cron:weather-check', agentId: 'clawly'},
+      )
+
+      expect(resolveSessionKeyCalls).toEqual(['clawly'])
+      expect(injectCalls).toEqual([
+        {sessionKey: 'agent:clawly:main', message: 'Weather is sunny today!'},
+      ])
+      expect(logs).toContainEqual({
+        level: 'info',
+        msg: 'cron-delivery: injected into agent:clawly:main (messageId=msg-001)',
+      })
+    })
+
+    test('uses resolved session key (not hardcoded)', async () => {
+      mockResolvedKey = 'agent:luna:main'
+      const {api, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('Report ready')},
+        {sessionKey: 'agent:clawly:cron:daily-report', agentId: 'luna'},
+      )
+
+      expect(resolveSessionKeyCalls).toEqual(['luna'])
+      expect(injectCalls[0].sessionKey).toBe('agent:luna:main')
+    })
+  })
+
+  describe('error handling', () => {
+    test('handles resolveSessionKey failure gracefully', async () => {
+      mockResolveError = new Error('sessions.resolve failed: JSON parse error')
+      const {api, logs, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('Weather report')},
+        {sessionKey: 'agent:clawly:cron:weather-check', agentId: 'clawly'},
+      )
+
+      expect(injectCalls).toHaveLength(0)
+      expect(logs).toContainEqual({
+        level: 'error',
+        msg: 'cron-delivery: sessions.resolve failed: JSON parse error',
+      })
+    })
+
+    test('handles injectAssistantMessage failure gracefully', async () => {
+      mockInjectError = new Error('chat.inject failed: timeout')
+      const {api, logs, handlers} = createMockApi()
+      registerCronDelivery(api)
+
+      await handlers.get('agent_end')!(
+        {messages: makeMessages('Weather report')},
+        {sessionKey: 'agent:clawly:cron:weather-check', agentId: 'clawly'},
+      )
+
+      // injectAssistantMessage was called (recorded) but threw
+      expect(injectCalls).toHaveLength(1)
+      expect(logs).toContainEqual({
+        level: 'error',
+        msg: 'cron-delivery: chat.inject failed: timeout',
+      })
+    })
+  })
+})

package/gateway/cron-delivery.ts

@@ -52,12 +52,13 @@ 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
-    api.logger.info(
-      `cron-delivery[debug]: agent_end fired sessionKey=${sessionKey ?? 'undefined'} agentId=${agentId ?? 'undefined'} trigger=${String(ctx?.trigger ?? 'undefined')}`,
-    )
     // Only fire for cron sessions
     if (!sessionKey?.startsWith('agent:clawly:cron:')) return
 
+    api.logger.info(
+      `cron-delivery[debug]: agent_end fired sessionKey=${sessionKey} agentId=${agentId ?? 'undefined'} trigger=${String(ctx?.trigger ?? 'undefined')}`,
+    )
+
     try {
       // Extract raw assistant text (preserving formatting)
       const text = getRawLastAssistantText(event.messages)
@@ -78,7 +79,10 @@ export function registerCronDelivery(api: PluginApi) {
         return
       }
 
-      // Filter noise — reuse the same logic as offline-push
+      // Filter noise — reuse the same logic as offline-push.
+      // Note: shouldSkipPushForMessage was designed for newline-collapsed text
+      // (via getLastAssistantText), but works correctly here with raw text
+      // because all its regexes use \s (matches \n) and $ without /m flag.
       const reason = shouldSkipPushForMessage(text)
       if (reason) {
         api.logger.info(`cron-delivery: skipped (filtered: ${reason})`)

package/internal/hooks/auto-update.ts

@@ -4,7 +4,7 @@
  */
 import {$} from 'zx'
 
-import {stripCliLogsFull} from '../../lib/stripCliLogs'
+import {stripCliLogs} from '../../lib/stripCliLogs'
 import type {PluginApi} from '../../types'
 
 $.verbose = false
@@ -90,7 +90,7 @@ function needsUpdate(job: CronJobEntry, config: JobConfig): boolean {
 async function findJobs(): Promise<[unknown, CronJobEntry[]]> {
   try {
     const {stdout} = await $`openclaw cron list --json`
-    const parsed = JSON.parse(stripCliLogsFull(stdout))
+    const parsed = JSON.parse(stripCliLogs(stdout))
     const jobs: unknown[] = parsed?.jobs ?? parsed ?? []
     if (!Array.isArray(jobs)) return [null, []]
     return [null, jobs.filter((j: any) => j.name === JOB_NAME) as CronJobEntry[]]
@@ -136,7 +136,7 @@ export function registerAutoUpdate(api: PluginApi) {
         const {stdout} =
           await $`openclaw cron add ${['--name', JOB_NAME, '--json', ...configToArgs(JOB_CONFIG)]}`
         try {
-          const result = JSON.parse(stripCliLogsFull(stdout))
+          const result = JSON.parse(stripCliLogs(stdout))
           autoUpdateJobId = result?.id ?? null
         } catch {
           // ID extraction failed — job was still created

package/lib/stripCliLogs.test.ts

@@ -1,5 +1,5 @@
 import {describe, expect, test} from 'bun:test'
-import {stripCliLogs, stripCliLogsFull} from './stripCliLogs'
+import {stripCliLogs} from './stripCliLogs'
 
 describe('stripCliLogs', () => {
   test('strips leading log lines', () => {
@@ -82,9 +82,7 @@ describe('stripCliLogs', () => {
     const input = ['11:40:09 [plugins] loading', '[', '  {"id":"test"}', ']'].join('\n')
     expect(stripCliLogs(input)).toBe('[\n  {"id":"test"}\n]')
   })
-})
 
-describe('stripCliLogsFull', () => {
   test('strips both leading and trailing log lines around pretty-printed JSON', () => {
     const input = [
       '19:48:48 [plugins] feishu_drive: Registered feishu_drive tool',
@@ -94,29 +92,19 @@ describe('stripCliLogsFull', () => {
       '}',
       '19:48:49 [plugins] echo: registered /clawly_echo command',
     ].join('\n')
-    expect(stripCliLogsFull(input)).toBe('{\n  "jobs": []\n}')
-    expect(JSON.parse(stripCliLogsFull(input))).toEqual({jobs: []})
+    expect(stripCliLogs(input)).toBe('{\n  "jobs": []\n}')
+    expect(JSON.parse(stripCliLogs(input))).toEqual({jobs: []})
   })
 
   test('strips trailing log lines after compact single-line JSON', () => {
     const input = ['{"ok":true}', '19:48:49 [plugins] echo: registered /clawly_echo command'].join(
       '\n',
     )
-    expect(stripCliLogsFull(input)).toBe('{"ok":true}')
-  })
-
-  test('behaves like stripCliLogs when no trailing log lines', () => {
-    const input = ['11:40:09 [plugins] loading', '{', '  "version": "1.0.0"', '}'].join('\n')
-    expect(stripCliLogsFull(input)).toBe(stripCliLogs(input))
-  })
-
-  test('returns empty string when all lines are logs', () => {
-    const input = '11:00:00 [a] foo\n12:00:00 [b] bar'
-    expect(stripCliLogsFull(input)).toBe('')
+    expect(stripCliLogs(input)).toBe('{"ok":true}')
   })
 
   test('handles JSON array with leading and trailing logs', () => {
     const input = ['[plugins] loading', '[', '  {"id":"test"}', ']', '[plugins] done'].join('\n')
-    expect(stripCliLogsFull(input)).toBe('[\n  {"id":"test"}\n]')
+    expect(stripCliLogs(input)).toBe('[\n  {"id":"test"}\n]')
   })
 })

package/lib/stripCliLogs.ts

@@ -1,42 +1,27 @@
 /**
- * Strip leading log lines from `openclaw ... --json` output.
+ * Strip leading and trailing log lines from `openclaw ... --json` output.
  *
  * OpenClaw CLI may emit log lines (with or without ANSI colors / timestamps)
- * before the actual JSON payload:
+ * before and after the actual JSON payload:
  *
  *   11:40:09 [plugins] echo: registered /clawly_echo command
  *   \x1b[35m[plugins] tool: registered clawly_send_app_push agent tool
  *   [{"id":"clawly-plugins", ...}]
+ *   19:48:49 [plugins] echo: registered /clawly_echo command
  *
  * It may also emit a "Config warnings" box using box-drawing characters
  * (│, ◇, ├, ─, ╮, ╯) between log lines and the JSON body.
  *
- * This function strips ANSI escape sequences, drops every leading line that
- * is not JSON (log prefixes, warning boxes, blank lines), and returns the
- * remaining text (the JSON body).
+ * This function strips ANSI escape sequences, drops every leading and trailing
+ * line that is not JSON (log prefixes, warning boxes, blank lines), and returns
+ * the remaining text (the JSON body).
  */
 
 const ANSI_RE = /\x1b\[[0-9;]*m/g
 const JSON_START_RE = /^\{|^\[$|^\[[\s\][{"]/
-
-export function stripCliLogs(output: string): string {
-  const cleaned = output.replace(ANSI_RE, '')
-  const lines = cleaned.split('\n')
-  const firstJson = lines.findIndex((line) => JSON_START_RE.test(line))
-  if (firstJson === -1) return ''
-  return lines.slice(firstJson).join('\n').trim()
-}
-
-/**
- * Strip both leading AND trailing non-JSON lines from CLI output.
- *
- * `stripCliLogs` only strips leading lines. This variant also removes
- * trailing log lines that appear after the JSON body closes — e.g.
- * `19:48:49 [plugins] echo: registered /clawly_echo command`.
- */
 const JSON_END_RE = /^[}\]]$/
 
-export function stripCliLogsFull(output: string): string {
+export function stripCliLogs(output: string): string {
   const cleaned = output.replace(ANSI_RE, '')
   const lines = cleaned.split('\n')
   const firstJson = lines.findIndex((line) => JSON_START_RE.test(line))

package/model-gateway-setup.ts

@@ -27,51 +27,73 @@ export const PUBLIC_GATEWAY_MODELS = [
     canonicalId: 'moonshotai/kimi-k2.5',
     alias: 'Kimi K2.5',
     input: ['text', 'image'],
+    contextWindow: 262_144,
+    maxTokens: 65_535,
   },
   {
     canonicalId: 'google/gemini-2.5-pro',
     alias: 'Gemini 2.5 Pro',
     input: ['text', 'image'],
+    contextWindow: 1_048_576,
+    maxTokens: 65_536,
   },
   {
     canonicalId: 'google/gemini-3-pro-preview',
     alias: 'Gemini 3 Pro Preview',
     input: ['text', 'image'],
+    contextWindow: 1_048_576,
+    maxTokens: 65_536,
   },
   {
     canonicalId: 'anthropic/claude-sonnet-4.6',
     alias: 'Claude Sonnet 4.6',
     input: ['text', 'image'],
+    contextWindow: 1_000_000,
+    maxTokens: 128_000,
+    api: 'anthropic-messages',
   },
   {
     canonicalId: 'anthropic/claude-opus-4.6',
     alias: 'Claude Opus 4.6',
     input: ['text', 'image'],
+    contextWindow: 1_000_000,
+    maxTokens: 128_000,
+    api: 'anthropic-messages',
   },
   {
     canonicalId: 'openai/gpt-5.4',
     alias: 'GPT-5.4',
     input: ['text', 'image'],
+    contextWindow: 1_050_000,
+    maxTokens: 128_000,
   },
   {
     canonicalId: 'minimax/minimax-m2.5',
     alias: 'MiniMax M2.5',
     input: ['text'],
+    contextWindow: 196_608,
+    maxTokens: 196_608,
   },
   {
     canonicalId: 'minimax/minimax-m2.1',
     alias: 'MiniMax M2.1',
     input: ['text'],
+    contextWindow: 196_608,
+    maxTokens: 196_608,
   },
   {
     canonicalId: 'qwen/qwen3.5-plus-02-15',
     alias: 'Qwen 3.5 Plus',
     input: ['text', 'image'],
+    contextWindow: 1_000_000,
+    maxTokens: 65_536,
   },
   {
     canonicalId: 'z-ai/glm-5',
     alias: 'GLM-5',
     input: ['text'],
+    contextWindow: 202_752,
+    maxTokens: 131_072,
   },
 ] as const
 
@@ -81,11 +103,17 @@ export const EXTRA_GATEWAY_MODELS: Array<{
   name: string
   alias: string
   input: string[]
+  contextWindow: number
+  maxTokens: number
+  api?: string
 }> = PUBLIC_GATEWAY_MODELS.map((model) => ({
   id: model.canonicalId,
   name: model.canonicalId,
   alias: model.alias,
   input: [...model.input],
+  contextWindow: model.contextWindow,
+  maxTokens: model.maxTokens,
+  ...('api' in model && model.api ? {api: model.api} : {}),
 }))
 
 export function readOpenclawConfig(configPath: string): Record<string, unknown> {
@@ -100,6 +128,24 @@ export function writeOpenclawConfig(configPath: string, config: Record<string, u
   fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n')
 }
 
+function buildProviderModel(id: string): {
+  id: string
+  name: string
+  input: string[]
+  contextWindow?: number
+  maxTokens?: number
+  api?: string
+} {
+  const extra = EXTRA_GATEWAY_MODELS.find((model) => model.id === id)
+  return {
+    id,
+    name: id,
+    input: extra ? [...extra.input] : ['text', 'image'],
+    ...(extra ? {contextWindow: extra.contextWindow, maxTokens: extra.maxTokens} : {}),
+    ...(extra?.api ? {api: extra.api} : {}),
+  }
+}
+
 export function patchModelGateway(
   config: Record<string, unknown>,
   api: PluginApi,
@@ -123,7 +169,30 @@ export function patchModelGateway(
     // Append any missing extra models
     for (const m of EXTRA_GATEWAY_MODELS) {
       if (!existingIds.has(m.id)) {
-        existingModels.push({id: m.id, name: m.name, input: m.input} as any)
+        existingModels.push({
+          id: m.id,
+          name: m.name,
+          input: m.input,
+          contextWindow: m.contextWindow,
+          maxTokens: m.maxTokens,
+          ...(m.api ? {api: m.api} : {}),
+        } as any)
+        dirty = true
+      }
+    }
+
+    // Backfill contextWindow/maxTokens and api on existing models that lack them
+    const extraLookup = new Map(EXTRA_GATEWAY_MODELS.map((m) => [m.id, m]))
+    for (const m of existingModels) {
+      const extra = extraLookup.get(m.id)
+      if (!extra) continue
+      if ((m as any).contextWindow == null || (m as any).maxTokens == null) {
+        ;(m as any).contextWindow = extra.contextWindow
+        ;(m as any).maxTokens = extra.maxTokens
+        dirty = true
+      }
+      if (extra.api && (m as any).api !== extra.api) {
+        ;(m as any).api = extra.api
         dirty = true
       }
     }
@@ -167,7 +236,7 @@ export function patchModelGateway(
       defaults.models = existingAliases
       agents.defaults = defaults
       config.agents = agents
-      api.logger.info(`Model gateway updated: appended missing extra models/aliases.`)
+      api.logger.info('Model gateway updated.')
     } else {
       api.logger.info('Model gateway provider already configured.')
     }
@@ -199,16 +268,14 @@ export function patchModelGateway(
     return false
   }
 
-  const defaultModels = [{id: defaultModel, name: defaultModel, input: ['text', 'image']}]
+  const defaultModels = [buildProviderModel(defaultModel)]
 
   const defaultIds = new Set(defaultModels.map((m) => m.id))
   const models = [
     ...defaultModels,
-    ...EXTRA_GATEWAY_MODELS.filter((m) => !defaultIds.has(m.id)).map(({id, name, input}) => ({
-      id,
-      name,
-      input,
-    })),
+    ...EXTRA_GATEWAY_MODELS.filter((m) => !defaultIds.has(m.id)).map(({id}) =>
+      buildProviderModel(id),
+    ),
   ]
 
   if (!config.models) config.models = {}

package/package.json

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