@2en/clawly-plugins 1.30.0-beta.9 → 1.31.0-beta.0

package/config-setup.ts

@@ -24,7 +24,6 @@ import {
   ENV_KEY_API_KEY,
   ENV_KEY_BASE,
   PROVIDER_NAME,
-  patchModelGateway,
   readOpenclawConfig,
   stripPathname,
   writeOpenclawConfig,
@@ -340,48 +339,82 @@ export function patchSession(config: OpenClawConfig): boolean {
   return dirty
 }
 
-const INCLUDE_PATH = './extensions/clawly-plugins/clawly-config-defaults.json5'
+const DEFAULTS_PATH = './extensions/clawly-plugins/clawly-config-defaults.json5'
+const LEGACY_INCLUDE_PATH = DEFAULTS_PATH
 
 /**
- * Ensures our defaults file is listed in the config's `$include` array.
- * Returns true if `$include` was modified.
+ * Remove legacy `$include` reference to our defaults file.
+ * Returns true if config was modified.
  */
-export function ensureInclude(config: OpenClawConfig & Record<string, unknown>): boolean {
+export function removeInclude(config: OpenClawConfig & Record<string, unknown>): boolean {
   const existing = config.$include
-  let includes: string[]
+  if (existing === undefined) return false
 
-  if (Array.isArray(existing)) {
-    includes = existing as string[]
-  } else if (typeof existing === 'string') {
-    includes = [existing]
-  } else {
-    includes = []
+  if (typeof existing === 'string') {
+    if (existing === LEGACY_INCLUDE_PATH) {
+      delete config.$include
+      return true
+    }
+    return false
   }
 
-  if (includes.includes(INCLUDE_PATH)) return false
+  if (Array.isArray(existing)) {
+    const includes = existing as string[]
+    const idx = includes.indexOf(LEGACY_INCLUDE_PATH)
+    if (idx === -1) return false
+    includes.splice(idx, 1)
+    if (includes.length === 0) {
+      delete config.$include
+    } else if (includes.length === 1) {
+      config.$include = includes[0]
+    }
+    return true
+  }
 
-  includes.push(INCLUDE_PATH)
-  config.$include = includes.length === 1 ? includes[0] : includes
-  return true
+  return false
 }
 
 /**
- * Restrict the $include defaults file to owner-only (0o600), matching
- * openclaw.json. npm/plugin-install creates files with 0o644 by default,
- * which would leave config readable by other local users.
+ * Deep-merge defaults into config. Config values take precedence;
+ * defaults only fill in missing keys. Arrays are not merged — config wins.
+ * Returns true if any key was added.
  */
-function hardenIncludePermissions(stateDir: string, api: PluginApi): void {
-  const includePath = path.join(stateDir, INCLUDE_PATH)
-  try {
-    const stat = fs.statSync(includePath)
-    const mode = stat.mode & 0o777
-    if (mode !== 0o600) {
-      fs.chmodSync(includePath, 0o600)
-      api.logger.info(`Hardened ${INCLUDE_PATH} permissions to 0600.`)
+export function deepMergeDefaults(
+  config: Record<string, unknown>,
+  defaults: Record<string, unknown>,
+): boolean {
+  let merged = false
+  for (const key of Object.keys(defaults)) {
+    const defaultVal = defaults[key]
+    const configVal = config[key]
+
+    if (configVal === undefined) {
+      config[key] = defaultVal
+      merged = true
+      continue
     }
-  } catch {
-    // File may not exist yet (first install before plugin copies files)
+
+    // Both are plain objects → recurse
+    if (
+      defaultVal !== null &&
+      typeof defaultVal === 'object' &&
+      !Array.isArray(defaultVal) &&
+      configVal !== null &&
+      typeof configVal === 'object' &&
+      !Array.isArray(configVal)
+    ) {
+      if (
+        deepMergeDefaults(
+          configVal as Record<string, unknown>,
+          defaultVal as Record<string, unknown>,
+        )
+      ) {
+        merged = true
+      }
+    }
+    // For arrays and primitives: config wins, do nothing
   }
+  return merged
 }
 
 const PLUGIN_ID = 'clawly-plugins'
@@ -450,89 +483,12 @@ function repairLegacyProvisionState(api: PluginApi, config: OpenClawConfig, stat
   return installRecordPatched
 }
 
-/**
- * Remove fields from config that are identical to the included defaults.
- * Since `$include` deep-merges with main config winning, residual values
- * from old JS set-if-missing code "shadow" the json5 defaults and prevent
- * future default updates from taking effect.
- *
- * Only prunes leaf values that exactly match.
- * Returns true if any field was deleted.
- */
-function stableStringify(v: unknown): string {
-  if (v !== null && typeof v === 'object' && !Array.isArray(v)) {
-    const obj = v as Record<string, unknown>
-    return `{${Object.keys(obj)
-      .sort()
-      .map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`)
-      .join(',')}}`
-  }
-  return JSON.stringify(v)
-}
-
-export function pruneIncludedDefaults(
-  config: Record<string, unknown>,
-  defaults: Record<string, unknown>,
-): boolean {
-  let pruned = false
-
-  function walk(defaultsNode: Record<string, unknown>, configNode: Record<string, unknown>): void {
-    for (const key of Object.keys(defaultsNode)) {
-      const defaultVal = defaultsNode[key]
-      const configVal = configNode[key]
-      if (configVal === undefined) continue
-
-      // Both are plain objects → recurse
-      if (
-        defaultVal !== null &&
-        typeof defaultVal === 'object' &&
-        !Array.isArray(defaultVal) &&
-        configVal !== null &&
-        typeof configVal === 'object' &&
-        !Array.isArray(configVal)
-      ) {
-        walk(defaultVal as Record<string, unknown>, configVal as Record<string, unknown>)
-        // Clean up empty parent objects left behind after pruning
-        if (Object.keys(configVal as Record<string, unknown>).length === 0) {
-          delete configNode[key]
-          pruned = true
-        }
-        continue
-      }
-
-      // Both are non-empty arrays → remove config elements that exist in defaults
-      if (Array.isArray(defaultVal) && defaultVal.length > 0 && Array.isArray(configVal)) {
-        const defaultSet = new Set(defaultVal.map((v) => stableStringify(v)))
-        const filtered = configVal.filter((v) => !defaultSet.has(stableStringify(v)))
-        if (filtered.length !== configVal.length) {
-          if (filtered.length === 0) {
-            delete configNode[key]
-          } else {
-            configNode[key] = filtered
-          }
-          pruned = true
-        }
-        continue
-      }
-
-      // Leaf comparison: use stableStringify for key-order-insensitive deep equality
-      if (stableStringify(configVal) === stableStringify(defaultVal)) {
-        delete configNode[key]
-        pruned = true
-      }
-    }
-  }
-
-  walk(defaults, config)
-  return pruned
-}
-
 /**
  * Load and parse clawly-config-defaults.json5 from the plugin install directory.
  * Uses the bundled `json5` package (declared in package.json).
  */
-function loadIncludedDefaults(stateDir: string): Record<string, unknown> | null {
-  const defaultsPath = path.join(stateDir, INCLUDE_PATH)
+function loadDefaults(stateDir: string): Record<string, unknown> | null {
+  const defaultsPath = path.join(stateDir, DEFAULTS_PATH)
   try {
     const raw = fs.readFileSync(defaultsPath, 'utf-8')
     return JSON5.parse(raw) as Record<string, unknown>
@@ -565,13 +521,12 @@ function reconcileRuntimeConfig(
   dirty = patchGateway(config) || dirty
   dirty = patchBrowser(config) || dirty
   dirty = patchSession(config) || dirty
-  dirty = patchModelGateway(config, api) || dirty
 
-  const defaults = loadIncludedDefaults(stateDir)
+  const defaults = loadDefaults(stateDir)
   if (defaults) {
-    dirty = pruneIncludedDefaults(config, defaults) || dirty
+    dirty = deepMergeDefaults(config, defaults) || dirty
   } else {
-    api.logger.warn('Config setup: failed to load included defaults, skipping dedup.')
+    api.logger.warn('Config setup: failed to load defaults json5, skipping merge.')
   }
 
   return dirty
@@ -588,22 +543,15 @@ export function setupConfig(api: PluginApi): void {
     return
   }
 
-  // OpenClaw exposes three config layers:
-  //   parsed   — raw JSON from openclaw.json (no $include, no env expansion)
-  //   resolved — parsed + $include deep-merge + ${ENV} interpolation
-  //   runtime  — resolved + SecretRef resolution, cached in-memory snapshot
-  //
-  // We need parsed: patchers mutate raw fields and write back via
-  // writeConfigFile, which diffs against the runtime snapshot and projects
-  // changes onto the source file. Using resolved/runtime would inline
-  // $include defaults into openclaw.json, defeating the json5 migration.
+  // Read the raw parsed config from openclaw.json (no env expansion).
+  // Patchers mutate fields in place; defaults from json5 are deep-merged
+  // to fill missing keys. The result is written back as the full config.
   const configPath = path.join(stateDir, 'openclaw.json')
   const config = readOpenclawConfig(configPath)
   const pc = toPCMerged(api, config)
 
   let dirty = false
-  dirty = ensureInclude(config) || dirty
-  hardenIncludePermissions(stateDir, api)
+  dirty = removeInclude(config) || dirty
   dirty = repairLegacyProvisionState(api, config, stateDir) || dirty
   dirty = reconcileRuntimeConfig(api, config, pc, stateDir) || dirty
 
@@ -611,12 +559,14 @@ export function setupConfig(api: PluginApi): void {
     try {
       writeOpenclawConfig(configPath, config)
       api.logger.info('Config setup: patched openclaw.json.')
-      // NOTE: We intentionally do NOT call api.runtime.config.writeConfigFile()
-      // here. The raw config (from readOpenclawConfig / JSON.parse) lacks
-      // $include-resolved fields (e.g. models array) and always fails
-      // validation. The raw disk write above is sufficient — the first
-      // successful writeConfigFile call from an RPC (like setTimezone)
-      // will refresh the runtime snapshot.
+      // Refresh the gateway's in-memory runtime config snapshot.
+      // The sync write above updates the file on disk, but the gateway
+      // caches config via runtimeConfigSnapshot (set during startup by
+      // the secrets system). Without this refresh, loadConfig() keeps
+      // returning the stale pre-patch config until the next restart.
+      void api.runtime.config.writeConfigFile(config).catch((err) => {
+        api.logger.warn(`Config setup: runtime snapshot refresh failed: ${(err as Error).message}`)
+      })
     } catch (err) {
       api.logger.error(`Config setup failed: ${(err as Error).message}`)
     }

package/gateway/config-model.ts

@@ -15,7 +15,6 @@
 
 import type {PluginApi} from '../types'
 import type {OpenClawConfig} from '../types/openclaw'
-import {backfillDiskConfig} from '../model-gateway-setup'
 
 export function registerConfigModel(api: PluginApi) {
   api.registerGatewayMethod('clawly.config.setModel', async ({params, respond}) => {
@@ -54,13 +53,8 @@ export function registerConfigModel(api: PluginApi) {
     agents.defaults = defaults
     config.agents = agents
 
-    // Backfill fields written by setupConfig (which writes directly to disk)
-    // so writeConfigFile's merge-patch doesn't revert them.
-    const stateDir = api.runtime.state.resolveStateDir()
-    const configToWrite = stateDir ? backfillDiskConfig(stateDir, config) : config
-
     try {
-      await api.runtime.config.writeConfigFile(configToWrite)
+      await api.runtime.config.writeConfigFile(config)
       api.logger.info(`config-model: set model.primary to ${model}`)
       respond(true, {changed: true, model})
     } catch (err) {

package/gateway/config-timezone.ts

@@ -11,7 +11,6 @@
 
 import type {PluginApi} from '../types'
 import type {OpenClawConfig} from '../types/openclaw'
-import {backfillDiskConfig} from '../model-gateway-setup'
 
 export function registerConfigTimezone(api: PluginApi) {
   api.registerGatewayMethod('clawly.config.setTimezone', async ({params, respond}) => {
@@ -47,13 +46,8 @@ export function registerConfigTimezone(api: PluginApi) {
     agents.defaults = defaults
     config.agents = agents
 
-    // Backfill fields written by setupConfig (which writes directly to disk)
-    // so writeConfigFile's merge-patch doesn't revert them.
-    const stateDir = api.runtime.state.resolveStateDir()
-    const configToWrite = stateDir ? backfillDiskConfig(stateDir, config) : config
-
     try {
-      await api.runtime.config.writeConfigFile(configToWrite)
+      await api.runtime.config.writeConfigFile(config)
       api.logger.info(`config-timezone: set userTimezone to ${timezone}`)
       respond(true, {changed: true, timezone})
     } catch (err) {

package/model-gateway-setup.ts

@@ -10,7 +10,6 @@
  */
 
 import fs from 'node:fs'
-import path from 'node:path'
 
 import type {PluginApi} from './index'
 import type {OpenClawConfig} from './types/openclaw'
@@ -68,48 +67,3 @@ export function patchModelGateway(config: OpenClawConfig, _api: PluginApi): bool
 
   return dirty
 }
-
-// ---------------------------------------------------------------------------
-// backfillDiskConfig — merge setupConfig's disk writes into a loadConfig() result
-// ---------------------------------------------------------------------------
-
-function isPlainObject(v: unknown): v is Record<string, unknown> {
-  return v !== null && typeof v === 'object' && !Array.isArray(v)
-}
-
-/**
- * Deep-merge `source` into `target`, where source wins for any key it has.
- * Arrays and primitives from source overwrite target.
- * Plain objects recurse.
- */
-function deepMerge(target: Record<string, unknown>, source: Record<string, unknown>): void {
-  for (const key of Object.keys(source)) {
-    if (key === '$include') continue // meta-directive, not a resolved config field
-    const sv = source[key]
-    const tv = target[key]
-    if (isPlainObject(sv) && isPlainObject(tv)) {
-      deepMerge(tv, sv)
-    } else {
-      target[key] = sv
-    }
-  }
-}
-
-/**
- * Read the raw disk config (openclaw.json) and deep-merge its fields into a
- * runtime config snapshot (from `loadConfig()`). This ensures that fields
- * written by `setupConfig` (which writes directly to disk) are present in the
- * config object before it's passed to `writeConfigFile`.
- *
- * Without this, `writeConfigFile`'s inner merge-patch sees the stale runtime
- * snapshot (missing setupConfig's changes) and reverts them on disk.
- */
-export function backfillDiskConfig(stateDir: string, config: OpenClawConfig): OpenClawConfig {
-  const configPath = path.join(stateDir, 'openclaw.json')
-  const diskConfig = readOpenclawConfig(configPath)
-  // Start from disk (setupConfig's fields) then overlay config (RPC handler's
-  // changes) so the caller's modifications win over stale disk values.
-  const merged = {...diskConfig} as Record<string, unknown>
-  deepMerge(merged, config as Record<string, unknown>)
-  return merged as OpenClawConfig
-}

package/package.json

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

package/tools/clawly-search.test.ts

@@ -1,6 +1,11 @@
 import {afterAll, beforeEach, describe, expect, test} from 'bun:test'
 import type {PluginApi} from '../types'
-import {registerDeepSearchTool, registerGrokSearchTool, registerSearchTool} from './clawly-search'
+import {
+  registerDeepSearchTool,
+  registerGrokSearchTool,
+  registerKimiSearchTool,
+  registerSearchTool,
+} from './clawly-search'
 
 // ── Helpers ──────────────────────────────────────────────────────
 
@@ -267,3 +272,45 @@ describe('clawly_grok_search', () => {
     expect(res.error).toContain('Grok API error 429')
   })
 })
+
+// ── clawly_kimi_search ──────────────────────────────────────────
+
+describe('clawly_kimi_search', () => {
+  test('uses Kimi gateway endpoint with web_search tool', async () => {
+    mockResponse.body = {
+      choices: [{message: {content: 'Kimi answer with [source](https://example.com/page)'}}],
+    }
+    const {execute} = createMockApi(registerKimiSearchTool)
+    const res = parseResult(await execute('tc-1', {query: 'Chinese news'}))
+
+    expect(fetchCalls).toHaveLength(1)
+    const call = fetchCalls[0]
+    expect(call.url).toBe('https://gw.example.com/v1/kimi/v1/chat/completions')
+    expect(call.body?.model).toBe('kimi-k2-turbo-preview')
+    expect(call.body?.stream).toBe(false)
+    expect(call.body?.messages).toEqual([{role: 'user', content: 'Chinese news'}])
+    expect(call.body?.tools).toEqual([{type: 'builtin_function', function: {name: '$web_search'}}])
+
+    expect(res.answer).toBe('Kimi answer with [source](https://example.com/page)')
+    expect(res.citations).toEqual(['https://example.com/page'])
+    expect(res.provider).toBe('kimi')
+  })
+
+  test('returns empty citations when response has no inline links', async () => {
+    mockResponse.body = {choices: [{message: {content: 'Plain answer'}}]}
+    const {execute} = createMockApi(registerKimiSearchTool)
+    const res = parseResult(await execute('tc-1', {query: 'test'}))
+
+    expect(res.answer).toBe('Plain answer')
+    expect(res.citations).toEqual([])
+    expect(res.provider).toBe('kimi')
+  })
+
+  test('returns error on Kimi API failure', async () => {
+    mockResponse = {ok: false, status: 429, body: {error: 'rate limited'}}
+    const {execute} = createMockApi(registerKimiSearchTool)
+    const res = parseResult(await execute('tc-1', {query: 'test'}))
+
+    expect(res.error).toContain('Kimi API error 429')
+  })
+})

package/tools/clawly-search.ts

@@ -1,9 +1,12 @@
 import {
   buildGrokBody,
   buildGrokUrl,
+  buildKimiBody,
+  buildKimiUrl,
   buildPerplexityUrl,
   createSearchToolRegistrar,
   parseGrokResponse,
+  parseKimiResponse,
 } from './create-search-tool'
 
 export const registerSearchTool = createSearchToolRegistrar({
@@ -40,3 +43,14 @@ export const registerGrokSearchTool = createSearchToolRegistrar({
   buildBody: buildGrokBody,
   parseResponse: parseGrokResponse,
 })
+
+export const registerKimiSearchTool = createSearchToolRegistrar({
+  toolName: 'clawly_kimi_search',
+  description: 'Search the web using Kimi. Good for Chinese-language queries and content.',
+  model: 'kimi-k2-turbo-preview',
+  buildUrl: buildKimiUrl,
+  timeoutMs: 30_000,
+  provider: 'kimi',
+  buildBody: buildKimiBody,
+  parseResponse: parseKimiResponse,
+})

package/tools/create-search-tool.ts

@@ -1,7 +1,7 @@
 import type {PluginApi} from '../types'
 import {resolveGatewayCredentials} from '../resolve-gateway-credentials'
 
-export type SearchProvider = 'grok' | 'perplexity'
+export type SearchProvider = 'grok' | 'kimi' | 'perplexity'
 
 export interface SearchResult {
   query: string
@@ -44,6 +44,19 @@ export function buildGrokBody(model: string, query: string): Record<string, unkn
   return {model, input: query, tools: [{type: 'web_search'}]}
 }
 
+export function buildKimiUrl(baseUrl: string): string {
+  return `${baseUrl.replace(/\/$/, '')}/kimi/v1/chat/completions`
+}
+
+export function buildKimiBody(model: string, query: string): Record<string, unknown> {
+  return {
+    model,
+    stream: false,
+    messages: [{role: 'user', content: query}],
+    tools: [{type: 'builtin_function', function: {name: '$web_search'}}],
+  }
+}
+
 function extractCitations(text: string): string[] {
   const urls: string[] = []
   const seen = new Set<string>()
@@ -57,6 +70,12 @@ function extractCitations(text: string): string[] {
   return urls
 }
 
+export function parseKimiResponse(data: unknown): {answer: string; citations: string[]} {
+  const d = data as {choices?: {message?: {content?: string}}[]}
+  const answerText = d.choices?.[0]?.message?.content ?? ''
+  return {answer: answerText, citations: extractCitations(answerText)}
+}
+
 export function parseGrokResponse(data: unknown): {answer: string; citations: string[]} {
   const typed = data as {
     output?: Array<{type: string; content?: Array<{type: string; text?: string}>}>
@@ -113,9 +132,13 @@ export function createSearchToolRegistrar(config: SearchToolConfig) {
 
           if (!res.ok) {
             const body = await res.text().catch(() => '')
-            throw new Error(
-              `${config.provider === 'grok' ? 'Grok' : 'Perplexity'} API error ${res.status}: ${body.slice(0, 200)}`,
-            )
+            const providerLabel =
+              config.provider === 'grok'
+                ? 'Grok'
+                : config.provider === 'kimi'
+                  ? 'Kimi'
+                  : 'Perplexity'
+            throw new Error(`${providerLabel} API error ${res.status}: ${body.slice(0, 200)}`)
           }
 
           const data = await res.json()

package/tools/index.ts

@@ -2,7 +2,12 @@ import type {PluginApi} from '../types'
 import {registerCalendarTools} from './clawly-calendar'
 import {registerIsUserOnlineTool} from './clawly-is-user-online'
 import {registerMsgBreakTool} from './clawly-msg-break'
-import {registerDeepSearchTool, registerGrokSearchTool, registerSearchTool} from './clawly-search'
+import {
+  registerDeepSearchTool,
+  registerGrokSearchTool,
+  registerKimiSearchTool,
+  registerSearchTool,
+} from './clawly-search'
 import {registerSendAppPushTool} from './clawly-send-app-push'
 import {registerSendFileTool} from './clawly-send-file'
 import {registerSendMessageTool} from './clawly-send-message'
@@ -14,6 +19,7 @@ export function registerTools(api: PluginApi) {
   registerSearchTool(api)
   registerDeepSearchTool(api)
   registerGrokSearchTool(api)
+  registerKimiSearchTool(api)
   registerSendAppPushTool(api)
   registerSendFileTool(api)
   registerSendMessageTool(api)