@icyfenix-dmla/cli 2026.6.6-1021 → 2026.6.11-1945

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@icyfenix-dmla/cli",
-  "version": "2026.6.6-1021",
+  "version": "2026.6.11-1945",
   "description": "DMLA 沙箱服务命令行工具",
   "type": "module",
   "main": "src/index.js",

package/shared/__init__.py

@@ -6,4 +6,4 @@
 #   from shared.cnn import AlexNet
 #   from shared.linear import LogisticRegression
 
-__all__ = ['bayesian', 'cnn', 'gan', 'linear', 'llm', 'neural', 'sequence_models', 'svm', 'tree', 'unsupervised']
+__all__ = ['agent_systems', 'bayesian', 'cnn', 'gan', 'linear', 'llm', 'neural', 'sequence_models', 'svm', 'tree', 'unsupervised']

package/shared/agent_systems/__init__.py

@@ -0,0 +1,12 @@
+# AGENT_SYSTEMS 模块
+from .agent_core import AgentCore
+from .agent_message import AgentMessage
+from .circuit_breaker import CircuitBreaker
+from .memory_manager import MemoryManager
+from .message_bus import MessageBus
+from .orchestrator import Orchestrator
+from .specialized_agent import SpecializedAgent
+from .tool_registry import ToolRegistry
+from .workflow_engine import WorkflowEngine
+
+__all__ = ['AgentCore', 'AgentMessage', 'CircuitBreaker', 'MemoryManager', 'MessageBus', 'Orchestrator', 'SpecializedAgent', 'ToolRegistry', 'WorkflowEngine']

package/shared/agent_systems/agent_core.py

@@ -0,0 +1,41 @@
+# AgentCore 定义
+# 从文档自动提取生成
+
+import json
+
+class AgentCore:
+    """基于 ReAct 模式的 Agent 核心"""
+    
+    def __init__(self, tool_registry, memory_manager, max_iterations=10):
+        self.tools = tool_registry
+        self.memory = memory_manager
+        self.max_iterations = max_iterations
+    
+    def run(self, goal):
+        """执行 Agent 主循环"""
+        self.memory.add("user", goal)
+        
+        for i in range(self.max_iterations):
+            # 构建提示词：系统指令 + 记忆上下文 + 工具描述
+            prompt = self._build_prompt()
+            
+            # 调用 LLM 生成思考和行动
+            response = self._call_llm(prompt)
+            
+            # 解析响应：提取思考、行动和最终答案
+            thought, action, final_answer = self._parse_response(response)
+            
+            if thought:
+                self.memory.add("thought", thought)
+            
+            if final_answer:
+                return final_answer
+            
+            if action:
+                # 执行工具调用
+                observation = self.tools.execute(
+                    action["tool"], **action.get("parameters", {})
+                )
+                self.memory.add("observation", json.dumps(observation, ensure_ascii=False))
+        
+        return "达到最大迭代次数，任务未完成"

package/shared/agent_systems/agent_message.py

@@ -0,0 +1,53 @@
+# AgentMessage 定义
+# 从文档自动提取生成
+
+import json
+import time
+import uuid
+from enum import Enum
+
+class AgentMessage:
+    """Agent 间通信的结构化消息"""
+    
+    def __init__(self, msg_type, sender, receiver, payload, 
+                 correlation_id=None, priority=0, ttl=None):
+        self.id = str(uuid.uuid4())
+        self.type = MessageType(msg_type) if isinstance(msg_type, str) else msg_type
+        self.sender = sender
+        self.receiver = receiver
+        self.payload = payload
+        self.correlation_id = correlation_id or self.id
+        self.priority = priority
+        self.ttl = ttl
+        self.timestamp = time.time()
+    
+    def to_dict(self):
+        return {
+            "id": self.id,
+            "type": self.type.value,
+            "sender": self.sender,
+            "receiver": self.receiver,
+            "payload": self.payload,
+            "correlation_id": self.correlation_id,
+            "priority": self.priority,
+            "timestamp": self.timestamp
+        }
+    
+    @classmethod
+    def from_dict(cls, data):
+        msg = cls(
+            msg_type=data["type"],
+            sender=data["sender"],
+            receiver=data["receiver"],
+            payload=data["payload"],
+            correlation_id=data.get("correlation_id"),
+            priority=data.get("priority", 0)
+        )
+        msg.id = data["id"]
+        msg.timestamp = data.get("timestamp", time.time())
+        return msg
+    
+    def is_expired(self):
+        if self.ttl is None:
+            return False
+        return time.time() - self.timestamp > self.ttl

