feihong-code 8.0.0 → 8.0.2

package/agent-team/core/models.py

@@ -0,0 +1,347 @@
+"""数据模型与 SQLite 数据访问层。
+
+对齐开发文档《统一协议与数据模型》：
+- leads          线索（含来源渠道、状态、分级、实时录入时间）
+- customers      客户（五列格式：公司名称 / 客户姓名 / 联系电话 / 联系时间 / 备注）
+- content_assets 内容资产（选题 / 脚本 / 成片 / 文章）
+- tasks          任务（任务协议：状态、优先级、重试、人工确认、trace）
+
+所有写操作使用参数化 SQL，时间字段一律记录实时时间戳。
+"""
+import json
+import sqlite3
+import threading
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import config
+
+_lock = threading.Lock()
+
+SCHEMA = """
+CREATE TABLE IF NOT EXISTS leads (
+    lead_id        TEXT PRIMARY KEY,
+    source_channel TEXT NOT NULL,
+    company_name   TEXT DEFAULT '',
+    contact_name   TEXT DEFAULT '',
+    contact_phone  TEXT DEFAULT '',
+    status         TEXT DEFAULT 'new',
+    grade          TEXT DEFAULT 'C',
+    remark         TEXT DEFAULT '',
+    created_at     TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS customers (
+    customer_id   TEXT PRIMARY KEY,
+    company_name  TEXT DEFAULT '',
+    contact_name  TEXT DEFAULT '',
+    contact_phone TEXT DEFAULT '',
+    contact_time  TEXT DEFAULT '',
+    remark        TEXT DEFAULT '',
+    tier          TEXT DEFAULT 'untiered'
+);
+CREATE TABLE IF NOT EXISTS content_assets (
+    content_id     TEXT PRIMARY KEY,
+    content_type   TEXT DEFAULT '',
+    topic          TEXT DEFAULT '',
+    script         TEXT DEFAULT '',
+    asset_url      TEXT DEFAULT '',
+    publish_status TEXT DEFAULT 'draft',
+    metrics        TEXT DEFAULT '{}'
+);
+CREATE TABLE IF NOT EXISTS tasks (
+    task_id     TEXT PRIMARY KEY,
+    task_type   TEXT NOT NULL,
+    module_id   TEXT NOT NULL,
+    status      TEXT NOT NULL,
+    priority    TEXT DEFAULT 'P1',
+    input_json  TEXT DEFAULT '{}',
+    output_json TEXT DEFAULT '{}',
+    retry_count INTEGER DEFAULT 0,
+    need_human  INTEGER DEFAULT 0,
+    trace       TEXT DEFAULT '[]',
+    created_at  TEXT NOT NULL,
+    finished_at TEXT DEFAULT ''
+);
+CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status, priority, created_at);
+CREATE INDEX IF NOT EXISTS idx_leads_status ON leads(status);
+"""
+
+
+def utcnow() -> str:
+    """实时时间戳（本地时间，YYYY-MM-DD HH:MM:SS）。"""
+    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+
+def _connect(db_path: Optional[str] = None) -> sqlite3.Connection:
+    path = db_path or config.DB_PATH
+    Path(path).parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(path, check_same_thread=False)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA journal_mode=WAL;")
+    return conn
+
+
+def init_db(db_path: Optional[str] = None) -> None:
+    """初始化全部表结构（幂等）。"""
+    conn = _connect(db_path)
+    try:
+        with _lock:
+            conn.executescript(SCHEMA)
+            conn.commit()
+    finally:
+        conn.close()
+
+
+def _j(d: Any) -> str:
+    return json.dumps(d, ensure_ascii=False)
+
+
+def _uj(s: str) -> Any:
+    try:
+        return json.loads(s) if s else {}
+    except (TypeError, ValueError):
+        return {}
+
+
+# ---------------------------------------------------------------- leads
+def insert_lead(lead: Dict[str, str]) -> Dict[str, str]:
+    conn = _connect()
+    try:
+        with _lock:
+            conn.execute(
+                "INSERT INTO leads (lead_id, source_channel, company_name, contact_name,"
+                " contact_phone, status, grade, remark, created_at)"
+                " VALUES (?,?,?,?,?,?,?,?,?)",
+                (lead["lead_id"], lead.get("source_channel", ""), lead.get("company_name", ""),
+                 lead.get("contact_name", ""), lead.get("contact_phone", ""),
+                 lead.get("status", "new"), lead.get("grade", "C"),
+                 lead.get("remark", ""), utcnow()),
+            )
+            conn.commit()
+        return lead
+    finally:
+        conn.close()
+
+
+def list_leads(status: Optional[str] = None) -> List[Dict[str, str]]:
+    conn = _connect()
+    try:
+        if status:
+            rows = conn.execute("SELECT * FROM leads WHERE status=? ORDER BY created_at", (status,)).fetchall()
+        else:
+            rows = conn.execute("SELECT * FROM leads ORDER BY created_at").fetchall()
+        return [dict(r) for r in rows]
+    finally:
+        conn.close()
+
+
+def update_lead(lead_id: str, **fields: str) -> None:
+    if not fields:
+        return
+    conn = _connect()
+    try:
+        with _lock:
+            cols = ", ".join(f"{k}=?" for k in fields)
+            conn.execute(f"UPDATE leads SET {cols} WHERE lead_id=?", (*fields.values(), lead_id))
+            conn.commit()
+    finally:
+        conn.close()
+
+
+# ------------------------------------------------------------- customers
+def insert_customer(cust: Dict[str, str]) -> Dict[str, str]:
+    """客户五列格式入库：公司名称 / 客户姓名 / 联系电话 / 联系时间 / 备注。"""
+    conn = _connect()
+    try:
+        with _lock:
+            conn.execute(
+                "INSERT INTO customers (customer_id, company_name, contact_name,"
+                " contact_phone, contact_time, remark, tier) VALUES (?,?,?,?,?,?,?)",
+                (cust["customer_id"], cust.get("company_name", ""), cust.get("contact_name", ""),
+                 cust.get("contact_phone", ""), cust.get("contact_time", "") or utcnow(),
+                 cust.get("remark", ""), cust.get("tier", "untiered")),
+            )
+            conn.commit()
+        return cust
+    finally:
+        conn.close()
+
+
+def list_customers() -> List[Dict[str, str]]:
+    conn = _connect()
+    try:
+        return [dict(r) for r in conn.execute("SELECT * FROM customers ORDER BY contact_time").fetchall()]
+    finally:
+        conn.close()
+
+
+def upsert_customer(company_name: str = "", contact_name: str = "",
+                    contact_phone: str = "", remark: str = "",
+                    tier: str = "untiered", customer_id: Optional[str] = None,
+                    contact_time: Optional[str] = None) -> str:
+    """按联系电话查重：存在则更新联系时间/备注/分层，不存在则新增。返回 customer_id。"""
+    conn = _connect()
+    try:
+        with _lock:
+            if contact_phone:
+                row = conn.execute("SELECT customer_id FROM customers WHERE contact_phone=?",
+                                   (contact_phone,)).fetchone()
+            else:
+                row = None
+            if row:
+                cid = row["customer_id"]
+                now = contact_time or utcnow()
+                conn.execute(
+                    "UPDATE customers SET company_name=?, contact_name=?, remark=?, tier=?,"
+                    " contact_time=? WHERE customer_id=?",
+                    (company_name, contact_name, remark, tier, now, cid))
+            else:
+                cid = customer_id or f"C{int(datetime.now().timestamp())}"
+                now = contact_time or utcnow()
+                conn.execute(
+                    "INSERT INTO customers (customer_id, company_name, contact_name,"
+                    " contact_phone, contact_time, remark, tier) VALUES (?,?,?,?,?,?,?)",
+                    (cid, company_name, contact_name, contact_phone, now, remark, tier))
+            conn.commit()
+            return cid
+    finally:
+        conn.close()
+
+
+def update_customer(customer_id: str, **fields: str) -> None:
+    if not fields:
+        return
+    conn = _connect()
+    try:
+        with _lock:
+            cols = ", ".join(f"{k}=?" for k in fields)
+            conn.execute(f"UPDATE customers SET {cols} WHERE customer_id=?", (*fields.values(), customer_id))
+            conn.commit()
+    finally:
+        conn.close()
+
+
+# -------------------------------------------------------- content_assets
+def insert_asset(asset: Dict[str, Any]) -> Dict[str, Any]:
+    conn = _connect()
+    try:
+        with _lock:
+            conn.execute(
+                "INSERT INTO content_assets (content_id, content_type, topic, script,"
+                " asset_url, publish_status, metrics) VALUES (?,?,?,?,?,?,?)",
+                (asset["content_id"], asset.get("content_type", ""), asset.get("topic", ""),
+                 asset.get("script", ""), asset.get("asset_url", ""),
+                 asset.get("publish_status", "draft"), _j(asset.get("metrics", {}))),
+            )
+            conn.commit()
+        return asset
+    finally:
+        conn.close()
+
+
+def list_assets(content_type: Optional[str] = None) -> List[Dict[str, Any]]:
+    conn = _connect()
+    try:
+        if content_type:
+            rows = conn.execute("SELECT * FROM content_assets WHERE content_type=?", (content_type,)).fetchall()
+        else:
+            rows = conn.execute("SELECT * FROM content_assets").fetchall()
+        out = []
+        for r in rows:
+            d = dict(r)
+            d["metrics"] = _uj(d.get("metrics", "{}"))
+            out.append(d)
+        return out
+    finally:
+        conn.close()
+
+
+# ----------------------------------------------------------------- tasks
+def insert_task(task: Dict[str, Any]) -> Dict[str, Any]:
+    conn = _connect()
+    try:
+        with _lock:
+            conn.execute(
+                "INSERT INTO tasks (task_id, task_type, module_id, status, priority,"
+                " input_json, output_json, retry_count, need_human, trace, created_at, finished_at)"
+                " VALUES (?,?,?,?,?,?,?,?,?,?,?,?)",
+                (task["task_id"], task["task_type"], task["module_id"], task["status"],
+                 task.get("priority", "P1"), _j(task.get("input_json", {})),
+                 _j(task.get("output_json", {})), task.get("retry_count", 0),
+                 1 if task.get("need_human") else 0, _j(task.get("trace", [])),
+                 task.get("created_at", utcnow()), task.get("finished_at", "")),
+            )
+            conn.commit()
+        return task
+    finally:
+        conn.close()
+
+
+def get_task(task_id: str) -> Optional[Dict[str, Any]]:
+    conn = _connect()
+    try:
+        row = conn.execute("SELECT * FROM tasks WHERE task_id=?", (task_id,)).fetchone()
+        if not row:
+            return None
+        d = dict(row)
+        d["input_json"] = _uj(d.get("input_json", "{}"))
+        d["output_json"] = _uj(d.get("output_json", "{}"))
+        d["trace"] = _uj(d.get("trace", "[]"))
+        d["need_human"] = bool(d.get("need_human"))
+        return d
+    finally:
+        conn.close()
+
+
+def update_task(task_id: str, **fields: Any) -> None:
+    if not fields:
+        return
+    conn = _connect()
+    try:
+        with _lock:
+            cols = ", ".join(f"{k}=?" for k in fields)
+            vals = []
+            for v in fields.values():
+                if isinstance(v, (dict, list)):
+                    vals.append(_j(v))
+                else:
+                    vals.append(v)
+            conn.execute(f"UPDATE tasks SET {cols} WHERE task_id=?", (*vals, task_id))
+            conn.commit()
+    finally:
+        conn.close()
+
+
+def list_tasks(status: Optional[str] = None, module_id: Optional[str] = None) -> List[Dict[str, Any]]:
+    conn = _connect()
+    try:
+        sql, args = "SELECT * FROM tasks WHERE 1=1", []
+        if status:
+            sql += " AND status=?"
+            args.append(status)
+        if module_id:
+            sql += " AND module_id=?"
+            args.append(module_id)
+        sql += " ORDER BY created_at"
+        rows = conn.execute(sql, args).fetchall()
+        out = []
+        for r in rows:
+            d = dict(r)
+            d["input_json"] = _uj(d.get("input_json", "{}"))
+            d["output_json"] = _uj(d.get("output_json", "{}"))
+            d["trace"] = _uj(d.get("trace", "[]"))
+            d["need_human"] = bool(d.get("need_human"))
+            out.append(d)
+        return out
+    finally:
+        conn.close()
+
+
+def count_tasks() -> Dict[str, int]:
+    conn = _connect()
+    try:
+        rows = conn.execute("SELECT status, COUNT(*) AS c FROM tasks GROUP BY status").fetchall()
+        return {r["status"]: r["c"] for r in rows}
+    finally:
+        conn.close()

