Host 组件：从混乱到秩序的多Agent系统总指挥

大家好，我是程序员小策。

你有没有遇到过这种情况：一个项目刚开始很简单，就几个类互相调用，但随着功能越来越多，代码开始变得像一团乱麻？今天要聊的这个 Host 组件 ，就是 LoreSmith 小说创作系统中用来解决这个问题的"总指挥"。它不亲自写代码、不调 LLM，但它把整个系统的复杂性给封装了起来，让外部调用者只需要跟它打交道。

灵魂拷问：如果一个多 Agent 系统有 11 个工具、4 种生命周期状态、3 层异步队列，你会怎么管理？是让每个模块自己暴露接口，还是找一个"店长"统一协调？

一、问题定义：为什么需要 Host？

1.1 系统复杂度爆炸

先看一眼 LoreSmith 的架构（简化版）：

复制代码

前端 (React)
  ↓ HTTP
Java Platform (Spring Boot) ← 平台层：故事管理、用户鉴权
  ↓ 内部调用
Python Runtime (FastAPI)
  ├── RunService        ← 业务服务层
  ├── WorkerManager     ← 后台任务消费者
  ├── Host              ←  今天的主角！
  │   ├── Config        ← 配置管理（多模型、多服务商）
  │   ├── Store         ← 持久化层（文件存储）
  │   └── CoordinatorLoop ← LangGraph 状态机编排
  │       ├── AgentRunner (含 11 个工具)
  │       └── LangGraphRuntime (状态机节点)
  └── Tools             ← 业务工具集
      ├── plan_chapter / draft_chapter / commit_chapter
      ├── check_consistency / review / rewrite
      └── save_summary / save_foundation ...

看到没？如果每个组件都直接对外暴露接口，那 RunService 和 WorkerManager 就得同时跟 Config、Store、CoordinatorLoop、事件队列、检查点系统 打交道。这就像一个新员工入职，HR 让他分别去找财务领电脑、找行政办门禁、找 IT 配置邮箱...效率极低还容易出错。

1.2 没有 Host 的代码长什么样？

让我们直接看代码------假设 LoreSmith 不用 Host ，RunService.create_run() 会变成什么样子：

python 复制代码

#  没有 Host：RunService.create_run() 的噩梦版本

class RunServiceWithoutHost:
    def create_run(self, req: CreateRunRequest) -> RunSession:
        prompt = req.input.prompt.strip()
        if not prompt:
            raise ApiError("INVALID_ARGUMENT", "prompt is required", 400)
        
        # ===== 第1步：手动构建配置（Host.__init__ 的步骤1） =====
        cfg = Config(
            output_dir=self._resolve_output_dir(req),
            provider=req.execution.provider or "openai",
            model=req.execution.model or "gpt-4o-mini",
            providers={req.execution.provider: ProviderConfig(api_key="dummy-key")},
            style=req.story.style or "default",
            context_window=req.execution.context_window or 128000,
        )
        cfg.fill_defaults()
        cfg.validate_base()  # 验证 API Key
        
        # ===== 第2步：手动初始化存储系统（Host.__init__ 的步骤2） =====
        store = Store(cfg.output_dir)
        store.init()
        store.run_meta.init(cfg.style, cfg.provider, cfg.model)
        
        # ===== 第3步：手动构建协调器循环（Host.__init__ 的步骤3） =====
        # 先构建工具注册表
        tools = build_tool_registry(store)
        runner = AgentRunner(tools)
        # 再构建 LangGraph 运行时
        langgraph = LangGraphRuntime(cfg, runner, store, emit_event, emit_stream)
        loop = CoordinatorLoop(langgraph)
        
        # ===== 第4步：手动创建事件队列（Host.__init__ 的步骤4） =====
        events = asyncio.Queue(maxsize=100)
        stream_ch = asyncio.Queue(maxsize=256)
        clear_ch = asyncio.Queue(maxsize=4)
        done_ch = asyncio.Queue(maxsize=4)
        
        # ===== 第5步：手动管理生命周期状态（Host.__init__ 的步骤5） =====
        lifecycle = "idle"
        
        # ===== 第6步：还得把这些零散的东西打包塞进 session =====
        session = RunSession(
            run_id=req.run_id,
            story_id=req.story.story_id or req.run_id,
            output_dir=cfg.output_dir,
            # 问题来了：session 里要存 cfg、store、loop、4个队列、lifecycle？
            # 这些本来都属于 Host 的内部状态，现在全部暴露给 session
            cfg=cfg,
            store=store,
            loop=loop,
            events=events,
            stream_ch=stream_ch,
            clear_ch=clear_ch,
            done_ch=done_ch,
            lifecycle=lifecycle,
            last_operation="create",
        )
        return session


# 有 Host：RunService.create_run() 的实际代码
class RunService:
    def create_run(self, req: CreateRunRequest) -> RunSession:
        existing = self.registry.get(req.run_id)
        if existing is not None:
            return existing
        prompt = (req.input.prompt or "").strip()
        if not prompt:
            raise ApiError("INVALID_ARGUMENT", "prompt is required", 400)
        cfg = self._build_config(req)
        host = Host(cfg)                    # ← 6步初始化全部封装在这里！
        self._seed_story_context(host, req) # ← 直接操作 host.store
        session = RunSession(
            run_id=req.run_id,
            story_id=req.story.story_id or req.run_id,
            output_dir=cfg.output_dir,
            cfg=cfg,
            host=host,                       # ← 整个系统就这一个入口！
            last_operation="create",
        )
        self.registry.put(session)
        self.registry.put_task(RunTask(...))
        return session