package/shared/agent_systems/circuit_breaker.py

@@ -0,0 +1,53 @@
+# CircuitBreaker 定义
+# 从文档自动提取生成
+
+class CircuitBreaker:
+    """断路器：在 Agent 持续失败时暂停向其分配任务"""
+    
+    CLOSED = "closed"      # 正常工作
+    OPEN = "open"          # 暂停分配
+    HALF_OPEN = "half_open"  # 试探性恢复
+    
+    def __init__(self, failure_threshold=3, recovery_timeout=60, half_open_max=1):
+        self.failure_threshold = failure_threshold
+        self.recovery_timeout = recovery_timeout
+        self.half_open_max = half_open_max
+        self._states = {}  # agent_id -> state
+        self._failure_counts = {}
+        self._last_failure_time = {}
+        self._half_open_counts = {}
+    
+    def can_execute(self, agent_id):
+        """检查是否可以向该 Agent 分配任务"""
+        state = self._states.get(agent_id, self.CLOSED)
+        
+        if state == self.CLOSED:
+            return True
+        
+        if state == self.OPEN:
+            # 检查是否到达恢复时间
+            elapsed = time.time() - self._last_failure_time.get(agent_id, 0)
+            if elapsed >= self.recovery_timeout:
+                self._states[agent_id] = self.HALF_OPEN
+                self._half_open_counts[agent_id] = 0
+                return True
+            return False
+        
+        if state == self.HALF_OPEN:
+            # 限制试探性请求的数量
+            return self._half_open_counts.get(agent_id, 0) < self.half_open_max
+        
+        return False
+    
+    def record_success(self, agent_id):
+        """记录成功执行"""
+        self._states[agent_id] = self.CLOSED
+        self._failure_counts[agent_id] = 0
+    
+    def record_failure(self, agent_id):
+        """记录执行失败"""
+        self._failure_counts[agent_id] = self._failure_counts.get(agent_id, 0) + 1
+        self._last_failure_time[agent_id] = time.time()
+        
+        if self._failure_counts[agent_id] >= self.failure_threshold:
+            self._states[agent_id] = self.OPEN

package/shared/agent_systems/memory_manager.py

@@ -0,0 +1,37 @@
+# MemoryManager 定义
+# 从文档自动提取生成
+
+class MemoryManager:
+    """简单的记忆管理器，维护对话历史和关键信息"""
+    
+    def __init__(self, max_history=20):
+        self.history = []
+        self.key_facts = []
+        self.max_history = max_history
+    
+    def add(self, role, content):
+        """添加一条记录到对话历史"""
+        self.history.append({"role": role, "content": content})
+        
+        # 超出限制时压缩早期历史
+        if len(self.history) > self.max_history:
+            self._compress_history()
+    
+    def get_context(self):
+        """获取当前上下文（格式化的对话历史）"""
+        return self.history.copy()
+    
+    def extract_fact(self, fact):
+        """提取关键事实到长期记忆"""
+        self.key_facts.append(fact)
+    
+    def _compress_history(self):
+        """压缩早期历史：保留最近记录，将早期记录摘要"""
+        # 保留最近 2/3 的记录，将前 1/3 压缩为摘要
+        compress_count = len(self.history) // 3
+        old_records = self.history[:compress_count]
+        self.history = self.history[compress_count:]
+        
+        # 生成摘要（简化实现：提取关键信息）
+        summary = f"[历史摘要: 共 {len(old_records)} 轮对话已压缩]"
+        self.history.insert(0, {"role": "system", "content": summary})

package/shared/agent_systems/message_bus.py