package/agent-team/core/scheduler.py

@@ -0,0 +1,150 @@
+"""11 调度官：任务创建、分派、状态机、重试、人工确认与告警。
+
+对齐开发文档《调度编排流程》：
+1. 接收触发：定时 / 事件 / 人工；
+2. 校验依赖（前置任务 success、数据就绪），不满足则 blocked 提示；
+3. 按优先级分派执行，全程记录 trace；
+4. 失败自动重试（上限 MAX_RETRY），超限转 blocked 并告警；
+   涉及对外动作（need_human）的任务执行后进入 awaiting_human，人工确认后 success。
+"""
+import logging
+import sys
+from typing import Any, Dict, List, Optional
+
+import config
+from core import models
+from core.agent import BaseAgent
+from core.task import Task, TaskStatus
+
+log = logging.getLogger("scheduler")
+
+
+class Scheduler:
+    def __init__(self, agents: Dict[str, BaseAgent]):
+        self.agents = agents
+        self.max_retry = config.MAX_RETRY
+
+    # ---------------------------------------------------------- 提交
+    def submit(self, module_id: str, task_type: str, input_data: Dict[str, Any],
+               priority: str = "P1", need_human: Optional[bool] = None,
+               task_id: Optional[str] = None) -> Task:
+        if module_id not in self.agents:
+            raise ValueError(f"未知模块编号: {module_id}（可用模块见 list-agents）")
+        agent = self.agents[module_id]
+        # 契约校验前置：尽早暴露输入错误
+        agent.validate_input(input_data)
+        human = agent.need_human if need_human is None else need_human
+        task = Task(task_type=task_type, module_id=module_id,
+                    input_json=input_data, priority=priority, need_human=human)
+        if task_id:
+            task.task_id = task_id
+        models.insert_task(task.to_dict())
+        log.info("已提交任务 %s -> %s(%s) pri=%s", task.task_id, module_id, task_type, priority)
+        return task
+
+    # ---------------------------------------------------------- 执行一轮
+    def run_once(self, limit: int = 10) -> List[Dict[str, Any]]:
+        """拉取 pending 任务（按优先级 + 创建时间），逐个分派执行。返回执行结果列表。"""
+        results: List[Dict[str, Any]] = []
+        rows = models.list_tasks(status=TaskStatus.PENDING.value)
+        rows.sort(key=lambda r: ({"P0": 0, "P1": 1, "P2": 2, "P3": 3}.get(r["priority"], 1), r["created_at"]))
+        for row in rows[:limit]:
+            results.append(self._dispatch(Task.from_dict(row)))
+        return results
+
+    def _dispatch(self, task: Task) -> Dict[str, Any]:
+        agent = self.agents.get(task.module_id)
+        if agent is None:
+            self._fail(task, f"模块 {task.module_id} 未注册")
+            return {"task_id": task.task_id, "status": task.status.value, "error": "模块未注册"}
+
+        try:
+            task.transition(TaskStatus.RUNNING)
+            task.append_trace("dispatch", f"module={task.module_id}")
+            models.update_task(task.task_id, status=task.status.value, trace=task.trace)
+
+            output = agent.execute(task)
+
+            task.output_json = output
+            task.append_trace("executed", "ok")
+            # 结果落库（失败视为任务失败，走重试）
+            agent.persist(output, task)
+            task.append_trace("persisted", "ok")
+            if task.need_human:
+                task.transition(TaskStatus.AWAITING_HUMAN)
+                task.append_trace("human_gate", "等待人工确认")
+            else:
+                task.transition(TaskStatus.SUCCESS)
+            models.update_task(task.task_id, status=task.status.value, output_json=task.output_json,
+                               trace=task.trace, finished_at=task.finished_at)
+            log.info("任务 %s 完成 -> %s", task.task_id, task.status.value)
+            return {"task_id": task.task_id, "status": task.status.value}
+        except Exception as e:  # noqa: BLE001 业务异常统一转失败
+            log.warning("任务 %s 执行异常: %s", task.task_id, e)
+            self._fail(task, str(e))
+            return {"task_id": task.task_id, "status": task.status.value, "error": str(e)}
+
+    def _fail(self, task: Task, reason: str) -> None:
+        task.retry_count += 1
+        task.append_trace("failed", reason)
+        if task.retry_count <= self.max_retry:
+            task.status = TaskStatus.PENDING  # 自动重试
+            log.info("任务 %s 重试 %d/%d", task.task_id, task.retry_count, self.max_retry)
+        else:
+            task.transition(TaskStatus.BLOCKED)
+            self._alert(f"任务 {task.task_id} 重试超限已阻塞: {reason}")
+        models.update_task(task.task_id, status=task.status.value,
+                           retry_count=task.retry_count, trace=task.trace)
+
+    def _alert(self, msg: str) -> None:
+        # M0 阶段告警落日志；后续可扩展飞书 / 短信通知
+        log.warning("【告警】%s", msg)
+        if config.ALERT_LEVEL == "stdout":
+            print(f"ALERT: {msg}")
+
+    # ---------------------------------------------------------- 人工确认
+    def approve(self, task_id: str, approved: bool = True) -> Dict[str, Any]:
+        row = models.get_task(task_id)
+        if row is None:
+            raise ValueError(f"任务不存在: {task_id}")
+        task = Task.from_dict(row)
+        if task.status != TaskStatus.AWAITING_HUMAN:
+            raise ValueError(f"任务 {task_id} 不在人工确认状态（当前 {task.status.value}）")
+        if approved:
+            task.transition(TaskStatus.SUCCESS)
+            task.append_trace("human_approved", "ok")
+        else:
+            task.transition(TaskStatus.FAILED)
+            task.append_trace("human_rejected", "人工驳回")
+            self._fail(task, "人工驳回")  # 走重试逻辑（若无重试价值可置 blocked）
+            models.update_task(task.task_id, status=task.status.value,
+                               retry_count=task.retry_count, trace=task.trace)
+            return {"task_id": task_id, "status": task.status.value, "approved": False}
+        models.update_task(task.task_id, status=task.status.value, trace=task.trace,
+                           finished_at=task.finished_at)
+        return {"task_id": task_id, "status": task.status.value, "approved": True}
+
+    # ---------------------------------------------------------- 统计
+    def stats(self) -> Dict[str, Any]:
+        counts = models.count_tasks()
+        by_module: Dict[str, int] = {}
+        for row in models.list_tasks():
+            by_module[row["module_id"]] = by_module.get(row["module_id"], 0) + 1
+        return {
+            "task_counts": counts,
+            "by_module": by_module,
+            "agents_online": len(self.agents),
+            "max_retry": self.max_retry,
+        }
+
+    # ---------------------------------------------------------- 链路演示
+    def create_pipeline(self, steps: List[Dict[str, Any]]) -> List[str]:
+        """按顺序提交一组任务（链路演示用），随后由 run_once 依次执行。"""
+        ids: List[str] = []
+        for i, step in enumerate(steps):
+            t = self.submit(module_id=step["module_id"],
+                            task_type=step.get("task_type", f"pipeline_{i + 1}"),
+                            input_data=step.get("input", {}),
+                            priority=step.get("priority", "P1"))
+            ids.append(t.task_id)
+        return ids

