Beaver/beaver_project
6
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

feat(engine): 添加MCP连接管理和工具集成功能

Browse Source 
- 集成MCP连接管理器，支持MCP服务器连接
- 添加多种内置工具：ClarifyTool、CronTool、DelegateTool、ExecuteCodeTool、
  PatchFileTool、ProcessTool、SendMessageTool、SpawnTool、TerminalTool、
  TodoTool、WebFetchTool、WebSearchTool、WriteFileTool等
- 实现工具注册和装配功能
- 添加技能选择上下文参数
- 支持思考模式控制参数thinking_enabled

feat(coordinator): 重构任务执行计划器参数命名

- 将learning_candidate_enabled重命名为allow_candidate_generation
- 更新TeamGraphScheduler中的参数传递
- 修改LocalAgentRunner中的相关参数处理
- 更新README文档中的相应描述

refactor(context): 标准化工具调用参数格式

- 添加_json导入用于参数序列化
- 实现_provider_tool_calls方法标准化OpenAI兼容的工具调用载荷
- 修复工具调用中参数非字符串类型的序列化问题

refactor(session): 优化消息历史记录过滤逻辑

- 修改get_messages_as_conversation为基于运行状态过滤消息
- 排除未完成、失败或错误结束的运行记录
- 改进对话历史的可见性控制机制

fix(store): 修复FTS索引重建逻辑

- 添加异常处理防止FTS索引创建失败
- 实现_rebuild_fts_index方法重新构建全文搜索索引
- 优化索引触发器和表的维护流程
This commit is contained in:
steven_li
2026-05-14 09:43:48 +08:00
parent 8a12c30141
commit 30ab74ffb2
149 changed files with 12293 additions and 2812 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
app-instance/backend/beaver/tasks/models.py
View File

@ -160,6 +160,9 @@ class MainAgentDecision:
mode: str
reason: str
starts_new_task: bool = False
closes_task: bool = False
abandons_task: bool = False
short_title: str | None = None
@property
def is_task(self) -> bool:

8
app-instance/backend/beaver/tasks/planner.py
View File

@ -50,10 +50,10 @@ class TaskExecutionPlan:
for node in nodes
for name in node.inherited_pinned_skills
],
"generated_skill_draft_ids": [
item.generated_skill_draft_id
"ephemeral_guidance_ids": [
item.ephemeral_guidance_id
for item in self.skill_resolution_report
if item.generated_skill_draft_id
if item.ephemeral_guidance_id
],
"skill_resolution_report": [item.to_dict() for item in self.skill_resolution_report],
"fallback_error": self.fallback_error,
@ -108,7 +108,7 @@ class TaskExecutionPlanner:
],
tools=None,
model=model,
max_tokens=1200,
max_tokens=4096,
temperature=0.0,
)
plan = self.from_json(response.content or "")

162
app-instance/backend/beaver/tasks/router.py
View File

