ECHO_CLAW：上下文驱动的游戏智能体框架

interface ReflectionRule {
  trigger: {
    health?: { below?: number; above?: number }
    threat?: 'hostile' | 'neutral' | 'friendly'
    event?: string
  }
  action: () => Promise<void>
  priority: number
}
 
// 示例规则
const rules: ReflectionRule[] = [
  {
    trigger: { health: { below: 20 }, threat: 'hostile' },
    action: async () => await bot.pathfinder.flee(hostileEntity),
    priority: 100
  },
  {
    trigger: { event: 'on_fire' },
    action: async () => await bot.equip(waterBucket, 'hand'),
    priority: 90
  }
]

interface OrchestrationContext {
  // 游戏状态
  gameState: {
    position: Vec3
    health: number
    inventory: Item[]
    nearbyEntities: Entity[]
  }
 
  // 对话历史（压缩后）
  conversationHistory: Message[]
 
  // 当前任务
  currentTask: Task | null
 
  // 可用 Skills
  availableSkills: SkillDeclaration[]
}
 
async function orchestrate(context: OrchestrationContext): Promise<ExecutionPlan> {
  // LLM 根据上下文选择并编排 Skills
  const prompt = buildOrchestrationPrompt(context)
  const response = await llm.invoke(prompt)
 
  return parseExecutionPlan(response)
}

interface ExecutionEngine {
  // 执行计划
  execute(plan: ExecutionPlan): Promise<ExecutionResult>
 
  // 管理 Plugin 池
  plugins: Map<string, PluginInterface>
 
  // 操作队列
  actionQueue: Action[]
}
 
async function execute(plan: ExecutionPlan): Promise<ExecutionResult> {
  const results: ActionResult[] = []
 
  for (const step of plan.steps) {
    if (step.type === 'parallel') {
      // 并行执行
      const parallelResults = await Promise.all(
        step.actions.map(a => executeAction(a))
      )
      results.push(...parallelResults)
    } else {
      // 串行执行
      for (const action of step.actions) {
        results.push(await executeAction(action))
      }
    }
  }
 
  return { results, success: true }
}

interface SkillDeclaration {
  // 基础信息
  name: string
  description: string
  version: string
 
  // 接口定义
  input: JSONSchema
  output: JSONSchema
 
  // 触发条件
  triggers: {
    keywords?: string[]      // 触发关键词
    events?: string[]        // 触发事件类型
    conditions?: Condition[] // 触发条件
  }
 
  // 能力声明
  capabilities: {
    applicableScenes: string[]  // 适用场景
    outputType: string          // 输出类型
    collaborationWith: string[] // 可协作的其他skill
  }
 
  // 执行元信息
  execution: {
    costEstimate: number      // 执行成本预估 (ms)
    reliability: number        // 可靠性 0-1
    timeout: number           // 超时时间
  }
 
  // 依赖与冲突
  dependencies: {
    requires: string[]        // 前置依赖
    conflicts: string[]       // 冲突的skill
    mutex: string[]           // 互斥资源
  }
 
  // 失败恢复
  recovery: {
    retryable: boolean
    fallbackSkill?: string
    rollbackStrategy?: 'none' | 'partial' | 'full'
  }
 
  // 优先级
  priority: {
    base: number              // 基础优先级
    modifiers: {              // 动态调整因子
      urgency?: number
      relevance?: number
      userPreference?: number
    }
  }
}

const craftItemSkill: SkillDeclaration = {
  name: 'craft-item',
  description: '根据配方合成物品',
  version: '1.0.0',
 
  input: {
    type: 'object',
    properties: {
      itemName: { type: 'string' },
      quantity: { type: 'number', default: 1 }
    }
  },
 
  output: {
    type: 'object',
    properties: {
      success: { type: 'boolean' },
      crafted: { type: 'number' },
      remaining: { type: 'object' }
    }
  },
 
  triggers: {
    keywords: ['合成', '做', 'craft', 'make'],
    events: ['inventory_update']
  },
 
  capabilities: {
    applicableScenes: ['safe_area', 'has_crafting_table'],
    outputType: 'inventory_change',
    collaborationWith: ['gather-resources', 'store-items']
  },
 
  execution: {
    costEstimate: 500,
    reliability: 0.95,
    timeout: 5000
  },
 
  dependencies: {
    requires: [],  // 无前置依赖
    conflicts: ['in-combat'],
    mutex: ['inventory', 'crafting_table']
  },
 
  recovery: {
    retryable: true,
    fallbackSkill: 'craft-item-manual',
    rollbackStrategy: 'none'
  },
 
  priority: {
    base: 50,
    modifiers: {
      urgency: 0,
      relevance: 10
    }
  }
}

interface CompressionStrategy {
  // 触发时机
  triggers: {
    taskBoundary: boolean     // 任务边界默认触发
    thresholdRatio: number    // 达到窗口 80% 强制触发
    llmRequest: boolean       // LLM 主动触发
  }
 
  // 压缩规则
  rules: {
    keep: string[]            // 保留：关键决策、承诺、未完成任务
    compress: string[]        // 压缩：详细对话、中间过程
    discard: string[]         // 丢弃：临时状态
  }
}
 
function compress(history: Message[], strategy: CompressionStrategy): CompressedHistory {
  const kept: Message[] = []
  const summary: string[] = []
 
  for (const msg of history) {
    if (shouldKeep(msg, strategy.rules.keep)) {
      kept.push(msg)
    } else if (shouldCompress(msg, strategy.rules.compress)) {
      summary.push(summarize(msg))
    }
    // discard 的直接跳过
  }
 
  return {
    messages: kept,
    summary: summary.join('\n'),
    compressionRatio: (history.length - kept.length) / history.length
  }
}

async function recallFromMemory(query: string): Promise<string[]> {
  // 从记忆系统重新加载
  const memories = await memorySystem.query({
    type: 'episodic',
    keywords: extractKeywords(query),
    limit: 5
  })
 
  return memories.map(m => m.content)
}

const wikiMCP: MCPServer = {
  name: 'minecraft-wiki',
  resources: [
    {
      uri: 'wiki://blocks',
      name: '方块百科',
      mimeType: 'application/json'
    },
    {
      uri: 'wiki://mobs',
      name: '生物百科',
      mimeType: 'application/json'
    }
  ],
 
  tools: [
    {
      name: 'search_wiki',
      description: '搜索 Wiki 内容',
      parameters: {
        query: { type: 'string' }
      },
      execute: async (params) => {
        const results = await wikiSearch(params.query)
        return { content: results }
      }
    }
  ]
}