feat:项目初始化，实现了workflow_manager

.gitignore

@@ -0,0 +1,10 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv

.python-version

@@ -0,0 +1 @@
+3.13

archonbot/core/model_router/model_router.py

@@ -0,0 +1,3 @@
+class ArchonModelRouter:
+    def __init__(self):
+        self.handler = {}

archonbot/core/pipeline/worker.py

@@ -0,0 +1,24 @@
+import asyncio
+from archonbot.protocol__plugin.event import ArchonMessageEvent
+
+class ArchonWorker:
+    def __init__(self):
+        self.workflow_queue = asyncio.Queue()
+        self.workflow_router = {}
+
+    def add_event(self, event: ArchonMessageEvent):
+        self.workflow_queue.put(event)
+
+    async def run(self):
+        while True:
+            try:
+                event : ArchonMessageEvent = self.workflow_queue.get()
+                match event.target:
+                    case "plugin":
+                        pass
+                    case _:
+                        pass
+            except:
+                pass
+            finally:
+                pass

archonbot/core/workflow_manager/workflow__manager.py

@@ -0,0 +1,52 @@
+import json
+from pathlib import Path
+from loguru import logger
+from archonbot.workflow_plugin.workflow import Workflow
+from archonbot.core.workflow_manager.workflow_generator.workflow_generator import WorkflowGenerator
+
+#工作流管理器，管理所有的工作流
+class WorkflowManager:
+    def __init__(self):
+        self.workflow_registry = {}
+        self._load_workflow_registry()
+
+    #_load_workflow_registry(加载工作流登记表)，在工作流管理器初始化时将工作流文件加载到工作流管理器
+    def _load_workflow_registry(self) -> None:
+        plugin_dir = Path("archonbot/workflow_plugin/workflow_list")
+        for file_path in plugin_dir.glob("*_workflow.json"):
+            try:
+                module_name = file_path.stem.rsplit("_",1)[0]
+                with file_path.open("r", encoding="utf-8") as file:
+                    workflow = json.load(file)
+                    self.workflow_registry[module_name] = workflow.get("description")
+                    logger.success("已加载工作流{}".format(module_name))
+            except:
+                logger.warning("工作流文件{}加载失败".format(file_path))
+
+    #init_workflow(初始化工作流），创建一个工作流并且注册到工作流管理器，并且生成对应的工作流文件到对应文件夹
+    def init_workflow(self, workflow_name : str, description : str, metadata : dict, work_link : list) -> None:
+        try:
+            WorkflowGenerator.generate(workflow_name, description, metadata, work_link)
+            self.workflow_registry[workflow_name] = description
+            logger.success("已创建{}工作流".format(workflow_name))
+        except FileExistsError:
+            logger.warning("{}工作流创建失败,错误原因：文件已存在".format(workflow_name))
+        except Exception as e:
+            logger.warning("{}工作流创建失败,错误原因：{}".format(workflow_name,e))
+
+    #get_workflow(获取工作流），将event对象转化为workflow对象并返回
+    def get_workflow(self, workflow_title : str,  workflow_command: str, workflow_name : str) -> Workflow:
+        if workflow_name not in self.workflow_registry:
+            logger.error(f"尝试启动未注册的工作流: {workflow_name}")
+            raise ValueError(f"Workflow {workflow_name} not found in registry.")
+        workflow = Workflow()
+        workflow.create_workflow(workflow_title, workflow_command, workflow_name)
+        return workflow
+
+    #get_workflow_list(获取工作流注册表），将工作流管理器中已经注册的工作流转化为格式化的json格式返回给llm
+    def get_workflow_list(self) -> str:
+        if not self.workflow_registry:
+            return "目前暂无可用工作流，请先通过指导文件创建。"
+        workflow_list = [{"workflow_name": workflow_name, "description": description} for workflow_name, description in self.workflow_registry.items()]
+        workflow_dict = {"name":"可用工作流表", "workflow_list":workflow_list}
+        return json.dumps(workflow_dict)

archonbot/core/workflow_manager/workflow_generator/workflow_generator.py