@ -1,40 +1,144 @@
"""Main Agent routing between simple chat and internal Task mode."""
"""LLM-based routing between simple chat and internal Task mode."""
from __future__ import annotations
import re
import asyncio
import json
from typing import Any
from .models import MainAgentDecision, TaskRecord
class MainAgentRouter:
"""Small deterministic classifier used before the main AgentLoop.
"""Semantic router for deciding whether a message belongs to a Task."""
The first version intentionally avoids a mandatory model call so the router
stays reliable during provider outages. The rule set is conservative:
anything that implies execution, files, tools, iteration, or validation
becomes Task mode.
"""
async def classify(
self,
message: str,
*,
active_task: TaskRecord | None = None,
provider: Any | None = None,
model: str | None = None,
recent_messages: list[dict[str, Any]] | None = None,
thinking_enabled: bool | None = None,
timeout_seconds: float = 8.0,
) -> MainAgentDecision:
if provider is None:
return self._fallback(active_task=active_task, reason="router_provider_unavailable")
try:
chat_kwargs: dict[str, Any] = {
"messages": [
{
"role": "system",
"content": (
"You route user messages for Beaver's internal Task mode. "
"Return only compact JSON. Do not explain."
),
},
{
"role": "user",
"content": self._prompt(
message=message,
active_task=active_task,
recent_messages=recent_messages or [],
),
},
],
"tools": None,
"model": model,
"max_tokens": 256,
"temperature": 0.0,
}
if thinking_enabled is not None:
chat_kwargs["thinking_enabled"] = thinking_enabled
response = await asyncio.wait_for(provider.chat(**chat_kwargs), timeout=timeout_seconds)
return self.from_json(response.content or "", active_task=active_task)
except Exception as exc:
return self._fallback(active_task=active_task, reason=f"router_failed: {exc}")
_TASK_PATTERNS = [
r"\b(implement|fix|debug|refactor|migrate|build|create|write|edit|update|test|validate|deploy)\b",
r"\b(file|repo|code|project|backend|frontend|api|database|migration|pull request|ci|bug)\b",
r"\b(step|multi-step|workflow|plan and|then)\b",
r"(实现|修复|调试|重构|迁移|构建|创建|编写|修改|更新|测试|验证|部署|文件|代码|项目|前端|后端|接口|数据库|多步|任务)",
]
_NEW_TASK_PATTERNS = [
r"\b(new task|another task|different task|start over)\b",
r"(新任务|另一个任务|换个任务|重新开始)",
]
def from_json(self, text: str, *, active_task: TaskRecord | None = None) -> MainAgentDecision:
payload = self._parse_json_object(text)
raw_action = str(payload.get("action") or payload.get("mode") or "").strip().lower()
reason = str(payload.get("reason") or raw_action or "llm_router")
short_title = _clean_short_title(payload.get("short_title") or payload.get("title"))
def classify(self, message: str, *, active_task: TaskRecord | None = None) -> MainAgentDecision:
text = message.strip()
lowered = text.lower()
starts_new = any(re.search(pattern, lowered, re.IGNORECASE) for pattern in self._NEW_TASK_PATTERNS)
if active_task is not None and active_task.status in {"awaiting_feedback", "needs_revision"} and not starts_new:
return MainAgentDecision(mode="task", reason="continuing_open_task", starts_new_task=False)
if any(re.search(pattern, lowered, re.IGNORECASE) for pattern in self._TASK_PATTERNS):
return MainAgentDecision(mode="task", reason="task_pattern_matched", starts_new_task=starts_new)
if len(text) > 240:
return MainAgentDecision(mode="task", reason="long_request", starts_new_task=starts_new)
return MainAgentDecision(mode="simple", reason="simple_question", starts_new_task=False)
if raw_action in {"continue_task", "continue", "task"}:
return MainAgentDecision(mode="task", reason=reason, short_title=short_title)
if raw_action in {"new_task", "new"}:
return MainAgentDecision(mode="task", reason=reason, starts_new_task=True, short_title=short_title)
if raw_action in {"close_task", "close", "done", "finish"}:
return MainAgentDecision(mode="simple", reason=reason, closes_task=active_task is not None, short_title=short_title)
if raw_action in {"abandon_task", "abandon", "cancel_task"}:
return MainAgentDecision(mode="simple", reason=reason, abandons_task=active_task is not None, short_title=short_title)
return MainAgentDecision(mode="simple", reason=reason or "simple_chat", short_title=short_title)
def _fallback(self, *, active_task: TaskRecord | None, reason: str) -> MainAgentDecision:
if active_task is not None:
return MainAgentDecision(mode="task", reason=reason)
return MainAgentDecision(mode="simple", reason=reason)
@staticmethod
def _prompt(
*,
message: str,
active_task: TaskRecord | None,
recent_messages: list[dict[str, Any]],
) -> str:
active_task_payload = None
if active_task is not None:
active_task_payload = {
"task_id": active_task.task_id,
"description": active_task.description,
"goal": active_task.goal,
"status": active_task.status,
"short_title": active_task.metadata.get("short_title"),
}
recent = [
{"role": item.get("role"), "content": str(item.get("content") or "")[:500]}
for item in recent_messages[-8:]
if item.get("role") in {"user", "assistant"}
]
return (
"Decide how to route the current user message.\n\n"
"Actions:\n"
"- simple_chat: no Task should be created or continued.\n"
"- continue_task: keep the user in the active Task.\n"
"- new_task: start a separate new Task.\n"
"- close_task: user explicitly says the active Task is done/satisfactory/finished.\n"
"- abandon_task: user explicitly says to stop, cancel, abandon, or no longer do the active Task.\n\n"
"Critical policy:\n"
"- If there is an active Task, choose continue_task unless the user's topic is completely unrelated "
"to that Task or the user explicitly closes/abandons it.\n"
"- Follow-up questions, corrections, partial changes, extra constraints, and result discussion stay in continue_task.\n"
"- Use new_task only when the user clearly asks to start a different task.\n"
"- If there is no active Task, choose new_task only for work that requires execution, iteration, tools, files, "
"implementation, validation, or multi-step completion. Otherwise choose simple_chat.\n"
"- short_title must be 5-15 Chinese characters or a similarly short English phrase when a Task is involved.\n\n"
"Return JSON only with keys: action, reason, short_title.\n\n"
f"Active task:\n{json.dumps(active_task_payload, ensure_ascii=False)}\n\n"
f"Recent conversation:\n{json.dumps(recent, ensure_ascii=False)}\n\n"
f"Current user message:\n{message}"
)
@staticmethod
def _parse_json_object(text: str) -> dict[str, Any]:
cleaned = text.strip()
if cleaned.startswith("```"):
cleaned = cleaned.strip("`")
if cleaned.lower().startswith("json"):
cleaned = cleaned[4:].strip()
start = cleaned.find("{")
end = cleaned.rfind("}")
if start >= 0 and end >= start:
cleaned = cleaned[start : end + 1]
payload = json.loads(cleaned)
if not isinstance(payload, dict):
raise ValueError("router response must be a JSON object")
return payload
def _clean_short_title(value: Any) -> str | None:
if value in (None, ""):
return None
title = " ".join(str(value).strip().split())
return title[:40] or None