对比很直观 ：没有 Host 的版本需要 30+ 行初始化代码，而且把 Config、Store、4个队列、lifecycle 全部暴露给了外面的 RunSession。任何调用 RunSession 的代码都可能不小心修改这些内部状态。有了 Host 之后，一行 Host(cfg) 搞定全部初始化，外部只能通过 Host 提供的公开方法交互。

1.3 核心痛点

痛点	描述	影响
状态管理混乱	创作流程有 idle/running/completed/paused 四种状态，每种状态下允许的操作不同	容易出现非法操作（如运行中重复启动）
子系统耦合严重	外部代码需要知道如何初始化 Config、Store、CoordinatorLoop	改一个初始化逻辑，要改 N 个调用处
事件通信复杂	有 4 个异步队列（events/stream_ch/clear_ch/done_ch），外部不知道该消费哪个	前端对接困难，容易漏事件
生命周期不可控	创建 → 运行 → 暂停 → 恢复 → 完成，整个链路缺乏统一入口	资源泄漏、状态不一致

这就是 Host 要解决的问题：用门面模式（Facade Pattern）封装所有内部细节，对外提供统一的高层 API。

二、核心概念 + 类比

2.1 什么是 Host？

Host（主机控制器） 是 LoreSmith 系统的核心控制器，相当于一家"小说创作工作室"的店长。它不亲自写作，但负责：

招聘团队（初始化子系统的配置）

分配任务（调度 CoordinatorLoop 执行创作）

监控进度（通过 report()/snapshot() 返回状态）

处理客户需求（接收 start/resume/steer/abort 指令）

想象你要开一家餐厅：

没有 Host：顾客（前端）得自己去厨房找厨师点菜（调 CoordinatorLoop），去仓库拿食材（调 Store），去财务结账（管 lifecycle）...乱成一锅粥。
有 Host：顾客只需要告诉店长"我要一份宫保鸡丁"，店长自动安排厨师做菜、通知服务员上菜、记录账单。顾客完全不需要知道后厨有几个灶台、食材放在哪个货架。

2.2 设计模式识别

Host 综合运用了三种经典设计模式：
#mermaid-svg-gOIsRQq1lI87PECb{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-gOIsRQq1lI87PECb .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-gOIsRQq1lI87PECb .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-gOIsRQq1lI87PECb .error-icon{fill:#552222;}#mermaid-svg-gOIsRQq1lI87PECb .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-gOIsRQq1lI87PECb .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-gOIsRQq1lI87PECb .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-gOIsRQq1lI87PECb .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-gOIsRQq1lI87PECb .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-gOIsRQq1lI87PECb .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-gOIsRQq1lI87PECb .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-gOIsRQq1lI87PECb .marker{fill:#333333;stroke:#333333;}#mermaid-svg-gOIsRQq1lI87PECb .marker.cross{stroke:#333333;}#mermaid-svg-gOIsRQq1lI87PECb svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-gOIsRQq1lI87PECb p{margin:0;}#mermaid-svg-gOIsRQq1lI87PECb .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-gOIsRQq1lI87PECb .cluster-label text{fill:#333;}#mermaid-svg-gOIsRQq1lI87PECb .cluster-label span{color:#333;}#mermaid-svg-gOIsRQq1lI87PECb .cluster-label span p{background-color:transparent;}#mermaid-svg-gOIsRQq1lI87PECb .label text,#mermaid-svg-gOIsRQq1lI87PECb span{fill:#333;color:#333;}#mermaid-svg-gOIsRQq1lI87PECb .node rect,#mermaid-svg-gOIsRQq1lI87PECb .node circle,#mermaid-svg-gOIsRQq1lI87PECb .node ellipse,#mermaid-svg-gOIsRQq1lI87PECb .node polygon,#mermaid-svg-gOIsRQq1lI87PECb .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-gOIsRQq1lI87PECb .rough-node .label text,#mermaid-svg-gOIsRQq1lI87PECb .node .label text,#mermaid-svg-gOIsRQq1lI87PECb .image-shape .label,#mermaid-svg-gOIsRQq1lI87PECb .icon-shape .label{text-anchor:middle;}#mermaid-svg-gOIsRQq1lI87PECb .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-gOIsRQq1lI87PECb .rough-node .label,#mermaid-svg-gOIsRQq1lI87PECb .node .label,#mermaid-svg-gOIsRQq1lI87PECb .image-shape .label,#mermaid-svg-gOIsRQq1lI87PECb .icon-shape .label{text-align:center;}#mermaid-svg-gOIsRQq1lI87PECb .node.clickable{cursor:pointer;}#mermaid-svg-gOIsRQq1lI87PECb .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-gOIsRQq1lI87PECb .arrowheadPath{fill:#333333;}#mermaid-svg-gOIsRQq1lI87PECb .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-gOIsRQq1lI87PECb .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-gOIsRQq1lI87PECb .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-gOIsRQq1lI87PECb .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-gOIsRQq1lI87PECb .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-gOIsRQq1lI87PECb .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-gOIsRQq1lI87PECb .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-gOIsRQq1lI87PECb .cluster text{fill:#333;}#mermaid-svg-gOIsRQq1lI87PECb .cluster span{color:#333;}#mermaid-svg-gOIsRQq1lI87PECb div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-gOIsRQq1lI87PECb .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-gOIsRQq1lI87PECb rect.text{fill:none;stroke-width:0;}#mermaid-svg-gOIsRQq1lI87PECb .icon-shape,#mermaid-svg-gOIsRQq1lI87PECb .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-gOIsRQq1lI87PECb .icon-shape p,#mermaid-svg-gOIsRQq1lI87PECb .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-gOIsRQq1lI87PECb .icon-shape .label rect,#mermaid-svg-gOIsRQq1lI87PECb .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-gOIsRQq1lI87PECb .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-gOIsRQq1lI87PECb .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-gOIsRQq1lI87PECb :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 观察者模式 Observer
门面模式 Facade
emit_event
状态模式 State
idle
running
paused
completed
lifecycle
允许 start/resume
允许 abort/steer
允许 resume/continue
终态，不允许操作
外部调用者

