@2en/clawly-plugins 1.16.0 → 1.16.1

package/index.ts

@@ -24,10 +24,8 @@
  * Hooks:
  * - tool_result_persist   — copies TTS audio to persistent outbound directory
  * - before_tool_call      — enforces delivery fields on cron.create
- * - gateway_start         — auto-approves device pairing for Clawly mobile clients (clientId: openclaw-ios)
  */
 
-import {registerAutoPair} from './auto-pair'
 import {registerCalendar} from './calendar'
 import {registerClawlyCronChannel} from './channel'
 import {registerCommands} from './command'
@@ -35,6 +33,7 @@ import {registerCronHook} from './cron-hook'
 import {registerEmail} from './email'
 import {registerGateway} from './gateway'
 import {getGatewayConfig} from './gateway-fetch'
+import {setupModelGateway} from './model-gateway-setup'
 import {registerOutboundHook, registerOutboundHttpRoute, registerOutboundMethods} from './outbound'
 import {registerTools} from './tools'
 
@@ -116,7 +115,7 @@ export default {
     registerClawlyCronChannel(api)
     registerCronHook(api)
     registerGateway(api)
-    registerAutoPair(api)
+    setupModelGateway(api)
 
     // Email & calendar (optional — requires skillGatewayBaseUrl + skillGatewayToken in config)
     const gw = getGatewayConfig(api)

package/model-gateway-setup.ts

@@ -0,0 +1,101 @@
+/**
+ * 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`
+ * already present in the config.
+ *
+ * This runs synchronously during plugin registration (before gateway_start).
+ * OpenClaw loads the config file once at startup, so writing before the
+ * gateway fully starts ensures the provider is active on first boot.
+ */
+
+import fs from 'node:fs'
+import path from 'node:path'
+
+import type {PluginApi} from './index'
+
+const PROVIDER_NAME = 'clawly-model-gateway'
+
+function resolveStateDir(api: PluginApi): string {
+  return api.runtime.state?.resolveStateDir?.(process.env) ?? process.env.OPENCLAW_STATE_DIR ?? ''
+}
+
+function readOpenclawConfig(configPath: string): Record<string, unknown> {
+  try {
+    return JSON.parse(fs.readFileSync(configPath, 'utf-8'))
+  } catch {
+    return {}
+  }
+}
+
+function writeOpenclawConfig(configPath: string, config: Record<string, unknown>) {
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n')
+}
+
+export function setupModelGateway(api: PluginApi): void {
+  const cfg = api.pluginConfig as Record<string, unknown> | undefined
+  const baseUrl =
+    typeof cfg?.modelGatewayBaseUrl === 'string' ? cfg.modelGatewayBaseUrl.replace(/\/$/, '') : ''
+  const token = typeof cfg?.modelGatewayToken === 'string' ? cfg.modelGatewayToken : ''
+
+  if (!baseUrl || !token) {
+    api.logger.info('Model gateway not configured (missing baseUrl or token), skipping.')
+    return
+  }
+
+  const stateDir = resolveStateDir(api)
+  if (!stateDir) {
+    api.logger.warn('Cannot resolve state dir — model gateway setup skipped.')
+    return
+  }
+
+  const configPath = path.join(stateDir, 'openclaw.json')
+  const config = readOpenclawConfig(configPath)
+
+  // Already configured — skip
+  if (config.models?.providers?.[PROVIDER_NAME]) {
+    api.logger.info('Model gateway provider already configured.')
+    return
+  }
+
+  // Derive model IDs from agents.defaults
+  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
+  }
+
+  const models =
+    defaultModel === imageModel || !imageModel
+      ? [{id: defaultModel, name: defaultModel, input: ['text', 'image']}]
+      : [
+          {id: defaultModel, name: defaultModel, input: ['text']},
+          {id: imageModel, name: imageModel, input: ['text', 'image']},
+        ]
+
+  if (!config.models) config.models = {}
+  if (!(config.models as any).providers) (config.models as any).providers = {}
+  ;(config.models as any).providers[PROVIDER_NAME] = {
+    baseUrl,
+    apiKey: token,
+    api: 'openai-completions',
+    models,
+  }
+
+  try {
+    writeOpenclawConfig(configPath, config)
+    api.logger.info(`Model gateway provider configured: ${baseUrl} with ${models.length} model(s).`)
+  } catch (err) {
+    api.logger.error(`Failed to setup model gateway: ${(err as Error).message}`)
+  }
+}