86
app-instance/backend/beaver/tasks/service.py
View File

@ -24,6 +24,8 @@ class TaskService:
metadata: dict[str, Any] | None = None,
) -> TaskRecord:
now = self._now()
task_metadata = dict(metadata or {})
task_metadata.setdefault("short_title", short_task_title(description))
task = TaskRecord(
task_id=uuid4().hex,
session_id=session_id,
@ -35,7 +37,7 @@ class TaskService:
creator=creator,
created_at=now,
updated_at=now,
metadata=dict(metadata or {}),
metadata=task_metadata,
)
self.store.upsert_task(task)
self._event(task, "created", payload={"description": description})
@ -44,11 +46,45 @@ class TaskService:
def get_task(self, task_id: str) -> TaskRecord | None:
return self.store.get_task(task_id)
def list_tasks(self) -> list[TaskRecord]:
return sorted(self.store.list_tasks(), key=lambda item: item.updated_at, reverse=True)
def list_events(self, task_id: str) -> list[TaskEvent]:
return self.store.list_events(task_id=task_id)
def get_task_by_run_id(self, run_id: str) -> TaskRecord | None:
return self.store.get_task_by_run_id(run_id)
def get_latest_open_task(self, session_id: str) -> TaskRecord | None:
return self.store.get_latest_open_task(session_id)
def get_latest_open_task(self, session_id: str, *, include_unengaged_scheduled: bool = False) -> TaskRecord | None:
tasks = [
task
for task in self.store.list_tasks()
if task.session_id == session_id and task.is_open
]
if not include_unengaged_scheduled:
tasks = [task for task in tasks if self._is_user_visible_active_task(task)]
if not tasks:
return None
return sorted(tasks, key=lambda item: item.updated_at)[-1]
def active_task_view(self, session_id: str) -> dict[str, Any] | None:
task = self.get_latest_open_task(session_id)
if task is None:
return None
return self.to_api_dict(task)
def to_api_dict(self, task: TaskRecord) -> dict[str, Any]:
payload = task.to_dict()
payload["short_title"] = self.ensure_short_title(task).metadata.get("short_title")
payload["is_open"] = task.is_open
return payload
def ensure_short_title(self, task: TaskRecord) -> TaskRecord:
if task.metadata.get("short_title"):
return task
task.metadata["short_title"] = short_task_title(task.description or task.goal or task.task_id)
self.store.upsert_task(task)
return task
def start_run(self, task_id: str, *, user_message: str, attempt_index: int) -> TaskRecord:
task = self._require(task_id)
@ -136,6 +172,38 @@ class TaskService:
self._event(task, f"feedback_{feedback_type}", run_id=run_id, payload=entry)
return task
def close_task(self, task_id: str, *, reason: str = "closed") -> TaskRecord:
task = self._require(task_id)
now = self._now()
task.status = "closed"
task.closed_at = now
task.close_reason = reason
task.updated_at = now
self.store.upsert_task(task)
self._event(task, "closed", payload={"reason": reason})
return task
def abandon_task(self, task_id: str, *, reason: str = "abandoned") -> TaskRecord:
task = self._require(task_id)
now = self._now()
task.status = "abandoned"
task.closed_at = now
task.close_reason = reason
task.updated_at = now
self.store.upsert_task(task)
self._event(task, "abandoned", payload={"reason": reason})
return task
def delete_task(self, task_id: str) -> bool:
return self.store.delete_task(task_id)
@staticmethod
def _is_user_visible_active_task(task: TaskRecord) -> bool:
if task.creator != "cron":
return True
metadata = task.metadata or {}
return bool(metadata.get("user_engaged") or metadata.get("requires_followup"))
def _require(self, task_id: str) -> TaskRecord:
task = self.store.get_task(task_id)
if task is None:
@ -165,3 +233,15 @@ class TaskService:
@staticmethod
def _now() -> str:
return datetime.now(timezone.utc).isoformat()
def short_task_title(text: str) -> str:
cleaned = " ".join((text or "").strip().split())
if not cleaned:
return "当前任务"
if any("\u4e00" <= char <= "\u9fff" for char in cleaned):
return cleaned[:15]
words = cleaned.split()
if len(words) <= 4:
return cleaned[:40]
return " ".join(words[:4])[:40]

