xiaoyuan-assistant 0.5.45

package/src/core/manager.js

@@ -0,0 +1,505 @@
+import { waitForAiElement, scanAiElements, waitForRender } from './dom.js'
+import { parseLocalCommands, looksLikeAnalysisLocal } from './localCommandParser.js'
+
+function isAnalysisRequest(message = '') {
+  return /(分析|研判|评估|判断|原因|趋势|风险|建议|情况|长势|预测|对比|比较|统计|为什么|是否异常|异常)/i.test(String(message))
+}
+
+function isCasualChatRequest(message = '') {
+  const text = String(message || '').trim()
+  if (!text || isAnalysisRequest(text)) return false
+  if (/(切换|打开|关闭|进入|跳转|返回|后退|前进|刷新|选择|设置|定位|放大|缩小|显示|隐藏|查看|获取|查询|读取|分析|研判|评估)/.test(text)) return false
+  return /(你是谁|你叫什么|介绍一下你自己|你能做什么|讲个笑话|讲一个笑话|说个笑话|谢谢|你好|嗨|在吗|你好吗|你觉得|是什么|什么意思|怎么用|帮我解释)/.test(text)
+}
+
+function isWeatherQuestion(message = '') {
+  const text = String(message || '')
+  return /(天气|气温|温度|降雨|下雨|湿度|风速|晴|阴|多云)/.test(text) && /(今天|当前|现在|明天|这几天|怎么样|如何|多少|预报|情况)/.test(text)
+}
+
+export class XiaoyuanManager {
+  constructor({ registry, speech, ai, options = {} }) {
+    this.registry = registry
+    this.speech = speech
+    this.ai = ai
+    this.options = {
+      commandTimeout: 0,
+      retryDelayMs: 3000,
+      retryCount: 2,
+      stepGapMs: 3000,
+      afterClickWait: 120,
+      totalExecutionTimeout: 0,
+      manifestCacheMs: 500,
+      ...options
+    }
+    this.manifestCache = null
+  }
+
+  setAI(ai) { this.ai = ai }
+
+  invalidateManifest() {
+    this.manifestCache = null
+  }
+
+  getManifest({ includeDataSources = false, force = false } = {}) {
+    const now = Date.now()
+    if (!force && this.manifestCache && now - this.manifestCache.at < this.options.manifestCacheMs && this.manifestCache.includeDataSources === includeDataSources) {
+      return this.manifestCache.data
+    }
+
+    const toolManifest = this.registry.getToolManifest()
+    const data = {
+      functions: toolManifest.functions,
+      dataSources: includeDataSources ? toolManifest.dataSources : [],
+      context: toolManifest.context,
+      domElements: scanAiElements(),
+      url: window.location.href,
+      path: window.location.pathname
+    }
+    this.manifestCache = { at: now, includeDataSources, data }
+    return data
+  }
+
+  async getData(name, params = {}) {
+    const source = this.registry.data.get(name)
+    if (!source) throw new Error(`未注册数据源：${name}`)
+    return await source.get(params)
+  }
+
+  async waitForDataWithRetry(name, params = {}) {
+    const attempts = Math.max(0, Number(this.options.retryCount ?? 2)) + 1
+    let lastValue
+
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+      try {
+        lastValue = await this.getData(name, params)
+        if (this.hasUsableData(lastValue)) {
+          return { found: true, data: lastValue, attempts: attempt + 1 }
+        }
+      } catch (error) {
+        lastValue = { __error: error?.message || `数据源 ${name} 获取失败` }
+      }
+
+      if (attempt < attempts - 1) {
+        await new Promise((resolve) => setTimeout(resolve, this.options.retryDelayMs))
+      }
+    }
+
+    return { found: false, data: lastValue, attempts }
+  }
+
+  hasUsableData(value) {
+    if (value == null) return false
+    if (value && typeof value === 'object' && value.__error) return false
+    if (Array.isArray(value)) return value.length > 0
+    if (typeof value === 'object') return Object.keys(value).length > 0
+    if (typeof value === 'string') return value.trim().length > 0
+    return true
+  }
+
+  async waitBetweenSteps(index) {
+    if (index <= 0) return
+    const delay = Math.max(0, Number(this.options.stepGapMs ?? 0))
+    if (delay > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delay))
+    }
+  }
+
+  async execute(command = {}) {
+    const name = command?.function || command?.name
+    const params = command?.params || {}
+    if (!name) return { success: false, message: '缺少 function' }
+
+    // 注册 Function：直接调用，不依赖 DOM。
+    const registered = this.registry.functions.get(name)
+    if (registered) {
+      try {
+        const result = await registered.handler({ params, context: this.registry.getContext() })
+        await waitForRender(1, this.options.afterClickWait)
+        this.invalidateManifest()
+        return { success: true, type: 'function', name, data: result }
+      } catch (error) {
+        return { success: false, type: 'function', name, message: error?.message || '执行失败' }
+      }
+    }
+
+    // DOM Function：先立即查找。多步骤之间由 stepGapMs 统一留出 5 秒缓冲；
+    // 当前步骤如果尚未渲染，则每隔 3 秒重试一次，最多重试 2 次。
+    let el = await waitForAiElement(name, params, { timeout: 0, interval: 50 })
+
+    if (!el) {
+      const retries = Math.max(0, Number(this.options.retryCount ?? 2))
+      for (let retry = 0; retry < retries; retry += 1) {
+        await new Promise((resolve) => setTimeout(resolve, this.options.retryDelayMs))
+        el = await waitForAiElement(name, params, { timeout: 0, interval: 50 })
+        if (el) break
+      }
+    }
+
+    if (!el) {
+      return { success: false, type: 'dom', name, message: '等待页面加载后仍未找到对应操作' }
+    }
+
+    return await this.clickAiElement(el, name)
+  }
+
+  async clickAiElement(el, name) {
+    try {
+      el.click()
+    } catch (error) {
+      return { success: false, type: 'dom', name, message: error?.message || '点击失败' }
+    }
+
+    await waitForRender(1, this.options.afterClickWait)
+    this.invalidateManifest()
+    return { success: true, type: 'dom', name }
+  }
+
+  normalizeStep(step) {
+    if (!step) return null
+    if (step.type === 'analysis') {
+      if (!Array.isArray(step.dataRequests) || !step.dataRequests.length) return null
+      return { type: 'analysis', dataRequests: step.dataRequests, instruction: step.instruction || '' }
+    }
+    if (step.function || step.name) return { type: 'action', function: step.function || step.name, params: step.params || {} }
+    return null
+  }
+
+  async plan(message, hooks = {}) {
+    if (typeof this.ai !== 'function') {
+      return { type: 'chat', reply: 'AI 模型接口尚未配置。', steps: [] }
+    }
+    const manifest = this.getManifest({ includeDataSources: isAnalysisRequest(message) })
+
+    const pushed = []
+    const onPlanStep = async (step) => {
+      const normalized = this.normalizeStep(step)
+      if (!normalized) return
+      pushed.push(normalized)
+      await hooks.onPlanStep?.({ step: normalized, index: pushed.length - 1 })
+    }
+
+    const result = await this.ai({
+      mode: 'plan',
+      message,
+      manifest,
+      getData: (name, params) => this.getData(name, params),
+      execute: (command) => this.execute(command),
+      onPlanStep
+    })
+
+    if (pushed.length) {
+      return { ...(result || {}), type: 'workflow', steps: pushed }
+    }
+    return result || { type: 'workflow', steps: [] }
+  }
+
+  async analyze(message, plan, dataResults, dataSourceManifest = []) {
+    if (typeof this.ai !== 'function') {
+      return { type: 'analysis', reply: 'AI 模型接口尚未配置。', analysis: '', steps: [] }
+    }
+    return this.ai({
+      mode: 'analysis',
+      message,
+      manifest: {
+        context: this.registry.getContext(),
+        dataSources: dataSourceManifest
+      },
+      plan,
+      dataResults,
+      getData: (name, params) => this.getData(name, params),
+      execute: (command) => this.execute(command)
+    })
+  }
+
+  async ask(message) { return this.run(message) }
+
+  describeCommand(command = {}) {
+    const name = command?.function || command?.name || ''
+    const params = command?.params || {}
+    const value = params?.value ?? params?.param ?? params?.target ?? params?.id ?? params?.name
+    const registered = this.registry.functions.get(name)
+    let description = registered?.description || ''
+
+    if (!description) {
+      const elements = this.getManifest({ includeDataSources: false }).domElements
+      const match = elements.find((item) => item.name === name && (value == null || item.params.some((v) => String(v) === String(value))))
+      description = match?.description || ''
+    }
+
+    description = String(description || '').trim()
+    const valueText = value !== undefined && value !== null && value !== '' ? String(value) : ''
+    if (description && valueText) return `${description}（${valueText}）`
+    if (description) return description
+    if (valueText) return `${name}（${valueText}）`
+    return name || '下一步操作'
+  }
+
+  async executeAnalysisStep(step, message, plan, hooks) {
+    const requests = Array.isArray(step.dataRequests) ? step.dataRequests.filter((item) => item?.name) : []
+    if (!requests.length) return { success: false, type: 'analysis', message: '没有找到可分析的数据源。' }
+    await hooks.onAnalysisStart?.({ step, requests })
+
+    // 多数据源并行获取，避免土壤/气象/作物等多个数据源串行等待，提升分析前置速度。
+    const fetchedResults = await Promise.all(
+      requests.map(async (request) => ({
+        name: request.name,
+        fetched: await this.waitForDataWithRetry(request.name, request.params || {})
+      }))
+    )
+    const dataResults = Object.fromEntries(
+      fetchedResults.map(({ name, fetched }) => [name, fetched.data])
+    )
+
+    const relevantSources = this.registry.getToolManifest().dataSources.filter((source) => requests.some((item) => item.name === source.name))
+    let analysisResult
+    try {
+      analysisResult = await this.analyze(message, plan, dataResults, relevantSources)
+    } catch (error) {
+      const messageText = error?.message || 'AI 分析失败'
+      try { await hooks.onAnalysisError?.({ step, requests, error, message: messageText, dataResults }) } catch (_) {}
+      return {
+        success: false,
+        type: 'analysis',
+        name: 'analysis',
+        message: messageText,
+        analysis: ''
+      }
+    }
+
+    try {
+      await hooks.onAnalysisDone?.({ step, requests, result: analysisResult, dataResults })
+    } catch (error) {
+      console.warn('[小园] 分析完成播报 hook 异常，继续后续流程：', error)
+    }
+
+    return {
+      success: true,
+      type: 'analysis',
+      name: 'analysis',
+      data: analysisResult,
+      analysis: analysisResult?.analysis || analysisResult?.reply || ''
+    }
+  }
+
+  async executeLocalSteps(steps, message, hooks, started) {
+    const execution = []
+    const queue = []
+    let index = 0
+
+    for (const step of steps) {
+      if (index > 0 && queue[index - 1]?.type !== 'analysis') {
+        await this.waitBetweenSteps(index)
+      }
+      queue.push(step)
+      const description = step.type === 'analysis' ? '分析当前数据' : this.describeCommand(step)
+      try { await hooks.onBeforeStep?.({ index, total: steps.length, command: step, description }) } catch (error) { console.warn('[小园] 步骤前置播报失败，继续执行当前步骤：', error) }
+
+      const item = step.type === 'analysis'
+        ? await this.executeAnalysisStep(step, message, { type: 'workflow', steps }, hooks)
+        : await this.execute(step)
+
+      const result = { ...item, index }
+      execution.push(result)
+
+      if (step.type !== 'analysis') {
+        try { await hooks.onStep?.({ index, total: steps.length, command: step, description, result }) } catch (error) { console.warn('[小园] 步骤完成 hook 失败：', error) }
+      }
+
+      if (result.success === false) {
+        return {
+          type: 'workflow',
+          reply: '',
+          steps: queue,
+          commands: queue.filter((item) => item.type !== 'analysis'),
+          dataRequests: queue.flatMap((item) => item.type === 'analysis' ? (item.dataRequests || []) : []),
+          execution,
+          summary: { total: execution.length, success: execution.filter((item) => item.success !== false).length, failed: 1, plannerDone: true },
+          local: true,
+          duration: Date.now() - started
+        }
+      }
+
+      index += 1
+    }
+
+    return {
+      type: 'workflow',
+      reply: '',
+      steps: queue,
+      commands: queue.filter((item) => item.type !== 'analysis'),
+      dataRequests: queue.flatMap((item) => item.type === 'analysis' ? (item.dataRequests || []) : []),
+      execution,
+      summary: { total: execution.length, success: execution.filter((item) => item.success !== false).length, failed: 0, plannerDone: true },
+      local: true,
+      duration: Date.now() - started
+    }
+  }
+
+  async runPlannerForUnresolved(unresolvedText, localManifest, message, queue, existingExecution, hooks, started) {
+    const execution = [...existingExecution]
+    let idx = execution.length
+    let planResult
+    try {
+      planResult = await this.ai({
+        mode: 'plan',
+        message: unresolvedText,
+        manifest: localManifest,
+        getData: (name, params) => this.getData(name, params),
+        execute: (command) => this.execute(command)
+      })
+    } catch (error) {
+      return {
+        type: 'workflow',
+        reply: '',
+        steps: queue,
+        execution,
+        local: true,
+        plannerError: error?.message || String(error),
+        duration: Date.now() - started
+      }
+    }
+
+    const steps = Array.isArray(planResult?.steps) ? planResult.steps : []
+    for (const rawStep of steps) {
+      const step = this.normalizeStep(rawStep)
+      if (!step) continue
+      if (idx > 0 && queue[idx - 1]?.type !== 'analysis') {
+        await this.waitBetweenSteps(idx)
+      }
+      queue.push(step)
+      const description = step.type === 'analysis' ? '分析当前数据' : this.describeCommand(step)
+      try { await hooks.onBeforeStep?.({ index: idx, total: null, command: step, description }) } catch (error) { console.warn('[小园] Planner 步骤前置播报失败，继续执行：', error) }
+
+      const item = step.type === 'analysis'
+        ? await this.executeAnalysisStep(step, message, { type: 'workflow', steps: queue }, hooks)
+        : await this.execute(step)
+
+      const result = { ...item, index: idx }
+      execution.push(result)
+      if (step.type !== 'analysis') {
+        await hooks.onStep?.({ index: idx, total: null, command: step, description, result })
+      }
+      idx += 1
+      if (result.success === false) break
+    }
+
+    return {
+      type: 'workflow',
+      reply: planResult?.reply || '',
+      steps: queue,
+      commands: queue.filter((step) => step.type !== 'analysis'),
+      dataRequests: queue.flatMap((step) => step.type === 'analysis' ? (step.dataRequests || []) : []),
+      execution,
+      summary: { total: execution.length, success: execution.filter((item) => item.success !== false).length, failed: execution.filter((item) => item.success === false).length, plannerDone: true },
+      local: false,
+      duration: Date.now() - started
+    }
+  }
+
+  async chatDirect(message, started = Date.now()) {
+    if (typeof this.ai !== 'function') {
+      return { type: 'chat', reply: 'AI 模型接口尚未配置。', steps: [], local: true, duration: Date.now() - started }
+    }
+
+    const chatResult = await this.ai({
+      mode: 'chat',
+      message,
+      manifest: { context: this.registry.getContext() }
+    })
+
+    return {
+      ...(chatResult || {}),
+      type: 'chat',
+      steps: [],
+      local: false,
+      duration: Date.now() - started
+    }
+  }
+
+  async run(message, hooks = {}) {
+    const started = Date.now()
+    const localManifest = this.getManifest({ includeDataSources: true, force: true })
+    const localPlan = parseLocalCommands(message, localManifest)
+
+    // 核心路由：先用本地 JS 判断是不是“大屏指令/数据分析”。
+    // 如果完全没有可执行指令，也没有可用的数据分析步骤，就直接交给 AI 聊天，
+    // 不再调用 Planner AI。这样“Vue3 生命周期是什么？”、“讲个笑话”等问题只会发起一次 Chat 请求。
+    if (!localPlan.steps.length && !localPlan.unresolved.length) {
+      return this.chatDirect(message, started)
+    }
+
+    // 如果本地已经识别出完整工作流，直接执行，完全不调用 Planner AI。
+    if (localPlan.ok && localPlan.steps.length) {
+      return await this.executeLocalSteps(localPlan.steps, message, hooks, started)
+    }
+
+    // 部分已识别：先执行本地明确的步骤。剩余无法识别的自然语言，
+    // 不再交给 Planner，而是在本地步骤完成后直接交给 Chat AI 回答。
+    if (localPlan.partial && localPlan.steps.length) {
+      const execution = []
+      const steps = [...localPlan.steps]
+      let index = 0
+
+      for (const step of steps) {
+        if (index > 0 && steps[index - 1]?.type !== 'analysis') {
+          await this.waitBetweenSteps(index)
+        }
+        const description = step.type === 'analysis' ? '分析当前数据' : this.describeCommand(step)
+        try { await hooks.onBeforeStep?.({ index, total: null, command: step, description }) } catch (error) { console.warn('[小园] 部分解析步骤前置播报失败，继续执行：', error) }
+
+        const item = step.type === 'analysis'
+          ? await this.executeAnalysisStep(step, message, { type: 'workflow', steps }, hooks)
+          : await this.execute(step)
+
+        const result = { ...item, index }
+        execution.push(result)
+
+        if (step.type !== 'analysis') {
+          hooks.onStep?.({ index, total: null, command: step, description, result })
+        }
+
+        if (result.success === false) {
+          return {
+            type: 'workflow',
+            reply: '',
+            steps,
+            execution,
+            local: true,
+            duration: Date.now() - started
+          }
+        }
+
+        index += 1
+      }
+
+      const unresolvedText = localPlan.unresolved.join('；').trim()
+      if (unresolvedText) {
+        // 未识别部分直接作为普通问题交给 AI，避免再次走 Planner。
+        const chatResult = await this.chatDirect(unresolvedText, started)
+        return {
+          ...chatResult,
+          type: 'workflow',
+          steps,
+          execution,
+          unresolvedReply: chatResult.reply || '',
+          reply: chatResult.reply || '',
+          local: false,
+          duration: Date.now() - started
+        }
+      }
+
+      return {
+        type: 'workflow',
+        reply: '',
+        steps,
+        execution,
+        local: true,
+        duration: Date.now() - started
+      }
+    }
+
+    // 纯自然语言问题：即使本地拆分不出 action，也不要尝试 Planner，直接 Chat AI。
+    return this.chatDirect(message, started)
+  }
+}