package/openclaw.plugin.json

@@ -47,7 +47,9 @@
       "defaultTimeoutMs": { "type": "number", "minimum": 1000 },
       "configPath": { "type": "string" },
       "skillGatewayBaseUrl": { "type": "string" },
-      "skillGatewayToken": { "type": "string" }
+      "skillGatewayToken": { "type": "string" },
+      "modelGatewayBaseUrl": { "type": "string" },
+      "modelGatewayToken": { "type": "string" }
     },
     "required": []
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2en/clawly-plugins",
-  "version": "1.16.0",
+  "version": "1.16.1",
   "module": "index.ts",
   "type": "module",
   "repository": {
@@ -17,13 +17,14 @@
     "lib",
     "tools",
     "index.ts",
-    "auto-pair.ts",
     "calendar.ts",
     "channel.ts",
     "cron-hook.ts",
     "email.ts",
     "gateway-fetch.ts",
     "outbound.ts",
+    "auto-pair.ts",
+    "model-gateway-setup.ts",
     "openclaw.plugin.json"
   ],
   "publishConfig": {

package/auto-pair.ts

@@ -1,72 +0,0 @@
-import type {PluginApi} from './index'
-
-const AUTO_APPROVE_CLIENT_IDS = new Set(['openclaw-ios'])
-const POLL_INTERVAL_MS = 3_000
-
-type PendingRequest = {
-  requestId: string
-  deviceId: string
-  clientId?: string
-  displayName?: string
-  platform?: string
-}
-
-type PairedDevice = {
-  deviceId: string
-  displayName?: string
-  platform?: string
-}
-
-type DevicePairingList = {
-  pending: PendingRequest[]
-  paired: PairedDevice[]
-}
-
-export function registerAutoPair(api: PluginApi) {
-  let timer: ReturnType<typeof setInterval> | null = null
-  let sdk: {
-    listDevicePairing: () => Promise<DevicePairingList>
-    approveDevicePairing: (
-      requestId: string,
-    ) => Promise<{requestId: string; device: PairedDevice} | null>
-  } | null = null
-
-  api.on('gateway_start', async () => {
-    try {
-      sdk = await import('openclaw/plugin-sdk')
-    } catch {
-      api.logger.warn('auto-pair: openclaw/plugin-sdk not available, skipping')
-      return
-    }
-
-    api.logger.info('auto-pair: started polling for pending pairing requests')
-
-    timer = setInterval(async () => {
-      if (!sdk) return
-      try {
-        const {pending} = await sdk.listDevicePairing()
-        for (const req of pending) {
-          if (req.clientId && AUTO_APPROVE_CLIENT_IDS.has(req.clientId)) {
-            const result = await sdk.approveDevicePairing(req.requestId)
-            if (result) {
-              api.logger.info(
-                `auto-pair: approved device=${result.device.deviceId} ` +
-                  `name=${result.device.displayName ?? 'unknown'} ` +
-                  `platform=${result.device.platform ?? 'unknown'}`,
-              )
-            }
-          }
-        }
-      } catch (err) {
-        api.logger.warn(`auto-pair: poll error: ${String(err)}`)
-      }
-    }, POLL_INTERVAL_MS)
-  })
-
-  api.on('gateway_stop', () => {
-    if (timer) {
-      clearInterval(timer)
-      timer = null
-    }
-  })
-}