29
app-instance/backend/beaver/tasks/skill_resolver.py
View File

@ -11,7 +11,7 @@ from beaver.engine.providers import ProviderBundle
from beaver.skills.assembler.embedding_retriever import SkillEmbeddingRetriever
from beaver.skills.catalog.loader import SkillsLoader
from beaver.skills.drafts import DraftService
from beaver.skills.learning import MissingSkillSynthesizer
from beaver.skills.learning import EphemeralGuidanceSynthesizer
from beaver.tasks.models import TaskRecord
@ -21,8 +21,8 @@ class SkillResolutionReport:
skill_query: str
required_capabilities: list[str] = field(default_factory=list)
selected_skill_names: list[str] = field(default_factory=list)
generated_skill_draft_id: str | None = None
generated_skill_name: str | None = None
ephemeral_guidance_id: str | None = None
ephemeral_guidance_name: str | None = None
ephemeral_used: bool = False
reason: str = ""
@ -32,15 +32,15 @@ class SkillResolutionReport:
"skill_query": self.skill_query,
"required_capabilities": list(self.required_capabilities),
"selected_skill_names": list(self.selected_skill_names),
"generated_skill_draft_id": self.generated_skill_draft_id,
"generated_skill_name": self.generated_skill_name,
"ephemeral_guidance_id": self.ephemeral_guidance_id,
"ephemeral_guidance_name": self.ephemeral_guidance_name,
"ephemeral_used": self.ephemeral_used,
"reason": self.reason,
}
class TaskSkillResolver:
"""Pins published or draft-only skills onto generic team nodes."""
"""Pins published skills or one-run guidance onto generic team nodes."""
def __init__(
self,
@ -48,12 +48,12 @@ class TaskSkillResolver:
skills_loader: SkillsLoader,
draft_service: DraftService,
retriever: SkillEmbeddingRetriever | None = None,
missing_skill_synthesizer: MissingSkillSynthesizer | None = None,
missing_skill_synthesizer: EphemeralGuidanceSynthesizer | None = None,
) -> None:
self.skills_loader = skills_loader
self.draft_service = draft_service
self.retriever = retriever or SkillEmbeddingRetriever()
self.missing_skill_synthesizer = missing_skill_synthesizer or MissingSkillSynthesizer()
self.missing_skill_synthesizer = missing_skill_synthesizer or EphemeralGuidanceSynthesizer()
async def resolve_graph(
self,
@ -138,7 +138,6 @@ class TaskSkillResolver:
skill_query=skill_query,
required_capabilities=required_capabilities,
provider_bundle=provider_bundle,
draft_service=self.draft_service,
)
resolved = self._generic_node(
node,
@ -149,8 +148,8 @@ class TaskSkillResolver:
"skill_query": skill_query,
"required_capabilities": required_capabilities,
"selected_skill_names": [],
"generated_skill_draft_id": missing.draft.draft_id,
"generated_skill_name": missing.draft.skill_name,
"ephemeral_guidance_id": missing.guidance_id,
"ephemeral_guidance_name": missing.guidance_name,
"ephemeral_skill_names": [missing.skill_context.name],
},
)
@ -158,10 +157,10 @@ class TaskSkillResolver:
node_id=node.node_id,
skill_query=skill_query,
required_capabilities=required_capabilities,
generated_skill_draft_id=missing.draft.draft_id,
generated_skill_name=missing.draft.skill_name,
ephemeral_guidance_id=missing.guidance_id,
ephemeral_guidance_name=missing.guidance_name,
ephemeral_used=True,
reason="generated draft-only skill for missing sub-agent guidance",
reason="generated ephemeral guidance for missing sub-agent capability",
)
async def _select_published_skills(self, *, query: str, provider_bundle: ProviderBundle) -> list[str]:
@ -215,7 +214,7 @@ class TaskSkillResolver:
],
tools=None,
model=model,
max_tokens=512,
max_tokens=2048,
temperature=0,
)
parsed = self._parse_names(response.content or "")