@@ -0,0 +1,24 @@
+from pathlib import Path
+from jinja2 import Template
+
+class WorkflowGenerator:
+    @staticmethod
+    def generate(workflow_name : str, description : str, metadata : dict, work_link : list) -> None:
+        #检查文件是否存在并生成工作流配置文件
+        target_path = Path("archonbot/workflow_plugin/workflow_list/")
+        workflow_file = target_path / "{}_workflow.json".format(workflow_name)
+        target_path.mkdir(parents=True, exist_ok=True)
+        if workflow_file.exists():
+            raise FileExistsError(f"file {workflow_file} already exists")
+        #加载配置模板
+        current_dir = Path(__file__).parent
+        template_file = current_dir / "workflow_json_template.j2"
+        with open(template_file) as f:
+            template = Template(f.read())
+        #渲染并生成配置文件
+        render_context = template.render(name=workflow_name,
+                        description=description,
+                        metadata=metadata,
+                        works=work_link)
+        with open(workflow_file, "w", encoding="utf-8") as f:
+            f.write(render_context)

archonbot/core/workflow_manager/workflow_generator/workflow_json_template.j2

@@ -0,0 +1,13 @@
+{
+  "name": "{{ name }}",
+  "version": "1.0",
+  "description": "{{ description }}"
+  "metadata": {
+    "limit": {{ metadata.limit | default(10) }}
+  },
+  "work_link": [
+    {% for work in works %}
+    {{ work | tojson }}{% if not loop.last %},{% endif %}
+    {% endfor %}
+  ]
+}

archonbot/individual_plugin/consciousness_node.py

@@ -0,0 +1,17 @@
+import ray
+from archonbot.protocol__plugin.model_protocol.modelbase import ModelBase
+
+@ray.remote
+class ConsciousnessNode:
+    def __init__(self):
+        self.model_id : str
+        self.path : str
+        self.adapter : str
+        self.name : str
+        self.model_method : ModelBase
+
+    async def get_model(self):
+        return await self.model_method.get_model
+
+    async def post_message(self):
+        return await self.model_method.post_message

archonbot/protocol__plugin/event.py

@@ -0,0 +1,11 @@
+from ulid import ULID
+
+class ArchonMessageEvent:
+    def __init__(self):
+        event_id : ULID
+        user : str
+        command : str
+        target : str
+        requirement : dict
+        payload : dict
+        context : dict

archonbot/protocol__plugin/model_protocol/gemini.py

@@ -0,0 +1,76 @@
+import httpx
+import json
+from typing import List, Dict, Any, AsyncGenerator
+from archonbot.protocol__plugin.model_protocol.modelbase import ModelBase
+
+class GeminiAdapter(ModelBase):
+    def __init__(self, base_url: str, adapter_title: str, api_key: str):
+        self.adapter_title: str = adapter_title
+        self.base_url = base_url.rstrip('/')
+        if not self.base_url.endswith('/v1'):
+            self.base_url += '/v1'
+        self.api_key = api_key
+        self.model_list = []
+
+    async def get_model(self) -> List[str]:
+        url = f"{self.base_url}/models"
+        headers = {"Authorization": f"Bearer {self.api_key}"}
+
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            response = await client.get(url, headers=headers)
+            response.raise_for_status()
+            data = response.json()
+            self.model_list = [m.get("id", "") for m in data.get("data", [])]
+            return self.model_list
+
+    async def post_message(
+            self,
+            model: str,
+            messages: List[Dict[str, str]],
+            stream: bool = False,
+            temperature: float = 0.7,
+            max_tokens: int = 4096,
+            **kwargs
+    ) -> Any:
+        url = f"{self.base_url}/chat/completions"
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+
+        payload = {
+            "model": model,
+            "messages": messages,
+            "stream": stream,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+            **kwargs
+        }
+
+        # 144GB 显存或云端长文本建议设置较长超时
+        timeout = httpx.Timeout(120.0, connect=10.0)
+
+        if not stream:
+            async with httpx.AsyncClient(timeout=timeout) as client:
+                response = await client.post(url, headers=headers, json=payload)
+                response.raise_for_status()
+                return response.json()
+        else:
+            return self._handle_stream(url, headers, payload)
+
+    @staticmethod
+    async def _handle_stream(self, url: str, headers: dict, payload: dict) -> AsyncGenerator[str, None]:
+        async with httpx.AsyncClient(timeout=None) as client:
+            async with client.stream("POST", url, headers=headers, json=payload) as response:
+                response.raise_for_status()
+                async for line in response.aiter_lines():
+                    if not line.strip() or line == "data: [DONE]":
+                        continue
+                    if line.startswith("data: "):
+                        try:
+                            chunk = json.loads(line[6:])
+                            delta = chunk["choices"][0]["delta"].get("content", "")
+                            if delta:
+                                yield delta
+                        except (json.JSONDecodeError, KeyError):
+                            continue

