@baimingtao/lbs-agent 1.0.0

package/AGENTS.md

@@ -0,0 +1,54 @@
+# AGENTS.md — LBS Agent 项目指令
+
+## 项目结构
+
+```
+lbs.py                    # 入口
+cli/main.py               # CLI 命令分发
+config/config.py          # 配置加载 (models.yaml + agents.yaml)
+core/llm/                 # LLM 层 (LLMClient + ModelRouter + CredentialPool)
+orchestration/loop/       # AgentLoop (ReAct 循环 + 验证 + 压缩)
+orchestration/supervisor_loop.py  # Orchestrator (多 Agent 编排 + DAG)
+orchestration/auto_cycle/ # Cron 定时任务
+tools/tool/               # 工具层 (Registry + Runtime + Profile)
+context/management/       # 上下文压缩引擎
+memory/                   # 短期/长期记忆
+memory/session/           # 会话存储
+```
+
+## 开发规范
+
+1. 修改核心层（LLM/编排/工具）后必须跑全量测试：`python -m pytest tests/ -q`
+2. 新增功能必须有对应测试
+3. optional-skills/ 和 optional-mcps/ 视为官方源；项目运行时状态统一进入 .lbs-agent/
+4. 自定义 skill 走 .lbs-agent/skills/local/；远程源走 .lbs-agent/skills/source/<alias>/；运行时只读 .lbs-agent/skills/active/
+5. 配置在 runtime/core/llm/registry/models.yaml / runtime/core/sub_agents/agents.yaml / tools/tool/tools.yaml / .lbs-agent/skills/sources.json 等，不在代码里硬编码
+6. 错误处理用 error_strategy（fail/retry/continue/escalate），不要裸 try/except
+
+## 测试
+
+```bash
+# 全量测试
+python -m pytest tests/ -q
+
+# 单个模块
+python -m pytest tests/architecture/test_agent_loop_collaborators.py -v
+
+# 真实 LLM 测试（需要 seeyon key）
+python lbs.py run-agent auditor "审计任务"
+```
+
+## Agent 配置
+
+当前 11 个子 Agent 在 `runtime/core/sub_agents/agents.yaml` 中定义：
+- chat（对话助手）、code（代码修改）、auditor（审计与安全）
+- vision（图片识别）、verifier（结果验证）、document（文档生成）
+- browser_worker（浏览器执行）、research（研究助手）
+- data_analyst（数据分析）、email_agent（邮件助手）、github_agent（GitHub 管理）
+
+每个 Agent 有：
+- model_chain（首选 → fallback 模型链）
+- tools（允许的工具列表）
+- guardrails（安全约束）
+- verification_rules（完成标准）
+- verification_level（light/medium/heavy）

package/README.md