21
app-instance/backend/beaver/tasks/store.py
View File

@ -40,7 +40,7 @@ class TaskStore:
tasks = [
task
for task in self.list_tasks()
if task.session_id == session_id and task.status in {"awaiting_feedback", "needs_revision", "open", "running"}
if task.session_id == session_id and task.is_open
]
if not tasks:
return None
@ -52,6 +52,25 @@ class TaskStore:
payload[task.task_id] = task.to_dict()
self._write_tasks_unlocked(payload)
def delete_task(self, task_id: str) -> bool:
with self._lock:
payload = self._read_tasks_unlocked()
if task_id not in payload:
return False
payload.pop(task_id, None)
self._write_tasks_unlocked(payload)
if self.events_path.exists():
kept = []
for line in self.events_path.read_text(encoding="utf-8").splitlines():
cleaned = line.strip()
if not cleaned:
continue
event_payload = json.loads(cleaned)
if not isinstance(event_payload, dict) or str(event_payload.get("task_id")) != task_id:
kept.append(cleaned)
self.events_path.write_text(("\n".join(kept) + "\n") if kept else "", encoding="utf-8")
return True
def append_event(self, event: TaskEvent) -> None:
self.events_path.parent.mkdir(parents=True, exist_ok=True)
with self._lock:

2
app-instance/backend/beaver/tasks/validation.py
View File

@ -84,7 +84,7 @@ class ValidationService:
],
tools=None,
model=model,
max_tokens=800,
max_tokens=4096,
temperature=0.0,
)
payload = self._parse_json_object(response.content or "")