package/agent-team/core/task.py

@@ -0,0 +1,121 @@
+"""任务协议与状态机。
+
+对齐开发文档《统一协议与数据模型》任务部分：
+状态流转约束：pending → running → success / failed / awaiting_human / blocked；
+failed 可重试回 pending（上限由调度官控制）；awaiting_human 经人工确认后 success / failed。
+"""
+import uuid
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+from core.models import utcnow
+
+
+class TaskStatus(str, Enum):
+    PENDING = "pending"
+    RUNNING = "running"
+    SUCCESS = "success"
+    FAILED = "failed"
+    BLOCKED = "blocked"
+    AWAITING_HUMAN = "awaiting_human"
+
+
+class TaskError(Exception):
+    """任务执行异常：携带可诊断信息。"""
+
+
+class TaskStatusError(TaskError):
+    """非法状态迁移。"""
+
+
+# 允许的状态迁移表
+_TRANSITIONS: Dict[TaskStatus, set] = {
+    TaskStatus.PENDING: {TaskStatus.RUNNING, TaskStatus.BLOCKED},
+    TaskStatus.RUNNING: {TaskStatus.SUCCESS, TaskStatus.FAILED,
+                         TaskStatus.AWAITING_HUMAN, TaskStatus.BLOCKED},
+    TaskStatus.FAILED: {TaskStatus.PENDING, TaskStatus.BLOCKED},
+    TaskStatus.AWAITING_HUMAN: {TaskStatus.SUCCESS, TaskStatus.FAILED},
+    TaskStatus.SUCCESS: set(),
+    TaskStatus.BLOCKED: {TaskStatus.PENDING},
+}
+
+
+def assert_transition(old: TaskStatus, new: TaskStatus) -> None:
+    if old == new:
+        return
+    if new not in _TRANSITIONS.get(old, set()):
+        raise TaskStatusError(f"非法状态迁移: {old.value} -> {new.value}")
+
+
+def new_task_id() -> str:
+    return "T" + uuid.uuid4().hex[:12]
+
+
+@dataclass
+class Task:
+    """领域任务对象：创建时校验必填字段，序列化/反序列化与 DB 行对齐。"""
+
+    task_type: str
+    module_id: str
+    input_json: Dict[str, Any] = field(default_factory=dict)
+    priority: str = "P1"
+    need_human: bool = False
+    status: TaskStatus = TaskStatus.PENDING
+    task_id: str = field(default_factory=new_task_id)
+    output_json: Dict[str, Any] = field(default_factory=dict)
+    retry_count: int = 0
+    trace: List[Dict[str, Any]] = field(default_factory=list)
+    created_at: str = field(default_factory=utcnow)
+    finished_at: str = ""
+
+    def __post_init__(self) -> None:
+        if not self.task_type or not self.module_id:
+            raise TaskError("task_type 与 module_id 为必填字段")
+        if self.priority not in ("P0", "P1", "P2", "P3"):
+            raise TaskError(f"非法优先级: {self.priority}")
+
+    # ---- 状态机 ----
+    def transition(self, new_status: TaskStatus) -> None:
+        assert_transition(self.status, new_status)
+        self.status = new_status
+        if new_status in (TaskStatus.SUCCESS, TaskStatus.FAILED, TaskStatus.BLOCKED):
+            self.finished_at = utcnow()
+
+    def append_trace(self, step: str, detail: Any = None) -> None:
+        self.trace.append({"step": step, "detail": detail, "at": utcnow()})
+
+    # ---- 序列化 ----
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "task_id": self.task_id,
+            "task_type": self.task_type,
+            "module_id": self.module_id,
+            "status": self.status.value,
+            "priority": self.priority,
+            "input_json": self.input_json,
+            "output_json": self.output_json,
+            "retry_count": self.retry_count,
+            "need_human": self.need_human,
+            "trace": self.trace,
+            "created_at": self.created_at,
+            "finished_at": self.finished_at,
+        }
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> "Task":
+        t = cls(
+            task_id=d["task_id"],
+            task_type=d["task_type"],
+            module_id=d["module_id"],
+            status=TaskStatus(d["status"]),
+            priority=d.get("priority", "P1"),
+            input_json=d.get("input_json", {}),
+            output_json=d.get("output_json", {}),
+            retry_count=d.get("retry_count", 0),
+            need_human=bool(d.get("need_human")),
+            trace=d.get("trace", []),
+            created_at=d.get("created_at", ""),
+            finished_at=d.get("finished_at", ""),
+        )
+        return t