@@ -0,0 +1,181 @@
+# LBS Agent
+
+LBS Agent 是一个自主 Agent 运行时系统。当前仓库的正式架构已经收口为五层：
+- `application/`：composition root + application services
+- `runtime/`：runtime kernel（LLM / context / memory / orchestration / perception）
+- `interfaces/`：CLI / API / gateway / web 入口
+- `extensions/`：skills 与 optional MCP catalogs
+- `tools/`：tool runtime、skill/mcp provider、执行基础设施
+
+legacy 顶层包（如 `app/`、`core/`、`cli/`）目前仅作为 compatibility shim 保留，不再是正式实现目录。
+
+## 5 分钟上手
+
+### 安装 / 启动
+
+```bash
+git clone <repo>
+cd lbs-agent
+pip install -r requirements.txt   # 或 poetry install
+python lbs.py --help
+```
+
+也可以继续使用顶层入口：
+
+```bash
+python lbs.py --help
+```
+
+### 配置 LLM Provider
+
+```bash
+python lbs.py llm inspect
+python lbs.py models
+python lbs.py config
+```
+
+模型与 agent 内置配置位于：
+- `runtime/core/llm/registry/models.yaml`
+- `runtime/core/sub_agents/agents.yaml`
+
+### 第一次跑 Agent
+
+```bash
+python lbs.py run "say hello"
+python lbs.py run-agent code "write fizzbuzz in python"
+```
+
+### 多 Agent 编排
+
+```bash
+python lbs.py run-agent research "调研 Hermes 和 LBS 的区别"
+python lbs.py run-agent summary "总结上一条结果"
+```
+
+## 当前架构
+
+### 1. application/
+- `application/container.py`：系统装配根
+- `application/runtime_factory.py`：构建单 agent runtime config
+- `application/services/`：use-case services（model / agent / orchestration / session / cron / tool / interactive / gateway / skill / mcp）
+
+### 2. runtime/
+- `runtime/core/`：ModelRouter、provider、sub-agent registry
+- `runtime/context/`：context builder / manager / trimming / compression
+- `runtime/memory/`：session store、working memory、long-term memory、task contracts
+- `runtime/orchestration/`：Orchestrator、AgentLoop、scheduler、verification
+- `runtime/perception/`：intent / entity / input preprocess
+
+### 3. interfaces/
+- `interfaces/cli/_impl/`：CLI 命令实现
+- `interfaces/api/_impl/server.py`：FastAPI 服务
+- `interfaces/gateway/_impl/`：gateway adapters
+- `interfaces/web/frontend/`：前端
+- `interfaces/web/legacy_web/`：历史 web 资源承接区
+
+### 4. extensions/
+- `extensions/skills/builtin/`
+- `extensions/skills/optional/`
+- `extensions/mcps/optional/`
+
+### 5. tools/
+- `tools/tool/`：ToolRuntime、tool policy、tool registry
+- `tools/skill/`：skill registry / provider
+- `tools/mcp/`：MCP registry / provider infra
+
+## 依赖方向
+
+正式依赖方向应保持：
+
+```text
+interfaces -> application -> runtime
+tools -----^            -> tools infra
+extensions (asset catalogs, loaded by runtime/tools when needed)
+```
+
+约束：
+- `interfaces/` 不直接依赖 runtime internals
+- `runtime/` 不反向 import `application/`
+- `legacy shim` 只做兼容转发，不承载真实逻辑
+
+## 常用命令
+
+```text
+lbs models
+lbs model list [--config]
+lbs model switch <provider> <model>
+lbs model health [provider]
+
+lbs llm inspect
+lbs llm validate [--json]
+lbs llm diagnostics [--json]
+lbs llm route <agent>
+
+lbs agents
+lbs tools inspect
+lbs tools list [--agent name]
+lbs tools profiles
+
+lbs skills list
+lbs skills view <name>
+lbs skill list
+lbs skill sources
+lbs skill sync <repo> [alias]
+
+lbs mcp list
+
+lbs sessions list
+lbs sessions show <id>
+lbs sessions export <id> <out>
+lbs sessions report [id]
+
+lbs workers list
+lbs workers show <id>
+
+lbs cron list
+lbs run "<task>"
+lbs run-agent <name> "<task>"
+```
+
+## 编程 API
+
+### Container
+
+```python
+from application.container import AgentSystemContainer
+from config.config import AppConfig
+
+container = AgentSystemContainer(config=AppConfig())
+container.session_service().list_sessions(limit=10)
+container.model_service().inspect_llm()
+container.build_orchestrator()
+```
+
+### Orchestrator
+
+```python
+result = container.build_orchestrator().run_agent_sync(
+    agent_name="code",
+    task="write hello world",
+    context="",
+    session_id="",
+)
+print(result.success, result.content)
+```
+
+## 开发
+
+### focused tests
+
+```bash
+python -m pytest tests/architecture/ -v
+python -m pytest tests/test_app_services_boundary.py tests/test_server_api.py -q
+```
+
+### 目录收口说明
+
+目录大迁移已完成；当前剩余 legacy 顶层目录主要用于 import compatibility。后续收尾以：
+1. 缩小 shim 表面积
+2. 让测试与文档全面直连新路径
+3. 最终删除不再需要的 legacy 目录
+为主。