package/src/core/registry.js

@@ -0,0 +1,49 @@
+export class Registry {
+  constructor() {
+    this.functions = new Map()
+    this.data = new Map()
+    this.context = {}
+  }
+
+  registerFunction(definition) {
+    if (!definition?.name || typeof definition.handler !== 'function') {
+      throw new Error('registerFunction 需要 name 与 handler')
+    }
+    this.functions.set(definition.name, {
+      name: definition.name,
+      description: definition.description || '',
+      params: definition.params || {},
+      handler: definition.handler
+    })
+    return () => this.functions.delete(definition.name)
+  }
+
+  registerData(definition) {
+    if (!definition?.name || typeof definition.get !== 'function') {
+      throw new Error('registerData 需要 name 与 get')
+    }
+    this.data.set(definition.name, {
+      name: definition.name,
+      description: definition.description || '',
+      schema: definition.schema || {},
+      get: definition.get
+    })
+    return () => this.data.delete(definition.name)
+  }
+
+  setContext(context = {}) {
+    this.context = { ...this.context, ...context }
+  }
+
+  getContext() {
+    return { ...this.context }
+  }
+
+  getToolManifest() {
+    return {
+      functions: [...this.functions.values()].map(({ name, description, params }) => ({ name, description, params })),
+      dataSources: [...this.data.values()].map(({ name, description, schema }) => ({ name, description, schema })),
+      context: this.getContext()
+    }
+  }
+}