RunService / WorkerManager
Host

统一入口
Config

配置管理
Store

持久化
CoordinatorLoop

状态机编排
CoordinatorLoop
events 队列
stream_ch 队列
持久化存储

三、代码实现：Host 的核心能力

3.1 初始化过程（"开店"流程）

看 host.py:139-211 的 __init__ 方法：

python 复制代码

class Host:
    def __init__(self, cfg: Config) -> None:
        # 步骤1: 配置准备
        cfg.fill_defaults()          # 补全缺失配置
        cfg.validate_base()          # 验证 API Key 等
        
        # 步骤2: 存储系统初始化
        self.store = Store(cfg.output_dir)
        self.store.init()            # 创建目录结构
        self.store.run_meta.init()   # 初始化元数据
        
        # 步骤3: 协调器循环构建（核心！）
        self.loop: CoordinatorLoop = build_coordinator_loop(
            self.cfg,
            self.store,
            emit_event=self._emit_event,      # ← 回调函数注入
            emit_stream=self._emit_stream_chunk,  # ← 回调函数注入
        )
        
        # 步骤4: 通信队列创建
        self.events: asyncio.Queue[Event] = asyncio.Queue(maxsize=100)
        self.stream_ch: asyncio.Queue[StreamChunk] = asyncio.Queue(maxsize=256)
        self.clear_ch: asyncio.Queue[bool] = asyncio.Queue(maxsize=4)
        self.done_ch: asyncio.Queue[bool] = asyncio.Queue(maxsize=4)
        
        # 步骤5: 状态初始化
        self.lifecycle = "idle"

关键设计点：

回调注入 ：通过 emit_event 和 emit_stream 回调，让内部的 CoordinatorLoop 能反向通知 Host 发生的事件（如工具调用、LLM 输出）
四个队列：不同类型的通信走不同的通道，解耦生产者和消费者

3.2 流程控制接口

Host 提供了 5 个核心操作方法（见 host.py:696-931）：

python 复制代码

# 1. 开始新创作
def start(self, prompt: str) -> None:
    """便捷方法，内部调用 start_prepared()"""
    self.start_prepared(build_start_prompt(prompt))

# 2. 从断点恢复
def resume(self) -> str:
    """自动读取进度，构建恢复 prompt"""
    prompt, label = build_resume_prompt(self.store)
    self.loop.resume(prompt)

# 3. 继续或追加内容
def continue_run(self, text: str) -> None:
    """支持两种场景：确认检查点 / 用户追加指令"""
    self.loop.follow_up(content)

# 4. 用户干预
def steer(self, text: str) -> None:
    """运行中立即生效 / 待命时保存到下次启动"""

# 5. 中止当前运行
def abort(self) -> bool:
    """优雅退出，不中断正在进行的 LLM 调用"""