archonbot/protocol__plugin/model_protocol/modelbase.py

@@ -0,0 +1,10 @@
+from abc import ABC,abstractmethod
+
+class ModelBase(ABC):
+    @abstractmethod
+    async def get_model(self):
+        pass
+
+    @abstractmethod
+    async def post_message(self, model: str, messages: list, stream: bool = False, **kwargs):
+        pass

archonbot/protocol__plugin/model_protocol/openai.py

@@ -0,0 +1,39 @@
+import httpx
+from archonbot.protocol__plugin.model_protocol.modelbase import ModelBase
+
+class OpenAIAdapter(ModelBase):
+    def __init__(self, base_url: str, adapter_title: str, api_key: str = "archon-local"):
+        self.adapter_title: str = adapter_title
+        self.base_url = base_url.rstrip('/')
+        if not self.base_url.endswith('/v1'):
+            self.base_url += '/v1'
+        self.api_key = api_key
+        self.model_list = []
+
+    async def get_model(self):
+        url = "{}/models".format(self.base_url)
+        headers = {
+            "Authorization": f"Bearer {self.api_key}"
+        }
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url, headers=headers)
+        response.raise_for_status()
+        response = response.json()
+        self.model_list = [m.get("id", "") for m in response.get("data", [])]
+        return self.model_list
+
+    async def post_message(self,model: str, messages: list, stream: bool = False, **kwargs):
+        url = f"{self.base_url}/chat/completions"
+        headers = {"Authorization": f"Bearer {self.api_key}"}
+        payload = {
+            "model": model,
+            "messages": messages,
+            "stream": stream,
+            **kwargs
+        }
+        async with httpx.AsyncClient(timeout=None) as client:
+            if not stream:
+                response = await client.post(url, headers=headers, json=payload)
+                return response.json()
+            else:
+                return client.stream("POST", url, headers=headers, json=payload)

archonbot/tool_plugin/docker_sandbox/docker_sandbox_manager.py

@@ -0,0 +1,6 @@
+import docker
+import socket
+
+class DockerSandBoxManager():
+    def __init__(self):
+        pass

archonbot/tool_plugin/docker_sandbox/docker_shell.json

@@ -0,0 +1,33 @@
+{
+  "name": "docker_sandbox",
+  "desc": "一款通过docker实现环境隔离的沙箱环境，实现安全地任务实现",
+  "command": [
+    {
+      "name": "read",
+      "desc": "浏览文件",
+      "param": {
+        "-p $PATH": "浏览$PATH下的文件",
+        "-h $LINE": "浏览前$LINE行文件"
+      }
+    },
+    {
+      "name": "write",
+      "desc": "写入文件",
+      "param": {
+        "-p $PATH": "写入$PATH下的文件",
+        "-t $TEXT": "将$TEXT写入文件"
+      }
+    },
+    {
+      "name": "ls",
+      "desc": "获取文件列表",
+      "param": {
+        "-l $PATH": "获取$PATH下的文件"
+      }
+    },
+    {
+
+    }
+  ],
+  "specification": ""
+}

archonbot/tool_plugin/docker_sandbox/sandbox_client.py

@@ -0,0 +1,8 @@
+import docker
+import socket
+
+class SandboxClient:
+    def __init__(self, sandbox_id : int, ):
+        self.sandbox_id : int
+        
+        client = docker.from_env()

archonbot/tool_plugin/docker_sandbox/sandbox_image/Dockerfile

@@ -0,0 +1,4 @@
+FROM ubuntu:latest
+LABEL authors="zhaoxi"
+
+ENTRYPOINT ["top", "-b"]