package/src/index.js

@@ -0,0 +1,100 @@
+import { inject } from 'vue'
+import XiaoyuanAssistant from './components/XiaoyuanAssistant.vue'
+import { Registry } from './core/registry.js'
+import { XiaoyuanManager } from './core/manager.js'
+import { SpeechService } from './voice/speech.js'
+import './styles/index.css'
+import { createSiliconFlowProvider } from './providers/siliconflow.js'
+import { registerBuiltinFunctions } from './core/builtins.js'
+import { HewoyiTTSProvider } from './voice/hewoyi.js'
+
+const KEY = Symbol('xiaoyuan')
+
+let singleton = null
+
+export function useXiaoyuan() {
+  if (!singleton) throw new Error('请先在 main.js 中 app.use(Xiaoyuan)')
+  return singleton
+}
+
+const Xiaoyuan = {
+  install(app, options = {}) {
+    if (singleton) return
+
+    const registry = new Registry()
+    registerBuiltinFunctions(registry)
+    const normalizedOptions = {
+      ...options,
+      enableTTS: options.enableTTS !== false,
+      enableWakeWord: options.enableWakeWord !== false,
+      wakeWord: options.wakeWord || '你好小园'
+    }
+
+    const ttsOptions = normalizedOptions.tts || {}
+    const ttsProvider = new HewoyiTTSProvider({
+      apiUrl: ttsOptions.apiUrl,
+      apiKey: ttsOptions.apiKey,
+      voice: ttsOptions.voice || 'zh-CN-XiaoyiNeural',
+      format: ttsOptions.format || 'mp3',
+      speed: ttsOptions.speed || '',
+      model: ttsOptions.model || '',
+      type: ttsOptions.type || 'speech',
+      requestTimeoutMs: ttsOptions.requestTimeoutMs ?? 7000
+    })
+
+    const speech = new SpeechService({
+      lang: normalizedOptions.lang || 'zh-CN',
+      rate: normalizedOptions.ttsRate ?? 1,
+      pitch: normalizedOptions.ttsPitch ?? 1,
+      volume: normalizedOptions.ttsVolume ?? 1,
+      ttsProvider: ttsOptions.provider === 'hewoyi' ? ttsProvider : null
+    })
+
+    // 默认直接使用内置 SiliconFlow Provider。
+    // 仍允许通过 aiProvider / ai 完全替换为自己的模型。
+    // 对外只暴露两个 AI 配置：模型与请求路径。
+    // temperature / maxTokens / thinking 等执行策略由 SDK 内部自动决定。
+    const siliconflowOptions = {
+      model: normalizedOptions.model,
+      apiUrl: normalizedOptions.aiUrl,
+      apiKey: normalizedOptions.apiKey
+    }
+
+    const defaultAIProvider = createSiliconFlowProvider(siliconflowOptions)
+
+    const manager = new XiaoyuanManager({
+      registry,
+      speech,
+      ai: normalizedOptions.aiProvider || normalizedOptions.ai || defaultAIProvider
+    })
+
+    const api = {
+      tts: ttsProvider,
+      registerFunction: (definition) => registry.registerFunction(definition),
+      registerData: (definition) => registry.registerData(definition),
+      setContext: (ctx) => registry.setContext(ctx),
+      getContext: () => registry.getContext(),
+      getManifest: () => manager.getManifest(),
+      getData: (name, params) => manager.getData(name, params),
+      execute: (command) => manager.execute(command),
+      ask: (message) => manager.run(message),
+      speech,
+      manager,
+      createSiliconFlowProvider
+    }
+
+    singleton = { api, registry, manager, speech, options: normalizedOptions }
+
+    app.config.globalProperties.$xiaoyuan = api
+    app.provide(KEY, singleton)
+    app.provide('xiaoyuan', singleton)
+    app.component('XiaoyuanAssistant', XiaoyuanAssistant)
+
+    if (typeof window !== 'undefined') {
+      window.$xiaoyuan = api
+    }
+  }
+}
+
+export { XiaoyuanAssistant, KEY, createSiliconFlowProvider, HewoyiTTSProvider }
+export default Xiaoyuan