状态转换图：
#mermaid-svg-Zxu0wh09no47pZET{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-Zxu0wh09no47pZET .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-Zxu0wh09no47pZET .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-Zxu0wh09no47pZET .error-icon{fill:#552222;}#mermaid-svg-Zxu0wh09no47pZET .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-Zxu0wh09no47pZET .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-Zxu0wh09no47pZET .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-Zxu0wh09no47pZET .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-Zxu0wh09no47pZET .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-Zxu0wh09no47pZET .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-Zxu0wh09no47pZET .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-Zxu0wh09no47pZET .marker{fill:#333333;stroke:#333333;}#mermaid-svg-Zxu0wh09no47pZET .marker.cross{stroke:#333333;}#mermaid-svg-Zxu0wh09no47pZET svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-Zxu0wh09no47pZET p{margin:0;}#mermaid-svg-Zxu0wh09no47pZET defs #statediagram-barbEnd{fill:#333333;stroke:#333333;}#mermaid-svg-Zxu0wh09no47pZET g.stateGroup text{fill:#9370DB;stroke:none;font-size:10px;}#mermaid-svg-Zxu0wh09no47pZET g.stateGroup text{fill:#333;stroke:none;font-size:10px;}#mermaid-svg-Zxu0wh09no47pZET g.stateGroup .state-title{font-weight:bolder;fill:#131300;}#mermaid-svg-Zxu0wh09no47pZET g.stateGroup rect{fill:#ECECFF;stroke:#9370DB;}#mermaid-svg-Zxu0wh09no47pZET g.stateGroup line{stroke:#333333;stroke-width:1;}#mermaid-svg-Zxu0wh09no47pZET .transition{stroke:#333333;stroke-width:1;fill:none;}#mermaid-svg-Zxu0wh09no47pZET .stateGroup .composit{fill:white;border-bottom:1px;}#mermaid-svg-Zxu0wh09no47pZET .stateGroup .alt-composit{fill:#e0e0e0;border-bottom:1px;}#mermaid-svg-Zxu0wh09no47pZET .state-note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-svg-Zxu0wh09no47pZET .state-note text{fill:black;stroke:none;font-size:10px;}#mermaid-svg-Zxu0wh09no47pZET .stateLabel .box{stroke:none;stroke-width:0;fill:#ECECFF;opacity:0.5;}#mermaid-svg-Zxu0wh09no47pZET .edgeLabel .label rect{fill:#ECECFF;opacity:0.5;}#mermaid-svg-Zxu0wh09no47pZET .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-Zxu0wh09no47pZET .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-Zxu0wh09no47pZET .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-Zxu0wh09no47pZET .edgeLabel .label text{fill:#333;}#mermaid-svg-Zxu0wh09no47pZET .label div .edgeLabel{color:#333;}#mermaid-svg-Zxu0wh09no47pZET .stateLabel text{fill:#131300;font-size:10px;font-weight:bold;}#mermaid-svg-Zxu0wh09no47pZET .node circle.state-start{fill:#333333;stroke:#333333;}#mermaid-svg-Zxu0wh09no47pZET .node .fork-join{fill:#333333;stroke:#333333;}#mermaid-svg-Zxu0wh09no47pZET .node circle.state-end{fill:#9370DB;stroke:white;stroke-width:1.5;}#mermaid-svg-Zxu0wh09no47pZET .end-state-inner{fill:white;stroke-width:1.5;}#mermaid-svg-Zxu0wh09no47pZET .node rect{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-Zxu0wh09no47pZET .node polygon{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-Zxu0wh09no47pZET #statediagram-barbEnd{fill:#333333;}#mermaid-svg-Zxu0wh09no47pZET .statediagram-cluster rect{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-Zxu0wh09no47pZET .cluster-label,#mermaid-svg-Zxu0wh09no47pZET .nodeLabel{color:#131300;}#mermaid-svg-Zxu0wh09no47pZET .statediagram-cluster rect.outer{rx:5px;ry:5px;}#mermaid-svg-Zxu0wh09no47pZET .statediagram-state .divider{stroke:#9370DB;}#mermaid-svg-Zxu0wh09no47pZET .statediagram-state .title-state{rx:5px;ry:5px;}#mermaid-svg-Zxu0wh09no47pZET .statediagram-cluster.statediagram-cluster .inner{fill:white;}#mermaid-svg-Zxu0wh09no47pZET .statediagram-cluster.statediagram-cluster-alt .inner{fill:#f0f0f0;}#mermaid-svg-Zxu0wh09no47pZET .statediagram-cluster .inner{rx:0;ry:0;}#mermaid-svg-Zxu0wh09no47pZET .statediagram-state rect.basic{rx:5px;ry:5px;}#mermaid-svg-Zxu0wh09no47pZET .statediagram-state rect.divider{stroke-dasharray:10,10;fill:#f0f0f0;}#mermaid-svg-Zxu0wh09no47pZET .note-edge{stroke-dasharray:5;}#mermaid-svg-Zxu0wh09no47pZET .statediagram-note rect{fill:#fff5ad;stroke:#aaaa33;stroke-width:1px;rx:0;ry:0;}#mermaid-svg-Zxu0wh09no47pZET .statediagram-note rect{fill:#fff5ad;stroke:#aaaa33;stroke-width:1px;rx:0;ry:0;}#mermaid-svg-Zxu0wh09no47pZET .statediagram-note text{fill:black;}#mermaid-svg-Zxu0wh09no47pZET .statediagram-note .nodeLabel{color:black;}#mermaid-svg-Zxu0wh09no47pZET .statediagram .edgeLabel{color:red;}#mermaid-svg-Zxu0wh09no47pZET #dependencyStart,#mermaid-svg-Zxu0wh09no47pZET #dependencyEnd{fill:#333333;stroke:#333333;stroke-width:1;}#mermaid-svg-Zxu0wh09no47pZET .statediagramTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-Zxu0wh09no47pZET :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 创建 Host 实例
start() / resume()
abort()
所有章节写完
检查点暂停机制触发
resume() / continue_run()
超时未恢复
终态
Idle
Running
Paused
Completed
允许操作：abort() / steer()
允许操作：resume() / continue_run()

3.3 数据报告接口

Host 还提供了三个数据查询方法，供 API 层和前端使用：

python 复制代码

def report(self) -> dict[str, object]:
    """
    返回结构化状态数据（供后端/API 使用）
    
    包含：
    - 配置信息（provider/model/style）
    - 进度信息（completed_chapters/current_chapter/total_word_count）
    - 状态标记（latest_checkpoint/awaiting_confirmation）
    """

def snapshot(self) -> UISnapshot:
    """
    返回 UI 快照数据（供前端展示）
    
    比 report() 更丰富，包含：
    - 故事前提、大纲预览、角色列表
    - 最近章节摘要、评审结果
    - 上下文 Token 使用量估算
    """

def replay_queue(self, after_seq: int) -> list[RuntimeQueueItem]:
    """
    重放持久化事件队列（用于 SSE 断线重连）
    
    从磁盘读取完整历史，不受内存队列大小限制
    """

四、多场景对比：没有 Host vs 有 Host

光说理论不够直观，下面用 5 个真实业务场景 来对比"裸调子系统"和"通过 Host 统一调用"的差异。

场景一：启动创作任务（最核心场景）

需求： 用户提交了一个创作请求，系统需要创建运行实例并开始创作。

这个场景涉及 配置初始化、存储初始化、协调器构建、事件队列创建、状态管理、生命周期控制 共 6 个步骤。

python 复制代码

# ============================================================
#  场景一：没有 Host------WorkerManager._execute() 的 start 分支
# ============================================================