package/SOUL.md

@@ -0,0 +1,31 @@
+# LBS Agent — 主 Agent 身份
+
+你是 LBS Agent，一个企业执行型多 Agent 系统的主 Agent。
+
+## 身份
+
+- 名称：LBS Agent
+- 定位：企业级执行型 AI Agent，专注于致远互联客开/交付、代码工程、自动化任务
+- 用户：白明涛（致远互联，采购/供应链方向）
+
+## 行为准则
+
+1. 先动手再开口 — 先读文件、查上下文、搜答案，搞不定再问
+2. evidence-first — 每个结论都要有证据（文件路径+行号、命令输出、工具结果）
+3. 简洁高效 — 跳过废话，直接干活
+4. 对外谨慎对内大胆 — 读文件/分析/整理放心做；发消息/公开操作先确认
+5. 出错了说实话 — 别掩饰，别编造
+
+## 工作方式
+
+- 采用 Plan-Act-Reflect 循环
+- 有 Skill 时先加载方法论再执行
+- 中文为主，技术术语保留英文
+- 代码/命令直接给，不要解释半天再给
+
+## 安全红线
+
+- 私密数据绝不外泄
+- 破坏性操作先问
+- trash > rm（可恢复优于永久删除）
+- 不确定就问，别猜

package/application/__init__.py

@@ -0,0 +1 @@
+"""智能体系统目标架构包。"""

package/application/container.py