@@ -0,0 +1,41 @@
+# MessageBus 定义
+# 从文档自动提取生成
+
+import heapq
+from collections import defaultdict
+
+class MessageBus:
+    """Agent 间的消息总线，支持发布-订阅和点对点通信"""
+    
+    def __init__(self):
+        self._subscribers = defaultdict(list)  # topic -> [agent_ids]
+        self._queues = defaultdict(list)        # agent_id -> [(priority, message)]
+        self._ack_pending = {}                   # msg_id -> (sender, callback)
+    
+    def subscribe(self, agent_id, topic):
+        """订阅特定主题的消息"""
+        if agent_id not in self._subscribers[topic]:
+            self._subscribers[topic].append(agent_id)
+    
+    def publish(self, message):
+        """发布消息到主题，所有订阅者都会收到"""
+        topic = message.type.value
+        for agent_id in self._subscribers.get(topic, []):
+            self._enqueue(agent_id, message)
+    
+    def send(self, message):
+        """点对点发送消息给指定 Agent"""
+        self._enqueue(message.receiver, message)
+    
+    def receive(self, agent_id):
+        """接收 Agent 的下一条消息（按优先级排序）"""
+        if not self._queues[agent_id]:
+            return None
+        _, message = heapq.heappop(self._queues[agent_id])
+        if message.is_expired():
+            return self.receive(agent_id)  # 跳过过期消息
+        return message
+    
+    def _enqueue(self, agent_id, message):
+        """将消息加入 Agent 的消息队列（按优先级排序）"""
+        heapq.heappush(self._queues[agent_id], (-message.priority, message))

package/shared/agent_systems/orchestrator.py

@@ -0,0 +1,47 @@
+# Orchestrator 定义
+# 从文档自动提取生成
+
+class Orchestrator:
+    """集中式编排器，负责任务分解、分配和结果整合"""
+    
+    def __init__(self, message_bus, agents):
+        self.bus = message_bus
+        self.agents = {agent.agent_id: agent for agent in agents}
+        self.task_results = {}
+        self.workflow = None
+    
+    def decompose_task(self, goal):
+        """将高层目标分解为子任务列表"""
+        # 调用 LLM 进行任务分解
+        # 简化实现：基于规则的分解
+        subtasks = self._rule_based_decompose(goal)
+        return subtasks
+    
+    def assign_task(self, task, agent_id):
+        """将子任务分配给指定 Agent"""
+        msg = AgentMessage(
+            msg_type=MessageType.TASK_ASSIGN,
+            sender="orchestrator",
+            receiver=agent_id,
+            payload=task
+        )
+        self.bus.send(msg)
+    
+    def collect_results(self, task_ids, timeout=60):
+        """收集指定任务的执行结果"""
+        results = {}
+        deadline = time.time() + timeout
+        
+        while time.time() < deadline and len(results) < len(task_ids):
+            msg = self.bus.receive("orchestrator")
+            if msg and msg.type == MessageType.RESULT_SUBMIT:
+                results[msg.correlation_id] = msg.payload
+            elif msg and msg.type == MessageType.ERROR_REPORT:
+                results[msg.correlation_id] = {"status": "error", "error": msg.payload}
+        
+        return results
+    
+    def _rule_based_decompose(self, goal):
+        """基于规则的任务分解（简化实现）"""
+        # 实际实现中应调用 LLM 进行智能分解
+        return [{"id": "task_1", "description": goal, "type": "general"}]

package/shared/agent_systems/specialized_agent.py