package/agent-team/llm/__init__.py

@@ -0,0 +1,12 @@
+"""LLM 工厂：按配置返回 mock 或 doubao 客户端。"""
+from config import (DOUBAO_API_KEY, DOUBAO_BASE_URL, DOUBAO_MODEL, LLM_PROVIDER)
+
+from llm.base import LLMClient
+from llm.mock_llm import MockLLM
+
+
+def get_llm() -> LLMClient:
+    if LLM_PROVIDER == "doubao":
+        from llm.doubao_llm import DoubaoLLM
+        return DoubaoLLM(api_key=DOUBAO_API_KEY, model=DOUBAO_MODEL, base_url=DOUBAO_BASE_URL)
+    return MockLLM()

package/agent-team/llm/base.py

@@ -0,0 +1,22 @@
+"""LLM 客户端抽象：所有模块通过统一接口调用大模型。"""
+from typing import Any, Dict, List
+
+
+class LLMClient:
+    """大模型客户端接口。
+
+    chat(messages, **kwargs) -> str
+    messages: [{"role": "system"|"user"|"assistant", "content": str}, ...]
+    """
+
+    provider: str = "base"
+
+    def chat(self, messages: List[Dict[str, str]], **kwargs: Any) -> str:
+        raise NotImplementedError
+
+    def complete(self, prompt: str, system: str = "", **kwargs: Any) -> str:
+        msgs = []
+        if system:
+            msgs.append({"role": "system", "content": system})
+        msgs.append({"role": "user", "content": prompt})
+        return self.chat(msgs, **kwargs)