class WorkerManagerWithoutHost:
    def _execute(self, task: RunTask) -> None:
        session = self.registry.get(task.run_id)
        task.status = "running"
        task.started_at = utcnow()
        self.registry.persist_task(task)

        try:
            if task.op == "start":
                prompt = str(task.payload.get("prompt", "") or "")
                
                # --- 步骤1：手动重置环境状态 ---
                session.store.runtime.reset()           # 清空事件历史
                session.store.progress.init("", 0)       # 初始化进度
                session.store.signals.clear_pending_commit()  # 清除待提交信号
                session.store.signals.clear_stale_signals()    # 清除过期信号
                session.store.checkpoints.reset()             # 重置检查点
                
                # --- 步骤2：手动管理生命周期 ---
                if session.lifecycle == "running":
                    raise ValueError("already running")  # ← 状态检查分散各处
                session.lifecycle = "running"
                
                # --- 步骤3：手动发射事件 ---
                ev = Event(time=datetime.now(), category="SYSTEM", 
                          summary="开始创作", level="info")
                session._safe_put(session.events, ev)    # ← 直接操作内部队列！
                session._safe_put(session.clear_ch, True) # ← 清空信号
                
                # --- 步骤4：手动启动协调器 ---
                # 还要先构建 prompt...
                full_prompt = build_start_prompt(prompt)
                session.loop.start(full_prompt)          # ← 直接调内部 loop！
                session.loop.wait_idle()
                
                # --- 步骤5：手动收尾 ---
                progress = session.store.progress.load()
                if progress and progress.phase == Phase.COMPLETE:
                    session.lifecycle = "completed"
                    session._safe_put(session.events, 
                        Event(time=datetime.now(), category="SYSTEM", 
                              summary="创作完成", level="success"))
                elif session.store.signals.load_pending_checkpoint() is not None:
                    session.lifecycle = "paused"
                    session._safe_put(session.events,
                        Event(time=datetime.now(), category="SYSTEM",
                              summary="等待用户确认继续编写", level="info"))
                else:
                    session.lifecycle = "idle"
                    session._safe_put(session.events,
                        Event(time=datetime.now(), category="SYSTEM",
                              summary="Coordinator 停止", level="warn"))
                session._safe_put(session.done_ch, True)

            # session.state_override 检查、task 状态更新...还有一大堆

        except Exception as exc:
            task.status = "failed"
            task.error = str(exc)
        finally:
            task.finished_at = utcnow()
            self.registry.persist(session)
            self.registry.persist_task(task)


# ============================================================
#  场景一：有 Host------WorkerManager._execute() 的真实代码   
# ============================================================

class WorkerManager:
    def _execute(self, task: RunTask) -> None:
        session = self.registry.get(task.run_id)
        task.status = "running"
        task.started_at = utcnow()
        self.registry.persist_task(task)
        session.last_operation = task.op
        self.registry.persist(session)

        try:
            if task.op == "start":
                prompt = str(task.payload.get("prompt", "") or "")
                session.host.start_prepared(prompt)  # ← 就这一行！
                # 内部自动完成：环境重置 + 状态切换 + 事件发射 + 启动循环 + 收尾

            # ...其他操作同样简洁

        except Exception as exc:
            if session.state_override != "canceled":
                session.last_error_code = "INTERNAL_ERROR"
                session.last_error_message = str(exc)
                session.state_override = "failed"
            task.status = "failed"
            task.error = str(exc)
        finally:
            task.finished_at = utcnow()
            if session.host.lifecycle == "completed":
                session.finished_at = utcnow()
            self.registry.persist(session)
            self.registry.persist_task(task)

差异一目了然 ：没有 Host 的 start 分支需要 ~35 行 手动管理环境、状态、事件、收尾，而且每行都在操作 session 的内部字段（session.lifecycle、session.loop、session.events...）。有 Host 之后，一行 host.start_prepared(prompt) 全部搞定，外部代码完全不需要知道内部有队列、生命周期、检查点这些概念。

场景二：暂停创作（abort）

需求： 用户点击"暂停"按钮，系统需要优雅地停止正在进行的创作。

python 复制代码

# ============================================================
#  场景二：没有 Host------pause_run() 的实现
# ============================================================

class RunServiceWithoutHost:
    def pause_run(self, run_id: str) -> RunSession:
        session = self.get_run(run_id)
        
        # --- 手动检查状态 ---
        if session.lifecycle != "running":
            return session  # 不在运行中，无需暂停
        
        # --- 直接修改内部状态 ---
        session.lifecycle = "paused"
        
        # --- 直接操作 loop ---
        session.loop.abort()  # 设置中止标志，让循环在下一个步骤退出
        
        # --- 手动发送事件 ---
        ev = Event(time=datetime.now(), category="SYSTEM",
                   summary="用户手动暂停当前创作", level="warn")
        session._safe_put(session.events, ev)
        
        # --- 手动发送完成信号 ---
        session._safe_put(session.done_ch, True)
        
        session.last_operation = "pause"
        self.registry.persist(session)
        return session


# ============================================================
#  场景二：有 Host------pause_run() 的真实代码
# ============================================================

class RunService:
    def pause_run(self, run_id: str) -> RunSession:
        session = self.get_run(run_id)
        session.last_operation = "pause"
        session.host.abort()  # ← 就这一行！Host.abort() 内部完成全部逻辑
        self.registry.persist(session)
        return session

关键差异 ：没有 Host 时，外部代码必须知道 session.lifecycle 的取值规则、session.loop.abort() 的含义、需要发什么事件、需要往 done_ch 塞信号。这些全部是 Host 的内部实现细节 。有 Host 之后，host.abort() 一行搞定------它内部已经实现了 4 步逻辑

场景三：从检查点恢复创作（resume）

需求： 之前暂停的创作需要恢复，系统要自动读取进度、检查断点状态、构建恢复 prompt。

python 复制代码

# ============================================================
#  场景三：没有 Host------resume_run() 的实现
# ============================================================