@@ -0,0 +1,21 @@
+# SpecializedAgent 定义
+# 从文档自动提取生成
+
+class SpecializedAgent:
+    """专业化 Agent 基类，每个子类实现特定领域的逻辑"""
+    
+    def __init__(self, agent_id, role, description, tools, message_bus):
+        self.agent_id = agent_id
+        self.role = role
+        self.description = description
+        self.tools = tools
+        self.bus = message_bus
+        self.status = "idle"
+        self.current_task = None
+    
+    def get_system_prompt(self):
+        """生成 Agent 的系统提示词"""
+        tool_descriptions = "\n".join([
+            f"- {t['name']}: {t['description']}" for t in self.tools.get_schemas()
+        ])
+        return f"""你是一个{self.role}。

package/shared/agent_systems/tool_registry.py

@@ -0,0 +1,51 @@
+# ToolRegistry 定义
+# 从文档自动提取生成
+
+import json
+import signal
+import time
+from functools import wraps
+
+class ToolRegistry:
+    """工具注册中心，管理可用工具的注册、验证和执行"""
+    
+    def __init__(self):
+        self._tools = {}
+        self._schemas = {}
+    
+    def register(self, name=None, description="", parameters=None, timeout=30):
+        """工具注册装饰器"""
+        def decorator(func):
+            tool_name = name or func.__name__
+            self._tools[tool_name] = func
+            self._schemas[tool_name] = {
+                "name": tool_name,
+                "description": description or func.__doc__ or "",
+                "parameters": parameters or {"type": "object", "properties": {}},
+                "timeout": timeout
+            }
+            return func
+        return decorator
+    
+    def get_schemas(self):
+        """获取所有工具的描述 schema"""
+        return list(self._schemas.values())
+    
+    def execute(self, tool_name, **kwargs):
+        """执行指定工具，带参数验证和超时控制"""
+        if tool_name not in self._tools:
+            return {"error": f"工具 '{tool_name}' 不存在", "available_tools": list(self._tools.keys())}
+        
+        # 参数验证（简化版）
+        schema = self._schemas[tool_name]
+        required = schema["parameters"].get("required", [])
+        for param in required:
+            if param not in kwargs:
+                return {"error": f"缺少必选参数 '{param}'"}
+        
+        # 执行工具
+        try:
+            result = self._tools[tool_name](**kwargs)
+            return {"result": result}
+        except Exception as e:
+            return {"error": f"工具执行失败: {str(e)}"}

package/shared/agent_systems/workflow_engine.py

@@ -0,0 +1,68 @@
+# WorkflowEngine 定义
+# 从文档自动提取生成
+
+from collections import deque
+
+class WorkflowEngine:
+    """基于 DAG 的工作流执行引擎"""
+    
+    def __init__(self, message_bus, orchestrator):
+        self.bus = message_bus
+        self.orchestrator = orchestrator
+        self.checkpoints = {}
+    
+    def execute(self, workflow):
+        """执行工作流 DAG"""
+        # 拓扑排序确定执行顺序
+        execution_order = self._topological_sort(workflow)
+        
+        # 按层级执行（同层节点可并行）
+        for level in execution_order:
+            # 并行分配同层任务
+            for node_id in level:
+                node = workflow["nodes"][node_id]
+                agent_id = node.get("agent_id")
+                if agent_id:
+                    self.orchestrator.assign_task(node["task"], agent_id)
+            
+            # 等待同层任务完成
+            results = self.orchestrator.collect_results(level)
+            
+            # 保存检查点
+            self.checkpoints[level] = results
+            
+            # 检查是否有失败的任务
+            for task_id, result in results.items():
+                if result.get("status") == "error":
+                    # 触发容错处理
+                    self._handle_failure(task_id, result, workflow)
+        
+        return self.checkpoints
+    
+    def _topological_sort(self, workflow):
+        """拓扑排序，返回按层级组织的执行顺序"""
+        nodes = workflow["nodes"]
+        edges = workflow.get("edges", [])
+        
+        # 计算入度
+        in_degree = {nid: 0 for nid in nodes}
+        children = {nid: [] for nid in nodes}
+        for edge in edges:
+            children[edge["from"]].append(edge["to"])
+            in_degree[edge["to"]] += 1
+        
+        # BFS 分层
+        levels = []
+        queue = deque([nid for nid, deg in in_degree.items() if deg == 0])
+        while queue:
+            level = []
+            for _ in range(len(queue)):
+                nid = queue.popleft()
+                level.append(nid)
+                for child in children[nid]:
+                    in_degree[child] -= 1
+                    if in_degree[child] == 0:
+                        queue.append(child)
+            levels.append(level)
+        
+        return levels

package/src/commands/data.js

@@ -96,6 +96,15 @@ const DATASETS = [
     format: 'git',
     targetDir: 'datasets/minimind-alignment',
     source: 'ModelScope (icyfenix)'
+  },
+  {
+    id: 'gsm8k-200',
+    name: 'GSM8K 200 (数学推理评测集)',
+    url: 'https://www.modelscope.cn/datasets/icyfenix/GSM8K_200.git',
+    size: '~109KB',
+    format: 'git',
+    targetDir: 'datasets/gsm8k-200',
+    source: 'ModelScope (icyfenix)'
   }
 ]
 

package/src/server/native_env_check.js

@@ -29,7 +29,9 @@ const SOFT_DEPS = [
   'transformers',
   'tokenizers',
   'datasets',
-  'ipywidgets'
+  'ipywidgets',
+  'accelerate',
+  'bitsandbytes'
 ]
 
 // 环境检测结果缓存

package/version.json

@@ -1,4 +1,4 @@
 {
-  "buildTime": "2026-06-06T02:22:08.498Z",
-  "cliVersion": "2026.6.6-1021"
+  "buildTime": "2026-06-11T11:46:24.774Z",
+  "cliVersion": "2026.6.11-1945"
 }