sync: 鍚屾灞€鍩熺綉鏈€鏂颁唬鐮?(source master @ b69568e4)

This commit is contained in:
gozeros committed 2026-10-21 14:51:31 +08:00
1 parent 4f7f07504a
commit 8bc8b0e082
1651 files changed
+278599 -11416

No files matched your search

@@ -32,6 +32,7 @@ if TYPE_CHECKING:
from deerflow.persistence.notifications import NotificationStore
from deerflow.persistence.scheduled_tasks import ScheduledTaskStore
from deerflow.persistence.skills import SkillStore
from deerflow.persistence.strategy_agent_roles import StrategyAgentRoleStore
from deerflow.persistence.tags import TagStore
from deerflow.persistence.thread_meta.base import ThreadMetaStore
@@ -58,6 +59,32 @@ def get_config(request: Request) -> AppConfig:
return config
async def _enter_runtime_backend_or_fallback[BackendT](
stack: AsyncExitStack,
context_manager,
*,
label: str,
fallback_factory: Callable[[], BackendT],
) -> BackendT:
"""Enter a persistent runtime backend without making startup depend on it.
Checkpointer/Store ``setup()`` creates its own tables. Permissions,
incompatible DDL, or an unavailable persistence service must therefore
degrade to the in-process implementation instead of aborting FastAPI's
lifespan. The exception remains fully logged for operators.
"""
try:
return await stack.enter_async_context(context_manager)
except Exception:
logger.exception(
"%s initialization failed; continuing Gateway startup with an "
"in-memory fallback",
label,
)
return fallback_factory()
@asynccontextmanager
async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
"""Bootstrap and tear down all LangGraph runtime singletons.
@@ -67,6 +94,9 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
async with langgraph_runtime(app):
yield
"""
from langgraph.checkpoint.memory import InMemorySaver
from langgraph.store.memory import InMemoryStore
from deerflow.persistence.engine import close_engine, get_session_factory, init_engine_from_config
from deerflow.runtime import make_store, make_stream_bridge
from deerflow.runtime.checkpointer.async_provider import make_checkpointer
@@ -83,8 +113,18 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
# auto-create-database logic runs first (postgres backend).
await init_engine_from_config(config.database)
app.state.checkpointer = await stack.enter_async_context(make_checkpointer(config))
app.state.store = await stack.enter_async_context(make_store(config))
app.state.checkpointer = await _enter_runtime_backend_or_fallback(
stack,
make_checkpointer(config),
label="LangGraph checkpointer",
fallback_factory=InMemorySaver,
)
app.state.store = await _enter_runtime_backend_or_fallback(
stack,
make_store(config),
label="LangGraph store",
fallback_factory=InMemoryStore,
)
# Initialize repositories — one get_session_factory() call for all.
sf = get_session_factory()
@@ -108,6 +148,24 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
app.state.thread_store = make_thread_store(sf, app.state.store)
from deerflow.persistence.task_deeplink_threads import (
make_task_deeplink_thread_store,
)
app.state.task_deeplink_thread_store = make_task_deeplink_thread_store(
sf,
app.state.store,
app.state.thread_store,
)
from deerflow.persistence.artifact_library import make_artifact_library_store
app.state.artifact_library_store = make_artifact_library_store(sf)
# User-scoped refresh tasks are registered here by the artifacts router
# and cancelled by the Gateway lifespan before persistence shuts down.
app.state.artifact_library_sync_tasks = {}
app.state.artifact_library_sync_semaphore = asyncio.Semaphore(1)
from deerflow.persistence.scheduled_tasks import make_scheduled_task_store
app.state.scheduled_task_store = make_scheduled_task_store(sf)
@@ -132,6 +190,12 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
app.state.agent_store = make_agent_store(sf)
from deerflow.persistence.strategy_agent_roles import (
make_strategy_agent_role_store,
)
app.state.strategy_agent_role_store = make_strategy_agent_role_store(sf)
from deerflow.persistence.skills import make_skill_store
app.state.skill_store = make_skill_store(sf)
@@ -275,7 +339,12 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
from deerflow.persistence.position_roles import make_position_role_store
app.state.position_role_store = make_position_role_store(sf)
await app.state.position_role_store.ensure_seed(POSITION_ROLE_SEED)
try:
await app.state.position_role_store.ensure_seed(POSITION_ROLE_SEED)
except Exception:
logger.exception(
"Position-role seeding failed at startup; continuing without seed refresh"
)
from deerflow.persistence.business_mapping import make_business_mapping_store
@@ -300,7 +369,6 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
# Candidate plans are durable user-editable drafts, deliberately kept
# separate from both the canvas draft and a formal workflow run.
app.state.workflow_planning_store = make_workflow_planning_store(sf)
from app.report_collaboration.execution.live_hub import PublishingReportCollaborationStore, ReportCollaborationLiveHub
from deerflow.persistence.report_collaboration import make_report_collaboration_store
@@ -336,6 +404,12 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
app.state.sensitive_word_store = make_sensitive_word_store(sf)
# Immutable originals and every repaired/generated public-document
# version live outside temporary deep-research sandbox artifacts.
from deerflow.persistence.gongwen_documents import make_gongwen_document_store
app.state.gongwen_document_store = make_gongwen_document_store(sf)
from deerflow.persistence.dashboard_sessions import make_dashboard_session_store
app.state.dashboard_session_store = make_dashboard_session_store(sf)
@@ -344,6 +418,67 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
app.state.task_button_store = make_task_button_store(sf)
from deerflow.persistence.model_capabilities import (
import_legacy_reasoning_effort_capabilities,
make_model_capability_store,
)
app.state.model_capability_store = make_model_capability_store(sf)
imported_model_capabilities = await import_legacy_reasoning_effort_capabilities(
app.state.model_capability_store,
config.models,
)
if imported_model_capabilities:
logger.info(
"Imported legacy reasoning-effort capability for %d model(s)",
len(imported_model_capabilities),
)
from deerflow.persistence.upload_policy import make_upload_policy_store
from deerflow.uploads.policy import default_upload_policy, set_runtime_upload_policy
app.state.upload_policy_store = make_upload_policy_store(sf)
fallback_upload_policy = default_upload_policy()
try:
upload_policy_row = await app.state.upload_policy_store.ensure_seed(
fallback_upload_policy
)
set_runtime_upload_policy(upload_policy_row["policy"])
except Exception:
logger.exception(
"Upload-policy seeding failed at startup; using process-local defaults"
)
set_runtime_upload_policy(fallback_upload_policy)
from deerflow.persistence.knowledge_retrieval_settings import (
make_knowledge_retrieval_settings_store,
)
app.state.knowledge_retrieval_settings_store = (
make_knowledge_retrieval_settings_store(sf)
)
from deerflow.persistence.task_analysis import make_task_analysis_store
app.state.task_analysis_store = make_task_analysis_store(sf)
from deerflow.persistence.analysis_projects import AnalysisProjectStore
app.state.analysis_project_store = AnalysisProjectStore(sf)
from app.gateway.analysis_project_memory import (
AnalysisProjectMemoryDispatcher,
AnalysisProjectMemoryExecutor,
)
from deerflow.persistence.analysis_project_memory import AnalysisProjectMemoryStore
app.state.analysis_project_memory_store = AnalysisProjectMemoryStore(sf)
app.state.analysis_project_memory_executor = AnalysisProjectMemoryExecutor(app)
app.state.analysis_project_memory_dispatcher = AnalysisProjectMemoryDispatcher(
app.state.analysis_project_memory_store,
app.state.analysis_project_memory_executor,
)
from deerflow.persistence.report_structures import make_report_structure_store
app.state.report_structure_store = make_report_structure_store(sf)
@@ -357,10 +492,14 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
# Skill distillation and the single global assistant knowledge base.
# Both repositories live in ``deerflow.*``; only this composition layer
# wires them to Gateway executors and remote adapters.
from deerflow.persistence.assistant_knowledge import make_assistant_knowledge_store
from deerflow.persistence.assistant_knowledge import (
make_assistant_knowledge_store,
register_assistant_knowledge_store,
)
from deerflow.persistence.skill_knowledge import make_skill_knowledge_store
app.state.assistant_knowledge_store = make_assistant_knowledge_store(sf)
register_assistant_knowledge_store(app.state.assistant_knowledge_store)
app.state.skill_knowledge_store = make_skill_knowledge_store(sf)
if app.state.skill_knowledge_store is not None and app.state.assistant_knowledge_store is not None:
from app.gateway.skill_knowledge_job_dispatcher import SkillKnowledgeJobDispatcher
@@ -384,7 +523,6 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
# DeerFlow-local Wiki mirror/vector index. The store is always wired so
# migrations and status inspection work while feature flags are off;
# network/search services only exist when explicitly enabled.
from deerflow.integrations.weknora.local_index.runtime import register_local_wiki_index_runtime
from deerflow.persistence.llmwiki_index import make_llmwiki_index_store
local_index_config = config.llmwiki.local_wiki_index
@@ -397,78 +535,16 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
app.state.llmwiki_vector_search = None
app.state.llmwiki_sync_service = None
app.state.llmwiki_retrieval_service = None
from deerflow.integrations.weknora.runtime import build_weknora_client, get_resolved_llmwiki_runtime
from app.gateway.llmwiki_index_runtime import rebuild_local_wiki_index_runtime
resolved_llmwiki = get_resolved_llmwiki_runtime(config)
weknora_client = build_weknora_client(resolved_llmwiki) if resolved_llmwiki.weknora_enabled else None
embedding_config = local_index_config.embedding
# The administrator may select or upload the offline encoder from the
# UI. This runtime-owned value deliberately overrides config.yaml and
# survives application restarts without modifying release assets.
if embedding_config.provider == "local":
from deerflow.config.system_settings import load_system_settings
runtime_model_path = load_system_settings().local_wiki_encoder.model_path.strip()
if runtime_model_path:
embedding_config = embedding_config.model_copy(
update={"local_model_path": runtime_model_path}
)
embedding_configured = bool(
embedding_config.enabled
and (embedding_config.base_url or embedding_config.provider == "local")
and embedding_config.model.strip()
)
if embedding_configured:
from deerflow.integrations.weknora.local_index.embedding import StrictWikiEmbeddingClient
app.state.llmwiki_embedding = StrictWikiEmbeddingClient(embedding_config)
if local_index_config.enabled and app.state.llmwiki_embedding is not None:
from deerflow.integrations.weknora.local_index.search import WikiVectorSearchService
from deerflow.integrations.weknora.local_index.sync import WikiSyncService
from deerflow.integrations.weknora.local_index.vector_cache import WikiVectorCache
app.state.llmwiki_vector_cache = WikiVectorCache(
app.state.llmwiki_index_store,
max_knowledge_bases=local_index_config.cache_max_knowledge_bases,
revision_check_seconds=local_index_config.cache_revision_check_seconds,
)
app.state.llmwiki_vector_search = WikiVectorSearchService(
local_index_config,
app.state.llmwiki_embedding,
app.state.llmwiki_vector_cache,
)
if weknora_client is not None:
app.state.llmwiki_sync_service = WikiSyncService(
local_index_config,
app.state.llmwiki_index_store,
app.state.llmwiki_embedding,
app.state.llmwiki_vector_cache,
weknora_client,
)
from app.gateway.knowledge_transfer import sync_to_global
async def on_wiki_vectorized(mapping):
return await sync_to_global(app, mapping)
app.state.llmwiki_sync_service.on_completed = on_wiki_vectorized
if weknora_client is not None or app.state.llmwiki_vector_search is not None:
from deerflow.integrations.weknora.local_index.retrieval import WikiRetrievalService
app.state.llmwiki_retrieval_service = WikiRetrievalService(
app.state.llmwiki_index_store,
vector_search=(
app.state.llmwiki_vector_search
if local_index_config.internal_search_enabled
else None
),
client=weknora_client,
)
register_local_wiki_index_runtime(
store=app.state.llmwiki_index_store,
search=app.state.llmwiki_vector_search,
sync=app.state.llmwiki_sync_service,
retrieval=app.state.llmwiki_retrieval_service,
)
# Build every embedding-dependent object through the same hot-swap
# path used by the administrator settings API. This keeps startup,
# uploaded-local selection and config.yaml reloads behaviorally equal.
await rebuild_local_wiki_index_runtime(app, force=True)
# Start only after the optional embedding runtime is ready. Otherwise
# persisted jobs reclaimed during startup would be permanently stored
# as lexical-only even when phase-two vector recall is configured.
app.state.analysis_project_memory_dispatcher.start()
from deerflow.persistence.taskcop_tasks import make_taskcop_task_store
@@ -478,6 +554,10 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
app.state.task_report_store = make_task_report_store(sf)
from deerflow.persistence.force_situation import make_force_situation_store
app.state.force_situation_store = make_force_situation_store(sf)
from deerflow.persistence.roundtable_artifact_submissions import make_roundtable_artifact_submission_store
# Task-scoped artifact submission status: shared by task; actor is audit-only.
@@ -598,6 +678,9 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
from deerflow.persistence.deep_research_sessions import (
make_deep_research_session_store,
)
from deerflow.persistence.deep_research_sessions import (
register_default_store as _register_deep_research_session_default_store,
)
from deerflow.persistence.deep_research_sources import (
make_deep_research_source_store,
)
@@ -606,6 +689,8 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
)
app.state.deep_research_session_store = make_deep_research_session_store(sf)
# LangGraph 内联写作管线(deep_research_report)跨 harness 边界落会话终态。
_register_deep_research_session_default_store(app.state.deep_research_session_store)
app.state.deep_research_job_store = make_deep_research_job_store(sf)
app.state.deep_research_event_store = make_deep_research_event_store(sf)
app.state.deep_research_source_store = make_deep_research_source_store(sf)
@@ -701,15 +786,23 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
try:
yield
finally:
# Project-memory extraction can use the shared local Wiki encoder.
# Stop its jobs before retiring that runtime to avoid an embedding
# call racing shutdown.
analysis_project_memory_dispatcher = getattr(
app.state, "analysis_project_memory_dispatcher", None
)
if analysis_project_memory_dispatcher is not None:
await analysis_project_memory_dispatcher.stop()
from app.gateway.assistant_file_ingest import stop_file_jobs
await stop_file_jobs()
from deerflow.integrations.weknora.local_index.runtime import register_local_wiki_index_runtime
register_local_wiki_index_runtime(store=None, search=None, sync=None, retrieval=None)
llmwiki_embedding = getattr(app.state, "llmwiki_embedding", None)
if llmwiki_embedding is not None:
await llmwiki_embedding.close()
from app.gateway.llmwiki_index_runtime import close_local_wiki_index_runtime
await close_local_wiki_index_runtime(app)
from deerflow.persistence.notifications import set_notification_store
set_notification_store(None)
@@ -793,6 +886,14 @@ def get_thread_store(request: Request) -> ThreadMetaStore:
return val
def get_task_deeplink_thread_store(request: Request):
"""Return the dedicated taskId + goPath conversation-history index."""
val = getattr(request.app.state, "task_deeplink_thread_store", None)
if val is None:
raise HTTPException(status_code=503, detail="Task deep-link thread store not available")
return val
def get_scheduled_task_store(request: Request) -> ScheduledTaskStore:
"""Return the scheduled-task store."""
val = getattr(request.app.state, "scheduled_task_store", None)
@@ -824,6 +925,14 @@ def get_agent_store(request: Request) -> AgentStore:
return val
def get_strategy_agent_role_store(request: Request) -> StrategyAgentRoleStore:
"""Return the global strategy-agent role registry."""
val = getattr(request.app.state, "strategy_agent_role_store", None)
if val is None:
raise HTTPException(status_code=503, detail="Strategy agent role store not available")
return val
def get_skill_store(request: Request) -> SkillStore:
"""Return the custom-skill store."""
val = getattr(request.app.state, "skill_store", None)
@@ -1000,6 +1109,7 @@ async def get_current_user_from_request(request: Request):
"""
from app.gateway.auth import decode_token
from app.gateway.auth.errors import AuthErrorCode, AuthErrorResponse, TokenError, token_error_to_code
from app.gateway.auth.session_policy import session_policy_error
access_token = get_request_access_token(request)
if not access_token:
@@ -1015,6 +1125,12 @@ async def get_current_user_from_request(request: Request):
detail=AuthErrorResponse(code=token_error_to_code(payload), message=f"Token error: {payload.value}").model_dump(),
)
if policy_error := session_policy_error(payload):
raise HTTPException(
status_code=401,
detail=AuthErrorResponse(code=AuthErrorCode.TOKEN_INVALID, message=policy_error).model_dump(),
)
provider = get_local_provider()
user = await provider.get_user(payload.sub)
if user is None:
@@ -1027,7 +1143,7 @@ async def get_current_user_from_request(request: Request):
if user.token_version != payload.ver:
raise HTTPException(
status_code=401,
detail=AuthErrorResponse(code=AuthErrorCode.TOKEN_INVALID, message="Token revoked (password changed)").model_dump(),
detail=AuthErrorResponse(code=AuthErrorCode.TOKEN_INVALID, message="登录已失效:密码已更改或账号已在其他位置登录,请重新登录").model_dump(),
)
return user