class WorkerManagerWithoutHost:
    def _execute(self, task: RunTask) -> None:
        # ...前置代码...
        try:
            if task.op == "resume":
                # --- 手动读取进度 ---
                progress = session.store.progress.load()
                if progress is None:
                    # 没有进度，无法恢复
                    task.status = "failed"
                    task.error = "no progress found"
                    return
                if progress.phase == Phase.COMPLETE:
                    # 已经完成，不需要恢复
                    return
                
                # --- 手动构建恢复 prompt（50+ 行的复杂逻辑！）---
                title = progress.novel_name.strip() or "当前小说"
                lines = [f"[恢复指令]", "", f"本书「{title}」"]
                
                completed = len(progress.completed_chapters)
                if completed > 0:
                    msg = f"已完成 {completed} 章"
                    if progress.total_chapters > 0:
                        msg += f"（共 {progress.total_chapters} 章）"
                    msg += f"，共 {progress.total_word_count} 字。"
                    lines[-1] += msg

                label = "恢复"
                # 还要判断 phase 是 PREMISE / OUTLINE / WRITING...
                # 还要判断 pending_checkpoint / pending_commit / pending_rewrites...
                # 还要读取 meta.pending_steer...
                # ...此处省略 40 行分支判断代码...
                
                prompt = "\n".join(lines)
                
                # --- 手动状态检查 ---
                if session.lifecycle == "running":
                    raise ValueError("already running")
                session.lifecycle = "running"
                
                # --- 手动发射事件 ---
                session._safe_put(session.events,
                    Event(time=datetime.now(), category="SYSTEM",
                          summary=f"恢复创作: {label}", level="info"))
                
                # --- 手动执行恢复 ---
                session.loop.resume(prompt)
                session.loop.wait_idle()
                
                # --- 手动收尾（和场景一的收尾逻辑重复！）---
                # ...重复的状态判断和事件发送...


# ============================================================
#  场景三：有 Host------WorkerManager._execute() 的 resume 分支
# ============================================================

class WorkerManager:
    def _execute(self, task: RunTask) -> None:
        # ...前置代码...
        try:
            if task.op == "resume":
                prompt = str(task.payload.get("prompt", "") or "")
                if prompt:
                    session.host.continue_run(prompt)  # ← 带新指令
                else:
                    session.host.resume()              # ← 自动读断点！
                    # Host.resume() 内部自动完成：
                    #   1. 读取 progress
                    #   2. 调用 build_resume_prompt()（来自 resume.py）
                    #   3. 判断 phase / checkpoint / pending 状态
                    #   4. 设置 lifecycle
                    #   5. 发射恢复事件
                    #   6. 调用 loop.resume()
                    #   7. 等待并收尾

这里是最能体现 Host 价值的地方！ build_resume_prompt() 包含 70+ 行的分支判断逻辑（见 resume.py），涉及 6 种不同的恢复场景。如果没有 Host 封装，这些逻辑会散布在 WorkerManager._execute() 中，不仅代码膨胀，而且每次新增恢复场景都要改 WorkerManager。

场景四：动态切换 LLM 模型

需求： 用户在创作过程中想换一个更强的模型（比如从 DeepSeek 换到 GPT-4），系统需要重建整个协调器循环。

python 复制代码

# ============================================================
#  场景四：没有 Host------switch_model() 的实现
# ============================================================

class RunServiceWithoutHost:
    def switch_model(self, run_id: str, role: str, provider: str, model: str) -> None:
        session = self.get_run(run_id)
        
        # --- 手动校验 ---
        if not provider or not model:
            raise ValueError("provider and model are required")
        if provider not in session.cfg.providers:
            raise ValueError(f"provider {provider} is not configured")
        
        # --- 手动修改配置 ---
        if role and role != "default":
            rc = session.cfg.roles.get(role)
            if rc is None:
                raise ValueError(f"role {role} is not configured")
            rc.provider = provider
            rc.model = model
            session.cfg.roles[role] = rc
        else:
            session.cfg.provider = provider
            session.cfg.model = model
        
        # --- 手动重建协调器（最容易出错的步骤！）---
        # 需要知道 build_tool_registry 的内部逻辑
        tools = build_tool_registry(session.store)
        runner = AgentRunner(tools)
        # 还要手动把 emit_event / emit_stream 回调传进去
        langgraph = LangGraphRuntime(session.cfg, runner, session.store,
                                      emit_event=session._emit_event,
                                      emit_stream=session._emit_stream_chunk)
        session.loop = CoordinatorLoop(langgraph)
        #  问题：旧的 loop 正在运行怎么办？要 abort 吗？旧事件队列怎么处理？
        
        # --- 手动发送切换事件 ---
        session._safe_put(session.events,
            Event(time=datetime.now(), category="SYSTEM",
                  summary=f"模型已切换：{role or 'default'} -> {provider}/{model}",
                  level="info"))


# ============================================================
#  场景四：有 Host------switch_model() 的真实代码
# ============================================================

class Host:
    def switch_model(self, role: str, provider: str, model: str) -> None:
        if not provider or not model:
            raise ValueError("provider and model are required")
        if provider not in self.cfg.providers:
            raise ValueError(f"provider {provider} is not configured")
        
        # 修改配置（详细的角色级配置处理...）
        if role and role != "default":
            rc = self.cfg.roles.get(role)
            if rc is None:
                raise ValueError(f"role {role} is not configured")
            rc.provider = provider
            rc.model = model
            self.cfg.roles[role] = rc
        else:
            self.cfg.provider = provider
            self.cfg.model = model
        
        # 重建协调器（封装在 Host 内部，外部无需关心细节）
        self.loop = build_coordinator_loop(
            self.cfg, self.store,
            emit_event=self._emit_event,
            emit_stream=self._emit_stream_chunk,
        )
        # 自动发送事件
        self._emit_event(Event(time=datetime.now(), category="SYSTEM",
            summary=f"模型已切换：{role or 'default'} -> {provider}/{model}",
            level="info"))

关键风险 ：没有 Host 时，重建协调器循环需要外部代码知道 build_tool_registry()、AgentRunner()、LangGraphRuntime() 的构造参数。一旦这些内部实现发生变化（比如新增一个工具、修改回调签名），所有调用 switch_model 的地方都要同步修改。Host 把这一整套逻辑封装在 build_coordinator_loop() 调用中，外部完全无感知。

场景五：查询创作进度（report / snapshot）