archonbot/tool_plugin/docker_sandbox/sandbox_image/archon_shell.py

@@ -0,0 +1,33 @@
+class ArchonShell:
+    @staticmethod
+    def read():
+        pass
+
+    @staticmethod
+    def write():
+        pass
+
+    @staticmethod
+    def ls():
+        pass
+
+    @staticmethod
+    def mkdir():
+        pass
+
+    @staticmethod
+    def exec_py():
+        pass
+
+    @staticmethod
+    def exec_shell():
+        pass
+
+    @staticmethod
+    def kill():
+        pass
+
+    @staticmethod
+    def submit():
+        pass
+

archonbot/tool_plugin/docker_sandbox/sandbox_image/archon_shell_server.py

@@ -0,0 +1,16 @@
+import os
+import sys
+from loguru import logger
+import socket
+import multiprocessing
+
+class ArchonShellServer:
+    def __init__(self):
+        self.workspace_path = os.environ.get("ARCHON_WORKSPACE")
+        self.socket_path = os.environ.get("ARCHON_SOCKET")
+        self.signal_path = os.environ.get("ARCHON_SIGNAL")
+
+    def run(self):
+        while True:
+            pass
+

archonbot/workflow_plugin/workflow.py

@@ -0,0 +1,49 @@
+from pathlib import Path
+import json
+from ulid import ULID
+
+class Workflow:
+    def __init__(self):
+        self.workflow_id : str = ""
+        self.workflow_title: str = ""
+        self.work_link: list = []
+        self.workflow_description: str = ""
+        self.workflow_command: str = ""
+        self.workflow_output: dict = {}
+        self.workflow_metadata : dict = {}
+        self.work_demand: dict = {}
+        self.status: str = ""
+
+    def create_workflow(self, trace_id : str, workflow_title: str, workflow_command: str, workflow_name : str) -> None:
+        current_dir = Path(__file__).parent
+        workflow_file = current_dir / "workflow_list" / "{}_workflow.json".format(workflow_name)
+        with workflow_file.open("r", encoding="utf-8") as json_file:
+            workflow_json = json.load(json_file)
+            self.workflow_id = "{}_".format(workflow_name) + trace_id
+            self.workflow_title = workflow_title
+            self.work_link = workflow_json.get("work_link")
+            self.workflow_description = workflow_json.get("workflow_description")
+            self.workflow_command = workflow_command
+            self.workflow_metadata = workflow_json.get("metadata")
+            self.status = "step1"
+
+    def get_workflow(self) -> str:
+        workflow = {
+            "workflow_id":self.workflow_id,
+            "workflow_title":self.workflow_title,
+            "work_link":self.work_link,
+            "workflow_command":self.workflow_command,
+            "workflow_output":self.workflow_output,
+            "workflow_metadata":self.workflow_metadata,
+            "work_demand":self.work_demand,
+            "status":self.status,
+        }
+        workflow = json.dumps(workflow)
+        return workflow
+
+    def set_output(self, step, output) -> None:
+        self.workflow_output["step:{}".format(step)] = output
+
+    def set_work_link(self, work_link: str) -> None:
+        work_link = json.loads(work_link)
+        self.work_link = work_link

archonbot/workflow_plugin/workflow_list/programme_workflow.json