package/src/prompts.js

@@ -0,0 +1,24 @@
+export const DEFAULT_SYSTEM_PROMPT = `你是“大屏助手小园”的快速意图路由器。
+你的唯一任务：先听懂用户人话，再判断属于“页面操作(action)”、“数据分析(analysis)”还是“普通聊天(chat)”。
+规则：
+1. 只能使用能力清单里真实存在的 Function 和 DataSource。
+2. 页面操作：把用户人话拆成按原顺序执行的独立 action step，并提取 params.value；不要分析。
+3. 多个动作必须拆开，不能漏掉后续动作。
+4. data-ai-description 用来理解 Function 语义；data-ai-param 用来定位具体目标。
+5. 数据分析：输出 analysis step，并选择真正需要的数据源。
+6. 只有分析任务才需要 DataSource；纯页面操作不需要读取数据。
+7. 不要输出内部解释，不要输出 Markdown，只输出 JSON/逐行 JSON step。
+示例：
+用户：“切换到集成监管，并切换到2023年”
+输出：
+{"type":"action","function":"handleMenuClick","params":{"value":"集成监管"}}
+{"type":"action","function":"changeYear","params":{"value":"2023"}}
+用户：“分析一下当前土壤数据”
+输出：
+{"type":"analysis","dataRequests":[{"name":"soilData","params":{}}],"instruction":"分析当前土壤数据"}`
+
+export function buildSystemPrompt(customPrompt = '') {
+  return customPrompt?.trim()
+    ? `${DEFAULT_SYSTEM_PROMPT}\n\n项目自定义规则：\n${customPrompt.trim()}`
+    : DEFAULT_SYSTEM_PROMPT;
+}