需求： 前端需要展示当前创作进度（已完成章节、当前状态、上下文用量等），API 层需要返回结构化数据。

python 复制代码

# ============================================================
#  场景五：没有 Host------get_report() 的实现
# ============================================================

class RunServiceWithoutHost:
    def get_report(self, run_id: str):
        session = self.get_run(run_id)
        
        # --- 手动从各子系统收集数据 ---
        progress = session.store.progress.load()
        latest_cp = session.store.checkpoints.latest_global()
        last_commit = session.store.signals.load_last_commit()
        pending_checkpoint = session.store.signals.load_pending_checkpoint()
        
        # --- 手动计算当前章节 ---
        current_chapter = progress.current_chapter if progress else 0
        if pending_checkpoint is not None:
            current_chapter = pending_checkpoint.next_chapter
        
        # --- 手动组装报告 ---
        report = {
            "provider": session.cfg.provider,
            "model": session.cfg.model,
            "style": session.cfg.style,
            "lifecycle": session.lifecycle,  # ← 直接读 session 状态
            "output_dir": session.store.dir(),
            "completed_chapters": len(progress.completed_chapters) if progress else 0,
            "current_chapter": current_chapter,
            "total_word_count": progress.total_word_count if progress else 0,
            "flow": progress.flow if progress else "",
            "phase": progress.phase if progress else "",
            "latest_checkpoint": {
                "step": latest_cp.step,
                "scope": latest_cp.scope.kind,
                "seq": latest_cp.seq,
            } if latest_cp else None,
            "has_last_commit": bool(last_commit),
            "awaiting_confirmation": (
                self._pending_checkpoint_payload(pending_checkpoint) if pending_checkpoint else None
            ),
        }
        return session, report
    
    #  还要自己实现 _pending_checkpoint_payload...
    @staticmethod
    def _pending_checkpoint_payload(pending):
        if pending is None:
            return None
        return {
            "pause_after_chapter": pending.pause_after_chapter,
            "next_chapter": pending.next_chapter,
            "completed_count": pending.completed_count,
            "status": pending.status,
        }


# ============================================================
#  场景五：有 Host------get_report() 的真实代码
# ============================================================

class RunService:
    def get_report(self, run_id: str) -> tuple[RunSession, dict[str, object]]:
        session = self.get_run(run_id)
        report = session.host.report()  # ← 就这一行！
        return session, report

差异：没有 Host 的 get_report() 需要 25+ 行 代码手动拼装报告，而且直接访问了 session.store、session.cfg、session.lifecycle 等内部字段。有 Host 后，host.report() 一行搞定，返回完整的结构化字典（见 host.py:225-287）。同理，前端的 UI 快照也可以通过 host.snapshot() 一行获取。

五个场景代码量对比总结

场景	没有 Host 代码量	有 Host 代码量	减少比例
启动创作	~35 行	1 行 `host.start_prepared()`	97%
暂停创作	~15 行	1 行 `host.abort()`	93%
断点恢复	~55 行	1 行 `host.resume()`	98%
切换模型	~25 行	1 行调 `host.switch_model()`	96%
查询进度	~25 行	1 行 `host.report()`	96%

5 个场景，从 ~155 行降到 ~5 行，减少了 96% 的代码量。

更重要的是：减少的不仅是代码行数，更是认知负担 ------外部开发者不再需要理解 Store 的 API、lifecycle 的状态机、事件队列的管理方式、检查点的读取逻辑。他们只需要知道 Host 提供的 5 个高层方法即可。

五、分布式考量：异步与并发

5.1 为什么用 asyncio.Queue？

Host 维护了 4 个异步队列：

python 复制代码

self.events: asyncio.Queue[Event] = asyncio.Queue(maxsize=100)      # 系统事件
self.stream_ch: asyncio.Queue[StreamChunk] = asyncio.Queue(maxsize=256)  # 流式输出
self.clear_ch: asyncio.Queue[bool] = asyncio.Queue(maxsize=4)        # 清空信号
self.done_ch: asyncio.Queue[bool] = asyncio.Queue(maxsize=4)         # 完成信号

为什么要用队列而不是直接回调？

方案	优点	缺点
同步回调	简单直观	阻塞 LLM 调用线程，吞吐量低
asyncio.Queue（本项目）	解耦生产/消费，支持背压	需要管理队列生命周期
消息队列（Redis/RabbitMQ）	支持分布式，持久化	引入外部依赖，复杂度高

选择 asyncio.Queue 的理由：

单进程内足够：Python Runtime 是单体应用，不需要跨进程通信
背压保护 ：_safe_put() 方法实现了三级降级策
内存可控：设置 maxsize 防止 OOM

5.2 _safe_put() 的背压保护机制

这是 Host 中最精巧的设计之一：

python 复制代码

@staticmethod
def _safe_put(queue: asyncio.Queue, value: object) -> None:
    """
    三级降级策略：
    
    Level 1: 尝试正常放入
    Level 2: 队列满了 → 丢弃最旧的元素
    Level 3: 还是放不下 → 静默丢弃
    """
    try:
        queue.put_nowait(value)                    # Level 1
    except asyncio.QueueFull:
        try:
            queue.get_nowait()                      # Level 2: 丢弃队首
        except Exception:
            pass
        try:
            queue.put_nowait(value)
        except Exception:
            pass                                    # Level 3: 放弃

为什么这样设计？

LLM 生成速度 >> 前端消费速度 → 内存队列堆积 → OOM 崩溃
对于流式输出：丢中间的 token 比崩掉好
对于事件：丢旧事件比丢新事件好

六、对比表格：Host vs 其他方案

6.1 架构方案对比