@@ -0,0 +1,114 @@
+{
+  "name": "programme",
+  "version": "1.0",
+  "description": "编写程序的工作链模版,用于完成一个编程任务",
+  "metadata": {
+  },
+  "work_link": [
+    {
+      "step": 1,
+      "node": "consciousness_node",
+      "action": "architect",
+      "desc": "构建程序架构，定义子个体需求与工作链变更",
+      "output": "arch_spec",
+      "status": "waiting"
+    },
+    {
+      "step": 2,
+      "node": "control_node",
+      "action": "spawn_actors",
+      "desc": "根据 arch_spec 拉起子个体，挂载对应目录",
+      "input": "arch_spec",
+      "status": "waiting"
+    },
+    {
+      "step": 3,
+      "node": "composite_individual",
+      "action": "decompose",
+      "desc": "拆解 arch_spec 为原子任务包 (Task Packets)",
+      "input": "arch_spec",
+      "output": "task_packets",
+      "status": "waiting"
+    },
+    {
+      "step": 4,
+      "node": "primary_individual",
+      "action": "execute_code",
+      "desc": "执行编码任务，写入目标文件",
+      "input": "task_packets",
+      "output": "source_code",
+      "status": "waiting"
+    },
+    {
+      "step": 5,
+      "node": "composite_individual",
+      "action": "audit",
+      "desc": "静态逻辑检查与代码规范审计",
+      "input": "source_code",
+      "output": "audit_report",
+      "status": "waiting"
+    },
+    {
+      "step": 6,
+      "node": "control_node",
+      "action": "resource_recycle",
+      "desc": "暂存编码 Actor 状态，释放非必要显存",
+      "input": "audit_report",
+      "status": "waiting"
+    },
+    {
+      "step": 7,
+      "node": "consciousness_node",
+      "action": "design_test",
+      "desc": "基于 source_code 设计测试用例架构 (Test Bench)",
+      "input": "source_code",
+      "output": "test_spec",
+      "status": "waiting"
+    },
+    {
+      "step": 8,
+      "node": "control_node",
+      "action": "spawn_test_env",
+      "desc": "拉起测试专用子个体并分配执行环境",
+      "input": "test_spec",
+      "status": "waiting"
+    },
+    {
+      "step": 9,
+      "node": "primary_individual",
+      "action": "run_test",
+      "desc": "运行测试并生成实验报告 (Experiment Report)",
+      "input": "test_spec",
+      "output": "test_report",
+      "status": "waiting"
+    },
+    {
+      "step": 10,
+      "node": "consciousness_node",
+      "action": "analyze_report",
+      "desc": "研究测试报告，决定是否触发迭代循环",
+      "input": "test_report",
+      "logic_gate": {
+        "if_fail": "jump_to_step_1",
+        "if_pass": "continue"
+      },
+      "status": "waiting"
+    },
+    {
+      "step": 11,
+      "node": "consciousness_node",
+      "action": "finalize",
+      "desc": "总结全流程报告，提交归档",
+      "output": "final_package",
+      "status": "waiting"
+    },
+    {
+      "step": 12,
+      "node": "supervisory_node",
+      "action": "terminate_workflow",
+      "desc": "核对 final_package，关闭工作流并向用户反馈",
+      "input": "final_package",
+      "status": "waiting"
+    }
+  ]
+}

docs/project.md

@@ -0,0 +1,27 @@
+## ArchonBot项目开发
+#项目规划
+---
+#### 全局规划：
+- [ ] 实现监管模型的资源调度
+- [ ] 实现子个体的工作传递
+- [ ] 实现用户交互接口与ray集群的交互
+- [ ] 实现监管模型调度ray资源的接口
+- [ ] 实现由监管模型理解并发布，子个体向下布置任务，完成任务向上传递，监管模型检查的全工作流
+---
+#### 简介
+**ArchonBot**是一款python开发，实现将小模型进行微调后整理为一个大型集群，从而实现低算力情况下高复杂度任务的实现。
+系统模型分为以下部分：
+- **监管节点**：负责基本交流和任务分流；
+- **管控节点**：负责调度系统资源；
+- **意识节点**：负责复杂任务的处理；
+- **生长节点**：负责获取资源并且将基础模型训练为特化模型；
+- **感知模块**：与外界交互的模型，如embedding模型，tts模型等；
+- **复合子个体**：将监管节点的任务领取并进行专业的拆解任务并进行分配；
+- **生产子个体**：领取任务最小单位并执行；
+---
+#### 短期规划
+v0.1版本
+- [ ] **workflow构建**:构建任务的工作流
+- [ ] **接口构建**:对接vllm，openai接口和gemini接口
+- [ ] **工具构建**:配置供模型调用的爬虫工具箱，docker接口
+- [ ] **平台对接构建**:对接telegram等消息平台

pyproject.toml

@@ -0,0 +1,14 @@
+[project]
+name = "archonbot"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "docker-py>=1.10.6",
+    "httpx>=0.28.1",
+    "jinja2>=3.1.6",
+    "loguru>=0.7.3",
+    "python-ulid>=3.1.0",
+    "ray[defaule,serve]>=2.54.0",
+]