@@ -0,0 +1,376 @@
+"""应用装配根（Composition Root）。
+
+这是唯一负责把 config + LLM/tool/session/orchestration
+组装成可运行系统的层。入口（CLI/TUI/Gateway/API）调用 services；
+services 调用本容器；core 运行时各层不能反向 import app。
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pathlib import Path
+from threading import Event, Thread
+from typing import Optional
+
+from application.runtime_paths import RuntimePaths
+from config.config import AppConfig, load_config
+
+
+class AgentSystemContainer:
+    """Composition root for the LBS Agent system."""
+
+    def __init__(
+        self,
+        config: Optional[AppConfig] = None,
+        project_root: str | Path | None = None,
+        state_root: str | Path | None = None,
+        tools_config_path: str | Path | None = None,
+    ):
+        self.config = config or load_config()
+        self.project_root = Path(project_root) if project_root is not None else Path(__file__).resolve().parents[1]
+        self.tools_config_path = str(Path(tools_config_path).expanduser()) if tools_config_path is not None else None
+        self.runtime_paths = RuntimePaths.for_project(self.project_root, state_root=state_root).ensure()
+        self._runtime_factory = None
+        from runtime.core.llm.credential import CredentialPoolRegistry
+        self._credential_pool_registry = CredentialPoolRegistry()
+        self._orchestrator = None
+        self._session_store = None
+        self._cron_system = None
+        self._services = {}
+        self._cron_stop = Event()
+        self._cron_thread = None
+        self.models_yaml_path_override = None
+        self.agents_yaml_path_override = None
+        self.mcp_registry_path_override = None
+
+    def build_gateway_registry(self):
+        """返回 Gateway 实现注册表；具体接口实现只在装配根中出现。"""
+        from interfaces.gateway._impl import get_gateway_registry
+
+        return get_gateway_registry()
+
+    def build_gateway_installers(self):
+        """构建平台 adapter 工厂映射，供应用服务按需注册。"""
+        from interfaces.gateway._impl.adapters.dingtalk import DingTalkGateway
+        from interfaces.gateway._impl.adapters.feishu import FeishuGateway
+        from interfaces.gateway._impl.adapters.qq import QQGateway
+        from interfaces.gateway._impl.adapters.slack import SlackGateway
+        from interfaces.gateway._impl.adapters.wechat import WeChatGateway
+
+        return {
+            "feishu": FeishuGateway,
+            "wechat": WeChatGateway,
+            "qq": QQGateway,
+            "dingtalk": DingTalkGateway,
+            "slack": SlackGateway,
+        }
+
+    def build_session_store(self):
+        from runtime.memory.session.session_store import SessionStore
+
+        if self._session_store is None:
+            self._session_store = SessionStore(str(self.project_root), session_dir=self.runtime_paths.sessions)
+        return self._session_store
+
+    def build_agent_registry(self):
+        from runtime.core.sub_agents.registry import AgentRegistry
+
+        return AgentRegistry(self.config)
+
+    def build_tool_registry(self, *, include_mcp: bool = True):
+        from tools.tool.builtin import create_default_registry
+        from tools.tool.mcp_provider import McpToolProvider
+
+        reg = create_default_registry()
+        if not include_mcp:
+            return reg
+        try:
+            mcp_registry = self.build_mcp_registry()
+            if mcp_registry.list_servers(include_disabled=False):
+                reg.register_provider(McpToolProvider(mcp_registry))
+        except Exception:
+            pass
+        return reg
+
+    def build_runtime_factory(self):
+        from application.runtime_factory import AgentRuntimeFactory
+
+        if self._runtime_factory is None:
+            self._runtime_factory = AgentRuntimeFactory(
+                self.config,
+                self.project_root,
+                self.build_tool_registry(include_mcp=False),
+                runtime_paths=self.runtime_paths,
+                credential_pool_registry=self._credential_pool_registry,
+                tools_config_path=self.tools_config_path,
+            )
+        return self._runtime_factory
+
+    def build_orchestrator(self):
+        from runtime.orchestration.supervisor_loop import Orchestrator
+
+        if self._orchestrator is None:
+            runtime_factory = self.build_runtime_factory()
+            # 把 ApprovalStore 注入 ToolRuntime：危险工具调用必须携带单次 token，
+            # 取代原先"裸 permissions.get('confirmed')"的简单检查。
+            try:
+                from tools.tool.approval_workflow import ApprovalStore
+                approval_store = ApprovalStore(self.runtime_paths.approvals)
+                if hasattr(runtime_factory, "attach_approval_store"):
+                    runtime_factory.attach_approval_store(approval_store)
+            except Exception:
+                pass
+
+            self._orchestrator = Orchestrator(
+                self.config,
+                runtime_factory=runtime_factory,
+                session_store=self.build_session_store(),
+            )
+        return self._orchestrator
+
+    def build_model_router(self, agent_name: str = "", provider_name: str = ""):
+        """构建 ModelRouter，并显式区分 Agent 路由与 provider 诊断路由。
+
+        - 传入 agent_name：保留该 Agent 的 provider/model/fallback 合同。
+        - 只传 provider_name：以该 provider 的默认/首个模型开始，并按配置顺序 fallback。
+        - 两者都不传：使用 models.default.provider + models.default.model。
+        """
+        from runtime.core.llm.model_router import ModelRouter
+        from config.config import AgentEntry, get_default_provider, get_provider, get_agent
+
+        cfg = self.config
+        agent_entry = get_agent(cfg, agent_name) if agent_name else None
+        selected_provider_name = provider_name or (agent_entry.provider if agent_entry else cfg.models.default_provider)
+        provider_entry = get_provider(cfg, selected_provider_name)
+        if provider_entry is None:
+            if selected_provider_name:
+                raise RuntimeError(f"provider '{selected_provider_name}' 不存在")
+            provider_entry, _ = get_default_provider(cfg)
+        if provider_entry is None:
+            raise RuntimeError("无默认 provider（models.yaml 里没配）")
+
+        if agent_entry is None or agent_entry.provider != provider_entry.name:
+            preferred_model = (
+                cfg.models.default_model
+                if cfg.models.default_provider == provider_entry.name
+                and cfg.models.default_model in provider_entry.models
+                else (provider_entry.models[0] if provider_entry.models else "")
+            )
+            fallback_models = [model for model in provider_entry.models if model != preferred_model]
+            agent_entry = AgentEntry(
+                name=f"_diagnostic_{provider_entry.name}",
+                provider=provider_entry.name,
+                model=preferred_model,
+                fallback_models=fallback_models,
+            )
+        return ModelRouter(
+            provider_entry=provider_entry,
+            agent_entry=agent_entry,
+            pool_registry=self._credential_pool_registry,
+        )
+
+    def build_cron_system(self):
+        from runtime.orchestration.auto_cycle import CronSystem
+
+        if self._cron_system is None:
+            self._cron_system = CronSystem(
+                jobs_file=str(self.runtime_paths.cron_jobs),
+                runner=self._run_cron_job,
+            )
+        return self._cron_system
+
+    def _run_cron_job(self, job):
+        result = self.build_orchestrator().run_agent_sync(
+            job.agent_name,
+            job.task,
+            context=job.context,
+        )
+        return result.success, result.content or result.error or ""
+
+
+    def build_mcp_registry(self):
+        """暴露 MCP 注册表（持久化 + 原子写）。"""
+        from tools.mcp.registry import McpRegistry
+        if not hasattr(self, "_mcp_registry") or self._mcp_registry is None:
+            override = getattr(self, "mcp_registry_path_override", None)
+            if override:
+                self._mcp_registry = McpRegistry(Path(override), virtual_proxy=True)
+            else:
+                configured = self.project_root / "config" / "mcp.yaml"
+                self._mcp_registry = McpRegistry(configured if configured.exists() else self.runtime_paths.mcp_registry, virtual_proxy=True)
+        return self._mcp_registry
+
+    def mcp_service(self):
+        from application.services.mcp_service import McpService
+        return self._service("mcp", McpService)
+
+    def _service(self, name: str, factory):
+        if name not in self._services:
+            self._services[name] = factory(self)
+        return self._services[name]
+
+    def model_service(self):
+        from application.services.model_service import ModelService
+
+        return self._service("model", ModelService)
+
+    def agent_service(self):
+        from application.services.agent_service import AgentService
+
+        return self._service("agent", AgentService)
+
+    def orchestration_service(self):
+        from application.services.orchestration_service import OrchestrationService
+
+        return self._service("orchestration", OrchestrationService)
+
+    def session_service(self):
+        from application.services.session_service import SessionService
+
+        return self._service("session", SessionService)
+
+    def cron_service(self):
+        from application.services.cron_service import CronService
+
+        return self._service("cron", CronService)
+
+    def tool_service(self):
+        from application.services.tool_service import ToolService
+
+        return self._service("tool", ToolService)
+
+    def interactive_service(self):
+        from application.services.interactive_service import InteractiveService
+
+        return self._service("interactive", InteractiveService)
+
+    def gateway_service(self):
+        from application.services.gateway_service import GatewayService
+
+        if "gateway" not in self._services:
+            self._services["gateway"] = GatewayService(
+                registry=self.build_gateway_registry(),
+                installers=self.build_gateway_installers(),
+                orchestration_service=self.orchestration_service(),
+                default_agent="chat",
+            )
+        return self._services["gateway"]
+
+    def skill_service(self):
+        from application.services.skill_service import SkillService
+
+        return self._service("skill", SkillService)
+
+    @property
+    def cron_loop_running(self) -> bool:
+        return bool(self._cron_thread and self._cron_thread.is_alive())
+
+    def start_cron_loop(self, interval_seconds: float = 1.0) -> None:
+        if self.cron_loop_running:
+            return
+        self._cron_stop.clear()
+
+        def run_loop():
+            while not self._cron_stop.is_set():
+                self.cron_service().tick()
+                # P1: durable task stale recovery
+                try:
+                    orchestrator = self.build_orchestrator()
+                    if hasattr(orchestrator, "recover_stale_tasks"):
+                        orchestrator.recover_stale_tasks()
+                    # Run skill curator
+                    try:
+                        from tools.skill.curator import apply_automatic_transitions
+                        apply_automatic_transitions()
+                    except Exception:
+                        pass
+                except Exception:
+                    pass
+                self._cron_stop.wait(interval_seconds)
+
+        self._cron_thread = Thread(target=run_loop, name="lbs-cron", daemon=True)
+        self._cron_thread.start()
+
+        # Start background review thread
+        try:
+            from runtime.orchestration.background_review import spawn_background_review_thread
+            spawn_background_review_thread(self.project_root)
+        except Exception:
+            pass
+
+    def startup_recovery(self) -> dict[str, Any]:
+        """P3-3: 启动时立即执行恢复逻辑。
+
+        1. 清理上次崩溃留下的 stale running tasks
+        2. 恢复 interactive sessions
+        3. 恢复 process registry
+
+        应在 Container 初始化后、服务启动前调用。
+        """
+        import logging
+        log = logging.getLogger(__name__)
+        report = {"stale_tasks_recovered": [], "sessions_recovered": [], "processes_recovered": 0}
+
+        # 1. Stale task recovery
+        try:
+            orchestrator = self.build_orchestrator()
+            if hasattr(orchestrator, "recover_stale_tasks"):
+                recovered = orchestrator.recover_stale_tasks()
+                if recovered:
+                    report["stale_tasks_recovered"] = recovered
+                    log.info("[startup] recovered %d stale tasks", len(recovered))
+        except Exception:
+            log.debug("[startup] stale task recovery failed", exc_info=True)
+
+        # 2. Interactive session recovery
+        try:
+            interactive = self.interactive_service() if hasattr(self, 'interactive_service') else None
+            if interactive is None:
+                # Try building it
+                from application.services.interactive_service import InteractiveService
+                interactive = InteractiveService(self)
+            if hasattr(interactive, 'recover_sessions'):
+                recovered_sessions = interactive.recover_sessions()
+                report["sessions_recovered"] = recovered_sessions
+                if recovered_sessions:
+                    log.info("[startup] recovered %d interactive sessions", len(recovered_sessions))
+        except Exception:
+            log.debug("[startup] session recovery failed", exc_info=True)
+
+        # 3. Process registry recovery
+        try:
+            from runtime.orchestration.runtime.process_registry import get_process_registry
+            registry = get_process_registry()
+            if hasattr(registry, 'recover_from_checkpoint'):
+                n = registry.recover_from_checkpoint()
+                report["processes_recovered"] = n
+                if n:
+                    log.info("[startup] recovered %d processes", n)
+        except Exception:
+            log.debug("[startup] process recovery failed", exc_info=True)
+
+        return report
+
+    def stop_cron_loop(self) -> None:
+        self._cron_stop.set()
+        if self._cron_thread and self._cron_thread.is_alive():
+            self._cron_thread.join(timeout=5)
+        self._cron_thread = None
+
+    def shutdown(self) -> None:
+        # Stop background review
+        try:
+            from runtime.orchestration.background_review import stop_background_review_thread
+            stop_background_review_thread()
+        except Exception:
+            pass
+        self.stop_cron_loop()
+        if self._orchestrator is not None:
+            self._orchestrator.shutdown()
+            self._orchestrator = None
+        if self._runtime_factory is not None:
+            self._runtime_factory.close()
+            self._runtime_factory = None
+        self._cron_system = None
+        self._services.clear()

package/application/contracts/__init__.py

@@ -0,0 +1,5 @@
+"""Application Service 公开返回契约。"""
+
+from application.contracts.result import AppResult, ServiceResult
+
+__all__ = ["AppResult", "ServiceResult"]