维度	无 Host（裸调子系统）	Host（门面模式）	微内核架构
复杂度	高（调用者需了解所有子系统）	低（统一 API）	中（需理解插件机制）
扩展性	差（改一处动全身）	好（新增功能只需改 Host）	最好（热插拔插件）
测试难度	高（需要 Mock 多个依赖）	低（Mock Host 即可）	中（需 Mock 内核）
性能损耗	无	极小（一层间接调用）	小（插件加载开销）
适用场景	简单项目	中大型项目（推荐）	需要动态扩展的系统

6.2 Host 在同类项目中的位置

项目	类似角色	设计差异
LangChain	`Chain` 对象	更轻量，无生命周期管理
AutoGPT	`Agent` 类	专注单 Agent 循环，无多工具协调
CrewAI	`Crew` 类似	强调多 Agent 协作，弱化状态管理
LoreSmith Host	总控制器	强调生命周期 + 事件系统 + 断点恢复

七、面试追问：如果让你重构 Host？

Q1：Host 是否违反了单一职责原则（SRP）？

A：表面上看 Host 做了很多事（生命周期、事件、报告、流控），但实际上它的职责是统一的：作为子系统的协调者。这符合 SRP 的"一个类只有一个变化的原因"------Host 变化的唯一原因是"子系统协调方式变了"。

如果你觉得 Host 太重，可以拆分：

LifecycleManager：只管状态转换
EventEmitter：只管事件发射
Reporter：只管数据查询

但这样会增加调用者的负担，需要在简洁性 和纯粹性之间权衡。

Q2：Host 的线程安全性如何保证？

A： Host 本身不是线程安全的，但通过以下机制实现了安全通信：

asyncio.Queue：线程安全的队列，用于跨线程数据传递
WorkerManager 单线程消费：避免并发修改 Host 状态
lifecycle 状态检查 ：start() 方法会检查 if self.lifecycle == "running" 防止重复启动

如果未来需要多线程并发操作 Host，可以加一把 threading.RLock。

Q3：能否用协程替代 threading.Thread 来实现 WorkerManager？

A：可以，但需要注意：

当前 Python Runtime 用的是 FastAPI（基于 asyncio），理论上应该用协程
但 loop.start() 是阻塞调用（会等待整个创作循环结束）
如果用协程，需要 await asyncio.to_thread(host.start) 或改造为异步版本
目前的 threading 方案更简单，且不会阻塞 FastAPI 的事件循环

Q4：Host 的 event/store 双写机制有什么优缺点？

A： Host 的 _emit_event() 方法会同时写入内存队列和磁盘存储：

python 复制代码

def _emit_event(self, ev: Event) -> None:
    self._safe_put(self.events, ev)                    # 写入内存（实时消费）
    self._append_runtime_item(...)                      # 写入磁盘（持久化）

优点：

支持 SSE 断线重连（从磁盘恢复历史事件）
方便调试和审计（事后查看完整日志）

缺点：

双写有一定性能开销（I/O 操作）
磁盘写入失败不影响内存队列（最终一致性）

优化方向：

可以用批量写入减少 I/O 次数
或者引入 WAL（Write-Ahead Log）机制

八、总结：Host 的核心价值

8.1 问题与方案对照表

回顾全文，Host 解决的每一个问题都有清晰的对应方案：

问题	❌ 没有 Host 的做法	✅ Host 的解决方案	量化收益
子系统初始化复杂	每次调用都要手动创建 Config → Store → AgentRunner → LangGraphRuntime → 4 个 Queue（~30行）	`Host(cfg)` 构造函数一站式完成	减少 97% 初始化代码
状态管理混乱	lifecycle 标志散落在 session、WorkerManager、RunService 各处	`self.lifecycle` 字段 + 4 态状态机统一管理	消除状态不一致 bug
启动流程繁琐	手动重置环境 → 手动发射事件 → 手动启动循环 → 手动收尾（~35行）	`host.start_prepared(prompt)` 一行	减少 97% 业务代码
事件通信困难	外部直接操作 `session.events` / `session.stream_ch` 等内部队列	4 个 asyncio.Queue + `_safe_put()` 背压保护，外部无感知	解耦生产者和消费者
断点恢复复杂	手动读取 progress → 判断 phase/checkpoint/pending 等 6 种状态 → 手动构建 prompt（~55行）	`host.resume()` 一行，内部自动调用 `build_resume_prompt()`	减少 98% 业务代码
模型切换危险	手动改 cfg → 手动重建 AgentRunner → 手动重建 LangGraphRuntime（~25行）	`host.switch_model(role, provider, model)` 一行	消除遗漏重建步骤的风险
进度查询分散	手动从 store.progress / store.checkpoints / store.signals 组装数据（~25行）	`host.report()` / `host.snapshot()` 结构化输出	统一数据出口
前端对接困难	无法确定该从哪个队列读数据、如何解析事件格式	`replay_queue()` 支持 SSE 断线重连	前端只需消费一份数据流

8.2 核心设计原则

一句话总结：Host 是多 Agent 系统的"操作系统"，它让复杂的 AI 创作流程变得像调用一个函数一样简单。

记住一个原则：当你的系统超过 3 个子系统互相调用时，就该考虑引入门面模式了。 不是因为这样更酷，而是因为你不想在 3 个月后面对一堆纠缠不清的依赖关系而崩溃。

8.3 什么时候不需要 Host？

门面模式虽好，但不是万能药。以下场景不需要引入 Host 级别的封装：

场景	原因
只有 1-2 个子系统	引入 Host 是过度设计，直接调用更简洁
子系统频繁独立变化	Host 会成为变更瓶颈，需要频繁适配
性能敏感的路径	多一层间接调用有微小开销（本项目可忽略）
需要细粒度控制	Host 隐藏了细节，如果外部确实需要精细控制就不合适

对于 LoreSmith 这种 11 个工具 + 4 种状态 + 3 层队列 的复杂系统，Host 是恰如其分的抽象。