sync update from LAN repo (source dhk-1 @ 3e87be55)
This commit is contained in:
1 parent
ab6068a7c1
commit
42f2a26fa8
1482 files changed
+227759
-9584
No files matched your search
@@ -28,6 +28,8 @@ from langchain_core.callbacks import BaseCallbackHandler
|
||||
from langchain_core.messages import AnyMessage, BaseMessage, HumanMessage, ToolMessage
|
||||
from langgraph.types import Command
|
||||
|
||||
from deerflow.utils.tool_visibility import internal_tool_call_ids, project_outward_messages
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from deerflow.runtime.events.store.base import RunEventStore
|
||||
|
||||
@@ -84,6 +86,7 @@ class RunJournal(BaseCallbackHandler):
|
||||
# LLM request/response tracking
|
||||
self._llm_call_index = 0
|
||||
self._seen_llm_starts: set[str] = set() # langchain run_ids that fired on_chat_model_start
|
||||
self._internal_tool_call_ids: set[str] = set()
|
||||
|
||||
# -- Lifecycle callbacks --
|
||||
|
||||
@@ -193,6 +196,10 @@ class RunJournal(BaseCallbackHandler):
|
||||
|
||||
for message in messages:
|
||||
caller = self._identify_caller(tags)
|
||||
serialized_message = message.model_dump()
|
||||
self._internal_tool_call_ids.update(
|
||||
internal_tool_call_ids([serialized_message])
|
||||
)
|
||||
|
||||
# Latency
|
||||
rid = str(run_id)
|
||||
@@ -212,17 +219,22 @@ class RunJournal(BaseCallbackHandler):
|
||||
self._seen_llm_starts.add(rid)
|
||||
|
||||
# Trace event: llm_response (OpenAI completion format)
|
||||
self._put(
|
||||
event_type="llm.ai.response",
|
||||
category="message",
|
||||
content=message.model_dump(),
|
||||
metadata={
|
||||
"caller": caller,
|
||||
"usage": usage_dict,
|
||||
"latency_ms": latency_ms,
|
||||
"llm_call_index": call_index,
|
||||
},
|
||||
projected = project_outward_messages(
|
||||
[serialized_message],
|
||||
known_internal_tool_call_ids=self._internal_tool_call_ids,
|
||||
)
|
||||
if projected:
|
||||
self._put(
|
||||
event_type="llm.ai.response",
|
||||
category="message",
|
||||
content=projected[0],
|
||||
metadata={
|
||||
"caller": caller,
|
||||
"usage": usage_dict,
|
||||
"latency_ms": latency_ms,
|
||||
"llm_call_index": call_index,
|
||||
},
|
||||
)
|
||||
|
||||
# Token accumulation
|
||||
if self._track_tokens:
|
||||
@@ -248,16 +260,31 @@ class RunJournal(BaseCallbackHandler):
|
||||
|
||||
def on_tool_end(self, output, *, run_id, parent_run_id=None, **kwargs):
|
||||
"""Handle tool end event, append message and clear node data"""
|
||||
def put_message(message: BaseMessage) -> None:
|
||||
tool_call_id = str(getattr(message, "tool_call_id", "") or "")
|
||||
projected = project_outward_messages(
|
||||
[message.model_dump()],
|
||||
known_internal_tool_call_ids=self._internal_tool_call_ids,
|
||||
)
|
||||
if projected:
|
||||
self._put(
|
||||
event_type="llm.tool.result",
|
||||
category="message",
|
||||
content=projected[0],
|
||||
)
|
||||
else:
|
||||
self._internal_tool_call_ids.discard(tool_call_id)
|
||||
|
||||
try:
|
||||
if isinstance(output, ToolMessage):
|
||||
msg = cast(ToolMessage, output)
|
||||
self._put(event_type="llm.tool.result", category="message", content=msg.model_dump())
|
||||
put_message(msg)
|
||||
elif isinstance(output, Command):
|
||||
cmd = cast(Command, output)
|
||||
messages = cmd.update.get("messages", [])
|
||||
for message in messages:
|
||||
if isinstance(message, BaseMessage):
|
||||
self._put(event_type="llm.tool.result", category="message", content=message.model_dump())
|
||||
put_message(message)
|
||||
else:
|
||||
logger.warning(f"on_tool_end {run_id}: command update message is not BaseMessage: {type(message)}")
|
||||
else:
|
||||
|
||||
+234
-92
@@ -19,8 +19,10 @@ import asyncio
|
||||
import copy
|
||||
import inspect
|
||||
import logging
|
||||
from collections.abc import Awaitable
|
||||
from dataclasses import dataclass, field
|
||||
from functools import lru_cache
|
||||
from time import perf_counter
|
||||
from typing import TYPE_CHECKING, Any, Literal, cast
|
||||
|
||||
from langgraph.checkpoint.base import empty_checkpoint
|
||||
@@ -43,6 +45,11 @@ logger = logging.getLogger(__name__)
|
||||
|
||||
# Valid stream_mode values for LangGraph's graph.astream()
|
||||
_VALID_LG_MODES = {"values", "updates", "checkpoints", "tasks", "debug", "messages", "custom"}
|
||||
|
||||
# This budget applies only after graph execution has returned. Long-running
|
||||
# tools, research and subagents retain their own execution/cancellation policy.
|
||||
_RUN_FINALIZATION_TIMEOUT_SECONDS = 10.0
|
||||
_PENDING_COMPLETION_TASKS: set[asyncio.Future[Any]] = set()
|
||||
|
||||
|
||||
def _log_background_title_finalize_failure(thread_id: str):
|
||||
@@ -131,6 +138,29 @@ def _agent_factory_supports_app_config(agent_factory: Any) -> bool:
|
||||
return _compute_agent_factory_supports_app_config(agent_factory)
|
||||
|
||||
|
||||
def _build_agent_with_timing(agent_factory: Any, config: Any, app_config: AppConfig | None, run_id: str) -> Any:
|
||||
# Preserve the original task/ContextVars/event loop. Moving this factory to
|
||||
# a thread changes deferred-tool and MCP lifecycle behavior; measure first.
|
||||
started = perf_counter()
|
||||
outcome = "error"
|
||||
try:
|
||||
if app_config is not None and _agent_factory_supports_app_config(agent_factory):
|
||||
agent = agent_factory(config=config, app_config=app_config)
|
||||
else:
|
||||
agent = agent_factory(config=config)
|
||||
outcome = "ok"
|
||||
return agent
|
||||
finally:
|
||||
elapsed_ms = (perf_counter() - started) * 1000
|
||||
log = logger.warning if elapsed_ms >= 500 else logger.debug
|
||||
try:
|
||||
log("AGENT_BUILD_TIMING run_id=%s outcome=%s elapsed_ms=%.2f", run_id, outcome, elapsed_ms)
|
||||
except Exception:
|
||||
# Timing is diagnostic only; preserve the factory result/exception
|
||||
# even if a deployment's custom log handler is unavailable.
|
||||
pass
|
||||
|
||||
|
||||
async def run_agent(
|
||||
bridge: StreamBridge,
|
||||
run_manager: RunManager,
|
||||
@@ -160,11 +190,11 @@ async def run_agent(
|
||||
store = ctx.store
|
||||
event_store = ctx.event_store
|
||||
run_events_config = ctx.run_events_config
|
||||
thread_store = ctx.thread_store
|
||||
|
||||
run_id = record.run_id
|
||||
thread_id = record.thread_id
|
||||
requested_modes: set[str] = set(stream_modes or ["values"])
|
||||
internal_stream_call_ids: set[str] = set()
|
||||
pre_run_checkpoint_id: str | None = None
|
||||
pre_run_snapshot: dict[str, Any] | None = None
|
||||
snapshot_capture_failed = False
|
||||
@@ -219,14 +249,17 @@ async def run_agent(
|
||||
logger.warning("Could not capture pre-run checkpoint snapshot for run %s", run_id, exc_info=True)
|
||||
|
||||
# 2. Publish metadata — useStream needs both run_id AND thread_id
|
||||
await bridge.publish(
|
||||
run_id,
|
||||
"metadata",
|
||||
{
|
||||
"run_id": run_id,
|
||||
"thread_id": thread_id,
|
||||
},
|
||||
)
|
||||
metadata_event: dict[str, Any] = {
|
||||
"run_id": run_id,
|
||||
"thread_id": thread_id,
|
||||
}
|
||||
retrieval_trace = (record.metadata or {}).get("knowledge_retrieval_trace")
|
||||
if isinstance(retrieval_trace, dict):
|
||||
metadata_event["knowledge_retrieval_trace"] = retrieval_trace
|
||||
metadata_event["knowledge_retrieval_url"] = (
|
||||
f"/api/threads/{thread_id}/reference-batches"
|
||||
)
|
||||
await bridge.publish(run_id, "metadata", metadata_event)
|
||||
|
||||
# 3. Build the agent
|
||||
from langchain_core.runnables import RunnableConfig
|
||||
@@ -247,10 +280,7 @@ async def run_agent(
|
||||
config.setdefault("callbacks", []).append(journal)
|
||||
|
||||
runnable_config = RunnableConfig(**config)
|
||||
if ctx.app_config is not None and _agent_factory_supports_app_config(agent_factory):
|
||||
agent = agent_factory(config=runnable_config, app_config=ctx.app_config)
|
||||
else:
|
||||
agent = agent_factory(config=runnable_config)
|
||||
agent = _build_agent_with_timing(agent_factory, runnable_config, ctx.app_config, run_id)
|
||||
|
||||
# 4. Attach checkpointer and store
|
||||
if checkpointer is not None:
|
||||
@@ -324,7 +354,13 @@ async def run_agent(
|
||||
logger.info("Run %s abort requested — stopping", run_id)
|
||||
break
|
||||
sse_event = _lg_mode_to_sse_event(single_mode)
|
||||
await bridge.publish(run_id, sse_event, serialize(chunk, mode=single_mode))
|
||||
serialized = serialize(
|
||||
chunk,
|
||||
mode=single_mode,
|
||||
known_internal_tool_call_ids=internal_stream_call_ids,
|
||||
)
|
||||
if serialized is not None:
|
||||
await bridge.publish(run_id, sse_event, serialized)
|
||||
else:
|
||||
# Multiple modes or subgraphs: astream yields tuples
|
||||
async for item in agent.astream(
|
||||
@@ -342,13 +378,19 @@ async def run_agent(
|
||||
continue
|
||||
|
||||
sse_event = _lg_mode_to_sse_event(mode)
|
||||
await bridge.publish(run_id, sse_event, serialize(chunk, mode=mode))
|
||||
serialized = serialize(
|
||||
chunk,
|
||||
mode=mode,
|
||||
known_internal_tool_call_ids=internal_stream_call_ids,
|
||||
)
|
||||
if serialized is not None:
|
||||
await bridge.publish(run_id, sse_event, serialized)
|
||||
|
||||
# 8. Final status
|
||||
if record.abort_event.is_set():
|
||||
action = record.abort_action
|
||||
if action == "rollback":
|
||||
await run_manager.set_status(run_id, RunStatus.error, error="Rolled back by user")
|
||||
await _set_terminal_status(run_manager, record, RunStatus.error, error="Rolled back by user")
|
||||
try:
|
||||
await _rollback_to_pre_run_checkpoint(
|
||||
checkpointer=checkpointer,
|
||||
@@ -362,7 +404,7 @@ async def run_agent(
|
||||
except Exception:
|
||||
logger.warning("Failed to rollback checkpoint for run %s", run_id, exc_info=True)
|
||||
else:
|
||||
await run_manager.set_status(run_id, RunStatus.interrupted)
|
||||
await _set_terminal_status(run_manager, record, RunStatus.interrupted)
|
||||
else:
|
||||
# LLMErrorHandlingMiddleware intentionally converts an exhausted
|
||||
# provider failure into a user-safe AIMessage instead of raising.
|
||||
@@ -372,9 +414,10 @@ async def run_agent(
|
||||
# generation had silently stopped halfway through. Inspect the
|
||||
# terminal checkpoint before declaring success so the persisted run
|
||||
# state and the user-visible SSE outcome stay consistent.
|
||||
terminal_llm_error = await _terminal_llm_error_reason(
|
||||
checkpointer=checkpointer,
|
||||
thread_id=thread_id,
|
||||
terminal_llm_error = await _await_completion_io(
|
||||
_terminal_llm_error_reason(checkpointer=checkpointer, thread_id=thread_id),
|
||||
run_id=run_id,
|
||||
phase="terminal_checkpoint",
|
||||
)
|
||||
if terminal_llm_error is not None:
|
||||
error_message = "本轮模型生成未能完成,已保留当前对话内容,请稍后重试。"
|
||||
@@ -383,8 +426,9 @@ async def run_agent(
|
||||
run_id,
|
||||
terminal_llm_error,
|
||||
)
|
||||
await run_manager.set_status(
|
||||
run_id,
|
||||
await _set_terminal_status(
|
||||
run_manager,
|
||||
record,
|
||||
RunStatus.error,
|
||||
error=error_message,
|
||||
)
|
||||
@@ -397,12 +441,12 @@ async def run_agent(
|
||||
},
|
||||
)
|
||||
else:
|
||||
await run_manager.set_status(run_id, RunStatus.success)
|
||||
await _set_terminal_status(run_manager, record, RunStatus.success)
|
||||
|
||||
except asyncio.CancelledError:
|
||||
action = record.abort_action
|
||||
if action == "rollback":
|
||||
await run_manager.set_status(run_id, RunStatus.error, error="Rolled back by user")
|
||||
await _set_terminal_status(run_manager, record, RunStatus.error, error="Rolled back by user")
|
||||
try:
|
||||
await _rollback_to_pre_run_checkpoint(
|
||||
checkpointer=checkpointer,
|
||||
@@ -416,13 +460,13 @@ async def run_agent(
|
||||
except Exception:
|
||||
logger.warning("Run %s cancellation rollback failed", run_id, exc_info=True)
|
||||
else:
|
||||
await run_manager.set_status(run_id, RunStatus.interrupted)
|
||||
await _set_terminal_status(run_manager, record, RunStatus.interrupted)
|
||||
logger.info("Run %s was cancelled", run_id)
|
||||
|
||||
except Exception as exc:
|
||||
error_msg = f"{exc}"
|
||||
logger.exception("Run %s failed: %s", run_id, error_msg)
|
||||
await run_manager.set_status(run_id, RunStatus.error, error=error_msg)
|
||||
await _set_terminal_status(run_manager, record, RunStatus.error, error=error_msg)
|
||||
await bridge.publish(
|
||||
run_id,
|
||||
"error",
|
||||
@@ -433,72 +477,170 @@ async def run_agent(
|
||||
)
|
||||
|
||||
finally:
|
||||
# Flush any buffered journal events and persist completion data
|
||||
if journal is not None:
|
||||
try:
|
||||
await journal.flush()
|
||||
except Exception:
|
||||
logger.warning("Failed to flush journal for run %s", run_id, exc_info=True)
|
||||
|
||||
try:
|
||||
# Persist token usage + convenience fields to RunStore
|
||||
completion = journal.get_completion_data()
|
||||
await run_manager.update_run_completion(run_id, status=record.status.value, **completion)
|
||||
except Exception:
|
||||
logger.warning("Failed to persist run completion for %s (non-fatal)", run_id, exc_info=True)
|
||||
|
||||
# Sync title from checkpoint to threads_meta.display_name
|
||||
if checkpointer is not None and thread_store is not None:
|
||||
try:
|
||||
ckpt_config = {"configurable": {"thread_id": thread_id, "checkpoint_ns": ""}}
|
||||
ckpt_tuple = await checkpointer.aget_tuple(ckpt_config)
|
||||
if ckpt_tuple is not None:
|
||||
ckpt = getattr(ckpt_tuple, "checkpoint", {}) or {}
|
||||
channel_values = ckpt.get("channel_values", {}) or {}
|
||||
title = channel_values.get("title")
|
||||
if title:
|
||||
await thread_store.update_display_name(thread_id, title)
|
||||
if (
|
||||
record.status == RunStatus.success
|
||||
and channel_values.get("title_provisional") is True
|
||||
):
|
||||
log_title_debug(
|
||||
"Run %s: scheduling background title generation for thread %s",
|
||||
run_id,
|
||||
thread_id,
|
||||
)
|
||||
title_task = asyncio.create_task(
|
||||
finalize_thread_title(
|
||||
checkpointer=checkpointer,
|
||||
thread_store=thread_store,
|
||||
thread_id=thread_id,
|
||||
source_state=copy.deepcopy(channel_values),
|
||||
app_config=ctx.app_config,
|
||||
),
|
||||
name=f"title-finalize:{thread_id}",
|
||||
)
|
||||
title_task.add_done_callback(_log_background_title_finalize_failure(thread_id))
|
||||
elif record.status == RunStatus.success:
|
||||
log_title_debug(
|
||||
"Run %s: background title generation not scheduled for thread %s because title_provisional=%r title=%r",
|
||||
run_id,
|
||||
thread_id,
|
||||
channel_values.get("title_provisional"),
|
||||
channel_values.get("title"),
|
||||
)
|
||||
except Exception:
|
||||
logger.debug("Failed to sync title for thread %s (non-fatal)", thread_id)
|
||||
|
||||
# Update threads_meta status based on run outcome
|
||||
if thread_store is not None:
|
||||
try:
|
||||
final_status = "idle" if record.status == RunStatus.success else record.status.value
|
||||
await thread_store.update_status(thread_id, final_status)
|
||||
except Exception:
|
||||
logger.debug("Failed to update thread_meta status for %s (non-fatal)", thread_id)
|
||||
|
||||
await bridge.publish_end(run_id)
|
||||
asyncio.create_task(bridge.cleanup(run_id, delay=60))
|
||||
try:
|
||||
await _await_completion_io(
|
||||
_finalize_run(
|
||||
journal=journal,
|
||||
run_manager=run_manager,
|
||||
record=record,
|
||||
ctx=ctx,
|
||||
),
|
||||
run_id=run_id,
|
||||
phase="metadata_cleanup",
|
||||
)
|
||||
except TimeoutError:
|
||||
logger.warning("Run %s completion metadata exceeded its time budget; ending SSE", run_id)
|
||||
except asyncio.CancelledError:
|
||||
# A second cancellation can arrive while handling the original
|
||||
# cancellation or during normal cleanup. Never lose the terminator.
|
||||
logger.info("Run %s completion metadata was cancelled; ending SSE", run_id)
|
||||
except Exception:
|
||||
logger.warning("Failed to finalize run %s (non-fatal)", run_id, exc_info=True)
|
||||
finally:
|
||||
await bridge.publish_end(run_id)
|
||||
asyncio.create_task(bridge.cleanup(run_id, delay=60))
|
||||
|
||||
|
||||
async def _await_completion_io[T](
|
||||
operation: Awaitable[T],
|
||||
*,
|
||||
run_id: str,
|
||||
phase: str,
|
||||
) -> T:
|
||||
"""Bound completion-only I/O even if a backend delays cancellation.
|
||||
|
||||
Unlike wait_for, wait does not wait indefinitely for the cancelled
|
||||
operation to acknowledge cancellation. Do not use this for executing the
|
||||
graph: detaching a live tool would release run concurrency prematurely.
|
||||
"""
|
||||
task = asyncio.ensure_future(operation)
|
||||
_PENDING_COMPLETION_TASKS.add(task)
|
||||
|
||||
def consume_result(completed: asyncio.Future) -> None:
|
||||
_PENDING_COMPLETION_TASKS.discard(completed)
|
||||
if not completed.cancelled():
|
||||
completed.exception()
|
||||
|
||||
task.add_done_callback(consume_result)
|
||||
try:
|
||||
done, _ = await asyncio.wait({task}, timeout=_RUN_FINALIZATION_TIMEOUT_SECONDS)
|
||||
if not done:
|
||||
logger.warning("RUN_COMPLETION_TIMEOUT run_id=%s phase=%s", run_id, phase)
|
||||
raise TimeoutError(f"Run completion timed out during {phase}")
|
||||
return task.result()
|
||||
finally:
|
||||
if not task.done():
|
||||
task.cancel()
|
||||
|
||||
|
||||
async def _set_terminal_status(run_manager: RunManager, record: RunRecord, status: RunStatus, *, error: str | None = None) -> None:
|
||||
try:
|
||||
await _await_completion_io(
|
||||
run_manager.set_status(record.run_id, status, error=error),
|
||||
run_id=record.run_id,
|
||||
phase="terminal_status",
|
||||
)
|
||||
except TimeoutError:
|
||||
# set_status updates the registry before awaiting its best-effort store.
|
||||
# Keep that local outcome authoritative if persistence never returns.
|
||||
record.status = status
|
||||
if error is not None:
|
||||
record.error = error
|
||||
logger.warning("Run %s terminal status persistence timed out", record.run_id)
|
||||
|
||||
|
||||
async def _finalize_run(*, journal: Any, run_manager: RunManager, record: RunRecord, ctx: RunContext) -> None:
|
||||
"""Best-effort metadata writes after graph execution, under one budget."""
|
||||
run_id = record.run_id
|
||||
thread_id = record.thread_id
|
||||
checkpointer = ctx.checkpointer
|
||||
thread_store = ctx.thread_store
|
||||
# Flush any buffered journal events and persist completion data
|
||||
if journal is not None:
|
||||
try:
|
||||
await journal.flush()
|
||||
_check_completion_cancellation()
|
||||
except Exception:
|
||||
logger.warning("Failed to flush journal for run %s", run_id, exc_info=True)
|
||||
|
||||
try:
|
||||
# Persist token usage + convenience fields to RunStore
|
||||
completion = journal.get_completion_data()
|
||||
await run_manager.update_run_completion(run_id, status=record.status.value, **completion)
|
||||
_check_completion_cancellation()
|
||||
except Exception:
|
||||
logger.warning("Failed to persist run completion for %s (non-fatal)", run_id, exc_info=True)
|
||||
|
||||
# Sync title from checkpoint to threads_meta.display_name
|
||||
if checkpointer is not None and thread_store is not None:
|
||||
try:
|
||||
ckpt_config = {"configurable": {"thread_id": thread_id, "checkpoint_ns": ""}}
|
||||
ckpt_tuple = await checkpointer.aget_tuple(ckpt_config)
|
||||
if not await _completion_is_current(run_manager, record):
|
||||
return
|
||||
if ckpt_tuple is not None:
|
||||
ckpt = getattr(ckpt_tuple, "checkpoint", {}) or {}
|
||||
channel_values = ckpt.get("channel_values", {}) or {}
|
||||
title = channel_values.get("title")
|
||||
if title:
|
||||
await thread_store.update_display_name(thread_id, title)
|
||||
if not await _completion_is_current(run_manager, record):
|
||||
return
|
||||
if (
|
||||
record.status == RunStatus.success
|
||||
and channel_values.get("title_provisional") is True
|
||||
):
|
||||
log_title_debug(
|
||||
"Run %s: scheduling background title generation for thread %s",
|
||||
run_id,
|
||||
thread_id,
|
||||
)
|
||||
title_task = asyncio.create_task(
|
||||
finalize_thread_title(
|
||||
checkpointer=checkpointer,
|
||||
thread_store=thread_store,
|
||||
thread_id=thread_id,
|
||||
source_state=copy.deepcopy(channel_values),
|
||||
app_config=ctx.app_config,
|
||||
),
|
||||
name=f"title-finalize:{thread_id}",
|
||||
)
|
||||
title_task.add_done_callback(_log_background_title_finalize_failure(thread_id))
|
||||
elif record.status == RunStatus.success:
|
||||
log_title_debug(
|
||||
"Run %s: background title generation not scheduled for thread %s because title_provisional=%r title=%r",
|
||||
run_id,
|
||||
thread_id,
|
||||
channel_values.get("title_provisional"),
|
||||
channel_values.get("title"),
|
||||
)
|
||||
except Exception:
|
||||
logger.debug("Failed to sync title for thread %s (non-fatal)", thread_id)
|
||||
|
||||
# Update threads_meta status based on run outcome
|
||||
if thread_store is not None:
|
||||
try:
|
||||
if not await _completion_is_current(run_manager, record):
|
||||
return
|
||||
final_status = "idle" if record.status == RunStatus.success else record.status.value
|
||||
await thread_store.update_status(thread_id, final_status)
|
||||
except Exception:
|
||||
logger.debug("Failed to update thread_meta status for %s (non-fatal)", thread_id)
|
||||
|
||||
|
||||
def _check_completion_cancellation() -> None:
|
||||
task = asyncio.current_task()
|
||||
if task is not None and task.cancelling():
|
||||
# Some database adapters delay or suppress cancellation. They must not
|
||||
# resume subsequent title/status writes after the cleanup budget ends.
|
||||
raise asyncio.CancelledError
|
||||
|
||||
|
||||
async def _completion_is_current(run_manager: RunManager, record: RunRecord) -> bool:
|
||||
_check_completion_cancellation()
|
||||
records = await run_manager.list_by_thread(record.thread_id)
|
||||
_check_completion_cancellation()
|
||||
return not records or records[-1].run_id == record.run_id
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
+39
-6
@@ -13,6 +13,8 @@ from __future__ import annotations
|
||||
import dataclasses
|
||||
from typing import Any
|
||||
|
||||
from deerflow.utils.tool_visibility import internal_tool_call_ids, project_outward_messages
|
||||
|
||||
|
||||
def serialize_lc_object(obj: Any) -> Any:
|
||||
"""Recursively serialize a LangChain object to a JSON-serialisable dict."""
|
||||
@@ -72,19 +74,47 @@ def serialize_channel_values(channel_values: dict[str, Any]) -> dict[str, Any]:
|
||||
continue
|
||||
if key == "__interrupt__" and not value:
|
||||
continue
|
||||
result[key] = serialize_lc_object(value)
|
||||
serialized = serialize_lc_object(value)
|
||||
if key == "messages" and isinstance(serialized, list):
|
||||
serialized = project_outward_messages(serialized)
|
||||
result[key] = serialized
|
||||
return result
|
||||
|
||||
|
||||
def serialize_messages_tuple(obj: Any) -> Any:
|
||||
def serialize_messages_tuple(
|
||||
obj: Any,
|
||||
*,
|
||||
known_internal_tool_call_ids: set[str] | None = None,
|
||||
) -> Any:
|
||||
"""Serialize a messages-mode tuple ``(chunk, metadata)``."""
|
||||
if isinstance(obj, tuple) and len(obj) == 2:
|
||||
chunk, metadata = obj
|
||||
return [serialize_lc_object(chunk), metadata if isinstance(metadata, dict) else {}]
|
||||
return serialize_lc_object(obj)
|
||||
serialized_chunk = serialize_lc_object(chunk)
|
||||
if known_internal_tool_call_ids is not None:
|
||||
known_internal_tool_call_ids.update(
|
||||
internal_tool_call_ids([serialized_chunk])
|
||||
)
|
||||
projected = project_outward_messages(
|
||||
[serialized_chunk],
|
||||
known_internal_tool_call_ids=known_internal_tool_call_ids or (),
|
||||
)
|
||||
if not projected:
|
||||
if isinstance(serialized_chunk, dict):
|
||||
known_id = str(serialized_chunk.get("tool_call_id") or "")
|
||||
if known_internal_tool_call_ids is not None:
|
||||
known_internal_tool_call_ids.discard(known_id)
|
||||
return None
|
||||
return [projected[0], metadata if isinstance(metadata, dict) else {}]
|
||||
projected = project_outward_messages([serialize_lc_object(obj)])
|
||||
return projected[0] if projected else None
|
||||
|
||||
|
||||
def serialize(obj: Any, *, mode: str = "") -> Any:
|
||||
def serialize(
|
||||
obj: Any,
|
||||
*,
|
||||
mode: str = "",
|
||||
known_internal_tool_call_ids: set[str] | None = None,
|
||||
) -> Any:
|
||||
"""Serialize LangChain objects with mode-specific handling.
|
||||
|
||||
* ``messages`` — obj is ``(message_chunk, metadata_dict)``
|
||||
@@ -92,7 +122,10 @@ def serialize(obj: Any, *, mode: str = "") -> Any:
|
||||
* everything else — recursive ``model_dump()`` / ``dict()`` fallback
|
||||
"""
|
||||
if mode == "messages":
|
||||
return serialize_messages_tuple(obj)
|
||||
return serialize_messages_tuple(
|
||||
obj,
|
||||
known_internal_tool_call_ids=known_internal_tool_call_ids,
|
||||
)
|
||||
if mode == "values":
|
||||
return serialize_channel_values(obj) if isinstance(obj, dict) else serialize_lc_object(obj)
|
||||
return serialize_lc_object(obj)
|
||||
+19
@@ -0,0 +1,19 @@
|
||||
"""Task-analysis runtime package (external-task scheduled chain analysis)."""
|
||||
|
||||
from deerflow.runtime.task_analysis.data_delivery import (
|
||||
block_defs_payload,
|
||||
period_detail_payload,
|
||||
periods_payload,
|
||||
submit_block_data,
|
||||
)
|
||||
from deerflow.runtime.task_analysis.executor import ChainBindingExecutor
|
||||
from deerflow.runtime.task_analysis.service import TaskAnalysisService
|
||||
|
||||
__all__ = [
|
||||
"ChainBindingExecutor",
|
||||
"TaskAnalysisService",
|
||||
"block_defs_payload",
|
||||
"period_detail_payload",
|
||||
"periods_payload",
|
||||
"submit_block_data",
|
||||
]
|
||||
+176
@@ -0,0 +1,176 @@
|
||||
"""Scheduled data-delivery domain logic(定时数据交付:任务 6 块 JSON).
|
||||
|
||||
职责边界(已定稿口径):
|
||||
- 只做数据管道 + 调度;智能体干完活调技能入库,归配智能体/业务链的人管。
|
||||
- 不做席位↔块映射(多个智能体可各写一个块的不同部分,一个智能体也可写多个块),
|
||||
不做收口兜底。
|
||||
- 块 key 定死 ``block_1``~``block_6``;payload 不做 schema 校验,只要求是 JSON 对象。
|
||||
- 合并规则:顶层 key 合并、同 key 后写覆盖;块 payload 由提交流水按序合并得出
|
||||
(每次提交后从流水重算落库,天然规避并发读改写丢片段)。
|
||||
- 不挂时间轴:任务的数据只有一份「当前状态」,所有提交都合并进它;首次提交时
|
||||
若还没有承载记录,自动开一条(trigger=external),保证写入永远成功。
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
from typing import Any
|
||||
|
||||
from deerflow.persistence.task_analysis.base import TaskAnalysisStore
|
||||
from deerflow.persistence.task_analysis.data_blocks import (
|
||||
PERIOD_TRIGGER_EXTERNAL,
|
||||
merge_payload,
|
||||
)
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
async def submit_block_data(
|
||||
store: TaskAnalysisStore,
|
||||
*,
|
||||
task_id: str,
|
||||
block_key: str,
|
||||
data: Any,
|
||||
submitted_by: str | None = None,
|
||||
) -> dict[str, Any]:
|
||||
"""提交一块数据片段 → 落当前期 + 按流水重算合并结果。
|
||||
|
||||
Raises:
|
||||
ValueError: payload 不是 JSON 对象,或 block_key 不在块定义内。
|
||||
"""
|
||||
if not isinstance(data, dict):
|
||||
raise ValueError("payload 必须是 JSON 对象(不接受数组/字符串/数字)")
|
||||
block_key = str(block_key or "").strip()
|
||||
|
||||
defs = await store.ensure_block_defs(task_id)
|
||||
known = {definition["block_key"] for definition in defs}
|
||||
if block_key not in known:
|
||||
raise ValueError(f"未知数据块 {block_key or '(空)'};可用块:{', '.join(sorted(known))}")
|
||||
|
||||
period = await store.current_period(task_id)
|
||||
if period is None:
|
||||
period = await store.open_period(task_id, source=PERIOD_TRIGGER_EXTERNAL)
|
||||
period_index = int(period["period_index"])
|
||||
|
||||
await store.append_submission(
|
||||
task_id, period_index, block_key, data, submitted_by=submitted_by
|
||||
)
|
||||
|
||||
# 从流水按序重算(而非增量合并现值):并发提交下最终状态仍收敛到流水顺序。
|
||||
merged: dict[str, Any] = {}
|
||||
for submission in await store.list_submissions(task_id, period_index, block_key):
|
||||
fragment = submission.get("payload")
|
||||
if isinstance(fragment, dict):
|
||||
merged = merge_payload(merged, fragment)
|
||||
block = await store.upsert_period_block(task_id, period_index, block_key, merged)
|
||||
return {
|
||||
"block_key": block_key,
|
||||
"period_index": period_index,
|
||||
"updated_at": block["updated_at"],
|
||||
"keys": sorted(merged.keys()),
|
||||
}
|
||||
|
||||
|
||||
def _task_brief(task: dict[str, Any]) -> dict[str, Any]:
|
||||
return {
|
||||
"task_id": task["id"],
|
||||
"source_task_id": task["source_task_id"],
|
||||
"name": task["name"],
|
||||
}
|
||||
|
||||
|
||||
async def block_defs_payload(store: TaskAnalysisStore, task: dict[str, Any]) -> dict[str, Any]:
|
||||
"""GET …/blocks 响应:块定义列表(建任务自动种 6 条,旧任务懒补缺失 key)。"""
|
||||
defs = await store.ensure_block_defs(task["id"])
|
||||
return {
|
||||
"task": _task_brief(task),
|
||||
"blocks": [
|
||||
{
|
||||
"block_key": definition["block_key"],
|
||||
"title": definition["title"],
|
||||
"sort_order": definition["sort_order"],
|
||||
}
|
||||
for definition in defs
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
async def periods_payload(store: TaskAnalysisStore, task: dict[str, Any], *, limit: int = 500) -> dict[str, Any]:
|
||||
"""GET …/periods 响应(兼容旧路径):只返回任务当前的数据承载记录(最新一期)。
|
||||
|
||||
时间轴维度已去掉:任务的数据只有一份当前状态;存量任务的历史期保留在表里
|
||||
但不再对外暴露,读历史接口(periods/{n})仍可按期号访问。
|
||||
"""
|
||||
defs = await store.ensure_block_defs(task["id"])
|
||||
def_keys = [definition["block_key"] for definition in defs]
|
||||
current = await store.current_period(task["id"])
|
||||
blocks = await store.list_task_blocks(task["id"])
|
||||
|
||||
updated_by_period: dict[int, dict[str, str | None]] = {}
|
||||
for block in blocks:
|
||||
updated_by_period.setdefault(int(block["period_index"]), {})[block["block_key"]] = block.get("updated_at")
|
||||
|
||||
if current is None:
|
||||
return {"task": _task_brief(task), "current_period_index": None, "total": 0, "periods": []}
|
||||
current_index = int(current["period_index"])
|
||||
return {
|
||||
"task": _task_brief(task),
|
||||
"current_period_index": current_index,
|
||||
"total": 1,
|
||||
"periods": [
|
||||
{
|
||||
"period_index": current["period_index"],
|
||||
"opened_at": current["opened_at"],
|
||||
"trigger": current["trigger"],
|
||||
"run_id": current.get("run_id"),
|
||||
"is_current": True,
|
||||
"blocks": {
|
||||
key: {"updated_at": updated_by_period.get(current_index, {}).get(key)}
|
||||
for key in def_keys
|
||||
},
|
||||
}
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
async def period_detail_payload(store: TaskAnalysisStore, task: dict[str, Any], period_ref: str) -> dict[str, Any] | None:
|
||||
"""GET …/periods/{n|latest} 响应:该期 6 块完整 JSON + 各块 updated_at。
|
||||
|
||||
期不存在返回 None(路由转 404)。
|
||||
"""
|
||||
defs = await store.ensure_block_defs(task["id"])
|
||||
if period_ref == "latest":
|
||||
period = await store.current_period(task["id"])
|
||||
else:
|
||||
period = await store.get_period(task["id"], int(period_ref))
|
||||
if period is None:
|
||||
return None
|
||||
|
||||
period_index = int(period["period_index"])
|
||||
blocks = {
|
||||
block["block_key"]: block
|
||||
for block in await store.list_task_blocks(task["id"])
|
||||
if int(block["period_index"]) == period_index
|
||||
}
|
||||
current = await store.current_period(task["id"])
|
||||
current_index = int(current["period_index"]) if current else None
|
||||
return {
|
||||
"task": _task_brief(task),
|
||||
"period": {
|
||||
"period_index": period_index,
|
||||
"opened_at": period["opened_at"],
|
||||
"trigger": period["trigger"],
|
||||
"run_id": period.get("run_id"),
|
||||
"is_current": current_index is not None and period_index == current_index,
|
||||
},
|
||||
"blocks": [
|
||||
{
|
||||
"block_key": definition["block_key"],
|
||||
"title": definition["title"],
|
||||
"sort_order": definition["sort_order"],
|
||||
"payload": (blocks.get(definition["block_key"]) or {}).get("payload"),
|
||||
"updated_at": (blocks.get(definition["block_key"]) or {}).get("updated_at"),
|
||||
}
|
||||
for definition in defs
|
||||
],
|
||||
}
|
||||
+979
@@ -0,0 +1,979 @@
|
||||
"""Chain-binding orchestration executor for the task-analysis feature.
|
||||
|
||||
Runs one binding run stage-by-stage following the business-chain snapshot:
|
||||
seats within a stage run in parallel (each on its own lead-agent thread with
|
||||
``execution_context.agent_name`` pointing at the seat agent — the same in-process
|
||||
``start_run`` trick ``ScheduledTaskService._start_agent_run`` uses), stages run
|
||||
serially. Later seats receive prior seats' **full** deliveries (same contract as
|
||||
roundtable Step 2 ``_seat_message``), plus the chain's per-stage receive/produce
|
||||
goals, a structured delivery template, skill-directive assist, and a role boundary.
|
||||
|
||||
Process messages (input / llm.ai / artifact per seat) are flushed as they
|
||||
happen. While a seat is still running, ``GET /runs/{id}/messages`` also reads
|
||||
the live RunEventStore / checkpoint (same source as scheduled-task run detail)
|
||||
so the frontend's 5-second poll shows in-flight LLM turns and tool calls.
|
||||
Before the stages run, a dedicated
|
||||
built-in coordinator (``task-analysis-coordinator``, unattended: no clarification)
|
||||
reads the task context and emits a concrete per-seat task via the
|
||||
``agent_orchestration`` tool; each seat then executes that assigned task.
|
||||
Coordinator failure degrades to the same duty / stage / delivery contract
|
||||
without a coordinator-assigned task.
|
||||
|
||||
One content "timeline" version row is written per successful run.
|
||||
|
||||
A seat may fail without sinking the whole run: failed seats are marked, later
|
||||
stages are skipped, and the already-completed stages still land a (partial)
|
||||
content version — the partial-success semantics agreed for this feature.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import logging
|
||||
import time
|
||||
from datetime import UTC, datetime
|
||||
from typing import Any
|
||||
|
||||
from deerflow.persistence.task_analysis.base import TaskAnalysisStore
|
||||
from deerflow.runtime.task_analysis.thread_metadata import task_analysis_thread_metadata
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
COORDINATOR_SEAT = "__coordinator__"
|
||||
MARKDOWN_BLOCK_MAX_CHARS = 24000
|
||||
PRIOR_DELIVERY_MAX_CHARS = 8000
|
||||
|
||||
# 对齐会商第二步 ``useStep2Orchestration`` 的 ``SEAT_DELIVERY_GUIDE``:席位必须知道
|
||||
# 「产出长什么样」,否则只会复述任务简介。
|
||||
SEAT_DELIVERY_GUIDE = (
|
||||
"【交付要求】请直接基于已知信息做出合理假设、给出完整交付,**不要向用户提问或等待确认**;"
|
||||
"承接此前各席位的交付,不要重复或推翻已有结论。"
|
||||
"交付请按以下结构组织:① 一句话核心结论(先行);② 关键要点(分条列出);"
|
||||
"③ 风险 / 注意事项(如有);④ 与其它席位的依赖 / 承接关系(如有)。"
|
||||
)
|
||||
|
||||
# 对齐会商第二步 ``engine._SEAT_NO_ASK``:无人值守、正文必须带交付、同时落盘 outputs。
|
||||
SEAT_NO_ASK = (
|
||||
"注意:这是自动化任务分析,没有用户在线应答——**请勿向用户提问或等待确认**,"
|
||||
"直接基于已知信息做出合理假设,产出完整的结构化交付。\n"
|
||||
"**交付方式**:请用 write_file 工具把你这一轮的完整交付整理成一份 "
|
||||
"Markdown 文件,写入 /mnt/user-data/outputs/ 下(文件名体现你的职责,如 `情报收集.md`、"
|
||||
"`风险评估.md`);同时在回复正文里给出这份交付的内容本身(供后续席位承接),"
|
||||
"不要只回复『已写入文件』这类空话。"
|
||||
)
|
||||
|
||||
|
||||
class _RuntimeUser:
|
||||
"""Minimal user stand-in for in-process runs (mirrors scheduler service)."""
|
||||
|
||||
def __init__(self, id: str) -> None: # noqa: A002 - mirror scheduler API
|
||||
self.id = id
|
||||
|
||||
|
||||
def _goal_text(value: Any) -> str:
|
||||
text = str(value or "").strip()
|
||||
return text
|
||||
|
||||
|
||||
def _prior_deliveries_block(
|
||||
stage_outputs: list[tuple[str, str]], max_chars: int = PRIOR_DELIVERY_MAX_CHARS
|
||||
) -> str:
|
||||
"""Full prior-seat deliveries, matching roundtable ``_deliveries_block`` (not a 600-char digest)."""
|
||||
parts: list[str] = []
|
||||
for seat_name, text in stage_outputs:
|
||||
clipped = (text or "").strip()
|
||||
if not clipped:
|
||||
continue
|
||||
if len(clipped) > max_chars:
|
||||
clipped = clipped[:max_chars] + "…"
|
||||
parts.append(f"### {seat_name}\n{clipped}")
|
||||
return "\n\n".join(parts)
|
||||
|
||||
|
||||
def _stage_receive_text(
|
||||
*,
|
||||
stage_index: int,
|
||||
prev_goal: str | None,
|
||||
task: dict[str, Any],
|
||||
) -> str:
|
||||
if stage_index <= 0:
|
||||
name = str(task.get("name") or "").strip() or "(未命名)"
|
||||
desc = str(task.get("description") or "").strip() or "(无简介)"
|
||||
return f"外部任务「{name}」及其简介:{desc}"
|
||||
if prev_goal:
|
||||
return f"上一阶段目标「{prev_goal}」,以及下方「前序各席位已完成的交付」全文"
|
||||
return "上一阶段各席位的交付全文(见下方)"
|
||||
|
||||
|
||||
def _stage_produce_text(*, stage_goal: str | None, seat_description: str, seat_name: str) -> str:
|
||||
if stage_goal:
|
||||
return stage_goal
|
||||
if seat_description:
|
||||
return f"按席位职责完成交付:{seat_description}"
|
||||
return f"按「{seat_name}」的专业职责给出完整结构化交付"
|
||||
|
||||
|
||||
def _fallback_seat_task(
|
||||
*,
|
||||
seat_name: str,
|
||||
seat_description: str,
|
||||
stage_receive: str,
|
||||
stage_produce: str,
|
||||
) -> str:
|
||||
duty = seat_description or f"作为「{seat_name}」完成你的专业职责"
|
||||
return (
|
||||
"总控本轮未能完成派活。请按席位职责与阶段契约自行完成交付,不要空等总控。\n"
|
||||
f"职责:{duty}\n"
|
||||
f"本阶段接收:{stage_receive}\n"
|
||||
f"本阶段产出:{stage_produce}\n"
|
||||
"请给出完整结构化交付,不要向用户提问。"
|
||||
)
|
||||
|
||||
|
||||
def _strip_display_suffix(agent_name: str) -> str:
|
||||
# 兼容「<id>(中文名)」形式的派活(与会商 _strip_display_suffix 同语义)。
|
||||
return agent_name.split("<")[0].split("(")[0].strip()
|
||||
|
||||
|
||||
def _coerce_tool_call(call: Any) -> dict[str, Any] | None:
|
||||
"""LangChain ToolCall 可能是 dict,也可能是带 name/args 属性的对象。"""
|
||||
if isinstance(call, dict):
|
||||
name = call.get("name") or (call.get("function") or {}).get("name")
|
||||
args = call.get("args")
|
||||
if args is None:
|
||||
args = (call.get("function") or {}).get("arguments")
|
||||
if not name:
|
||||
return None
|
||||
return {"name": name, "args": args or {}}
|
||||
name = getattr(call, "name", None)
|
||||
args = getattr(call, "args", None)
|
||||
if not name:
|
||||
return None
|
||||
return {"name": name, "args": args or {}}
|
||||
|
||||
|
||||
def _parse_orchestration_calls(
|
||||
tool_calls: list[Any], valid_ids: set[str]
|
||||
) -> dict[str, str]:
|
||||
"""从总控 tool_calls 解析 agent_orchestration 派活 → {seat_id: task}。"""
|
||||
dispatch: dict[str, str] = {}
|
||||
for raw in tool_calls:
|
||||
call = _coerce_tool_call(raw)
|
||||
if call is None:
|
||||
continue
|
||||
name = str(call.get("name") or "").lower()
|
||||
if name != "agent_orchestration":
|
||||
continue
|
||||
args = call.get("args")
|
||||
if isinstance(args, str):
|
||||
import json as _json
|
||||
|
||||
try:
|
||||
args = _json.loads(args)
|
||||
except (TypeError, ValueError):
|
||||
continue
|
||||
if not isinstance(args, dict):
|
||||
continue
|
||||
agent = _strip_display_suffix(str(args.get("agent_name") or "").strip())
|
||||
task_text = str(args.get("task") or "").strip()
|
||||
if agent in valid_ids and task_text and agent not in dispatch:
|
||||
dispatch[agent] = task_text
|
||||
return dispatch
|
||||
|
||||
|
||||
class ChainBindingExecutor:
|
||||
"""Executes one ``task_analysis_runs`` row against a binding snapshot."""
|
||||
|
||||
def __init__(self, app: Any, store: TaskAnalysisStore) -> None:
|
||||
self.app = app
|
||||
self.store = store
|
||||
|
||||
# ── public entry ────────────────────────────────────────────────────────
|
||||
|
||||
async def execute(self, run: dict[str, Any], binding: dict[str, Any], task: dict[str, Any]) -> None:
|
||||
run_id = run["id"]
|
||||
await self.store.update_run(run_id, {"status": "running"})
|
||||
stages: list[list[str]] = run.get("stages_snapshot") or []
|
||||
seat_names: dict[str, str] = run.get("seat_names_snapshot") or {}
|
||||
stage_goals: list[Any] = run.get("stage_goals_snapshot") or []
|
||||
user_id = binding.get("created_by") or ""
|
||||
|
||||
started = time.monotonic()
|
||||
seat_results: dict[str, dict[str, Any]] = {}
|
||||
snapshot_seats = (binding.get("chain_snapshot") or {}).get("seats") or []
|
||||
descriptions = {
|
||||
seat.get("agent_id"): str(seat.get("description") or "") for seat in snapshot_seats
|
||||
}
|
||||
# 过程消息即时落库(逐段 flush),前端 5 秒轮询就能看到执行中的动态;
|
||||
# 落库失败仅记日志,绝不影响执行。
|
||||
async def emit(messages: list[dict[str, Any]]) -> None:
|
||||
if not messages:
|
||||
return
|
||||
try:
|
||||
await self.store.append_run_messages(run_id, messages)
|
||||
except Exception:
|
||||
logger.exception("task-analysis run %s message persist failed", run_id)
|
||||
stage_outputs: list[tuple[str, str]] = []
|
||||
failed = False
|
||||
run_error: str | None = None
|
||||
|
||||
try:
|
||||
# 流程图先把总控标成执行中、席位等待,避免前端把「run=running 且席位未开始」
|
||||
# 误显示成总控还在跑、同时席位已经开了。
|
||||
seat_results[COORDINATOR_SEAT] = {
|
||||
"state": "running",
|
||||
"duration_ms": 0,
|
||||
"thread_id": None,
|
||||
"seat_name": "总控",
|
||||
"error": None,
|
||||
}
|
||||
for stage in stages:
|
||||
for seat_id in stage:
|
||||
seat_results[seat_id] = {
|
||||
"state": "waiting",
|
||||
"duration_ms": 0,
|
||||
"thread_id": None,
|
||||
"error": None,
|
||||
}
|
||||
await self._flush_seat_results(run_id, seat_results)
|
||||
|
||||
async def note_live(
|
||||
seat_id: str,
|
||||
*,
|
||||
thread_id: str | None = None,
|
||||
agent_run_id: str | None = None,
|
||||
) -> None:
|
||||
await self._note_live(
|
||||
run_id,
|
||||
seat_results,
|
||||
seat_id,
|
||||
thread_id=thread_id,
|
||||
agent_run_id=agent_run_id,
|
||||
)
|
||||
|
||||
coord_started = time.monotonic()
|
||||
seat_tasks = await self._coordinator_dispatch(
|
||||
run=run,
|
||||
binding=binding,
|
||||
task=task,
|
||||
user_id=user_id,
|
||||
emit=emit,
|
||||
note_live=note_live,
|
||||
)
|
||||
coord_ms = int((time.monotonic() - coord_started) * 1000)
|
||||
prev_coord = dict(seat_results.get(COORDINATOR_SEAT) or {})
|
||||
if seat_tasks:
|
||||
seat_results[COORDINATOR_SEAT] = {
|
||||
**prev_coord,
|
||||
"state": "done",
|
||||
"duration_ms": coord_ms,
|
||||
"seat_name": "总控",
|
||||
"error": None,
|
||||
}
|
||||
await emit([{
|
||||
"seat_agent_id": COORDINATOR_SEAT,
|
||||
"stage_index": 0,
|
||||
"event_type": "artifact",
|
||||
"content": "【总控派活】\n"
|
||||
+ "\n".join(
|
||||
f"→ {seat_names.get(sid, sid)}:{text[:400]}"
|
||||
for sid, text in seat_tasks.items()
|
||||
),
|
||||
}])
|
||||
else:
|
||||
prev_coord = dict(seat_results.get(COORDINATOR_SEAT) or {})
|
||||
seat_results[COORDINATOR_SEAT] = {
|
||||
**prev_coord,
|
||||
"state": "failed",
|
||||
"duration_ms": coord_ms,
|
||||
"seat_name": "总控",
|
||||
"error": "总控未产生有效派活,席位将按阶段契约自行执行",
|
||||
}
|
||||
await emit([{
|
||||
"seat_agent_id": COORDINATOR_SEAT,
|
||||
"stage_index": 0,
|
||||
"event_type": "artifact",
|
||||
"content": "【总控未派活】未拿到各席位具体任务。后续席位按业务链职责与阶段契约自行交付,不会在总控还在跑时抢跑。",
|
||||
}])
|
||||
await self._flush_seat_results(run_id, seat_results)
|
||||
|
||||
for stage_index, stage in enumerate(stages):
|
||||
if failed:
|
||||
for seat_id in stage:
|
||||
seat_results[seat_id] = {
|
||||
"state": "waiting",
|
||||
"duration_ms": 0,
|
||||
"thread_id": None,
|
||||
"error": None,
|
||||
}
|
||||
continue
|
||||
|
||||
goal = _goal_text(stage_goals[stage_index]) if stage_index < len(stage_goals) else ""
|
||||
prev_goal = (
|
||||
_goal_text(stage_goals[stage_index - 1])
|
||||
if stage_index > 0 and stage_index - 1 < len(stage_goals)
|
||||
else ""
|
||||
)
|
||||
for seat_id in stage:
|
||||
current = dict(seat_results.get(seat_id) or {})
|
||||
current["state"] = "running"
|
||||
seat_results[seat_id] = current
|
||||
await self._flush_seat_results(run_id, seat_results)
|
||||
|
||||
results = await asyncio.gather(
|
||||
*[
|
||||
self._run_seat(
|
||||
run_id=run_id,
|
||||
seat_id=seat_id,
|
||||
seat_name=seat_names.get(seat_id, seat_id),
|
||||
seat_description=descriptions.get(seat_id) or "",
|
||||
stage_index=stage_index,
|
||||
stage_goal=goal or None,
|
||||
prev_goal=prev_goal or None,
|
||||
task=task,
|
||||
binding=binding,
|
||||
prior_deliveries=list(stage_outputs),
|
||||
seat_task=seat_tasks.get(seat_id),
|
||||
user_id=user_id,
|
||||
emit=emit,
|
||||
note_live=note_live,
|
||||
)
|
||||
for seat_id in stage
|
||||
],
|
||||
return_exceptions=True,
|
||||
)
|
||||
|
||||
stage_failed = False
|
||||
for seat_id, result in zip(stage, results, strict=False):
|
||||
if isinstance(result, BaseException):
|
||||
logger.exception(
|
||||
"task-analysis seat %s crashed (run %s)", seat_id, run_id
|
||||
)
|
||||
seat_results[seat_id] = {
|
||||
"state": "failed",
|
||||
"duration_ms": 0,
|
||||
"thread_id": None,
|
||||
"error": str(result),
|
||||
}
|
||||
stage_failed = True
|
||||
else:
|
||||
seat_results[seat_id] = result
|
||||
if result["state"] == "failed":
|
||||
stage_failed = True
|
||||
elif result.get("delivery"):
|
||||
stage_outputs.append(
|
||||
(result.get("seat_name") or seat_id, result["delivery"])
|
||||
)
|
||||
if stage_failed:
|
||||
failed = True
|
||||
run_error = f"阶段 {stage_index + 1} 存在失败席位,后续阶段已跳过"
|
||||
|
||||
status = "failed" if failed and not stage_outputs else ("partial" if failed else "succeeded")
|
||||
await self._finish_run(
|
||||
run=run,
|
||||
task=task,
|
||||
status=status,
|
||||
seat_results=seat_results,
|
||||
seat_names=seat_names,
|
||||
error=run_error,
|
||||
duration_ms=int((time.monotonic() - started) * 1000),
|
||||
)
|
||||
except Exception as exc: # noqa: BLE001 - top-level guard for the run
|
||||
logger.exception("task-analysis run %s crashed", run_id)
|
||||
await self._finish_run(
|
||||
run=run,
|
||||
task=task,
|
||||
status="failed",
|
||||
seat_results=seat_results,
|
||||
seat_names=seat_names,
|
||||
error=str(exc),
|
||||
duration_ms=int((time.monotonic() - started) * 1000),
|
||||
)
|
||||
|
||||
# ── single seat ─────────────────────────────────────────────────────────
|
||||
|
||||
async def _run_seat(
|
||||
self,
|
||||
*,
|
||||
run_id: str,
|
||||
seat_id: str,
|
||||
seat_name: str,
|
||||
seat_description: str,
|
||||
stage_index: int,
|
||||
stage_goal: str | None,
|
||||
prev_goal: str | None,
|
||||
task: dict[str, Any],
|
||||
binding: dict[str, Any],
|
||||
prior_deliveries: list[tuple[str, str]],
|
||||
seat_task: str | None,
|
||||
user_id: str,
|
||||
emit,
|
||||
note_live=None,
|
||||
) -> dict[str, Any]:
|
||||
thread_id = f"ta-seat-{seat_id}-{int(time.time() * 1000)}"
|
||||
thread_metadata = task_analysis_thread_metadata(
|
||||
task,
|
||||
run_id=run_id,
|
||||
role="seat",
|
||||
seat_id=seat_id,
|
||||
)
|
||||
prompt = self._build_seat_prompt(
|
||||
task=task,
|
||||
binding=binding,
|
||||
seat_name=seat_name,
|
||||
seat_description=seat_description,
|
||||
stage_index=stage_index,
|
||||
stage_goal=stage_goal,
|
||||
prev_goal=prev_goal,
|
||||
prior_deliveries=prior_deliveries,
|
||||
seat_task=seat_task,
|
||||
)
|
||||
prompt = self._apply_seat_assist(seat_id, prompt)
|
||||
if note_live is not None:
|
||||
await note_live(seat_id, thread_id=thread_id)
|
||||
await emit(
|
||||
[{"seat_agent_id": seat_id, "stage_index": stage_index, "event_type": "input", "content": prompt}]
|
||||
)
|
||||
started = time.monotonic()
|
||||
try:
|
||||
record = await self._start_seat_run(
|
||||
seat_id=seat_id, prompt=prompt, thread_id=thread_id, user_id=user_id,
|
||||
run_meta={"binding_id": binding["id"]},
|
||||
thread_metadata=thread_metadata,
|
||||
model_name=binding.get("model") or "",
|
||||
)
|
||||
if note_live is not None and record is not None:
|
||||
await note_live(
|
||||
seat_id,
|
||||
thread_id=thread_id,
|
||||
agent_run_id=getattr(record, "run_id", None),
|
||||
)
|
||||
# start_run 异步启动即返回;record.task 是执行任务,等它完成再取交付。
|
||||
if record is not None and getattr(record, "task", None) is not None:
|
||||
await record.task
|
||||
run_error = getattr(record, "error", None) if record is not None else None
|
||||
run_status = str(getattr(record, "status", "") or "") if record is not None else ""
|
||||
agent_run_id = getattr(record, "run_id", None) if record is not None else None
|
||||
delivery = await self._await_delivery(thread_id)
|
||||
duration_ms = int((time.monotonic() - started) * 1000)
|
||||
if delivery is None:
|
||||
detail = run_error or f"席位执行结束但未产生文字交付(run 状态 {run_status or 'unknown'})"
|
||||
return {
|
||||
"state": "failed",
|
||||
"duration_ms": duration_ms,
|
||||
"thread_id": thread_id,
|
||||
"agent_run_id": agent_run_id,
|
||||
"seat_name": seat_name,
|
||||
"delivery": None,
|
||||
"error": detail,
|
||||
}
|
||||
await emit(
|
||||
[{"seat_agent_id": seat_id, "stage_index": stage_index, "event_type": "llm.ai", "content": delivery}]
|
||||
)
|
||||
return {
|
||||
"state": "done",
|
||||
"duration_ms": duration_ms,
|
||||
"thread_id": thread_id,
|
||||
"agent_run_id": agent_run_id,
|
||||
"seat_name": seat_name,
|
||||
"delivery": delivery,
|
||||
"error": None,
|
||||
}
|
||||
except Exception as exc: # noqa: BLE001 - per-seat isolation
|
||||
logger.exception("task-analysis seat %s failed", seat_id)
|
||||
return {
|
||||
"state": "failed",
|
||||
"duration_ms": int((time.monotonic() - started) * 1000),
|
||||
"thread_id": thread_id,
|
||||
"seat_name": seat_name,
|
||||
"delivery": None,
|
||||
"error": str(exc),
|
||||
}
|
||||
|
||||
@staticmethod
|
||||
def _apply_seat_assist(seat_id: str, prompt: str) -> str:
|
||||
"""对齐会商第二步:技能识别强化(无人值守必须用技能)+ 席位角色边界。"""
|
||||
try:
|
||||
from app.gateway.roundtable_seat_skills import (
|
||||
append_seat_role_boundary,
|
||||
append_seat_skill_directive,
|
||||
)
|
||||
|
||||
prompt = append_seat_skill_directive(seat_id, prompt, chain_enabled=True)
|
||||
return append_seat_role_boundary(prompt)
|
||||
except Exception:
|
||||
logger.debug("task-analysis seat assist inject failed for %s", seat_id, exc_info=True)
|
||||
return prompt
|
||||
|
||||
def _build_seat_prompt(
|
||||
self,
|
||||
*,
|
||||
task: dict[str, Any],
|
||||
binding: dict[str, Any],
|
||||
seat_name: str,
|
||||
seat_description: str,
|
||||
stage_index: int,
|
||||
stage_goal: str | None,
|
||||
prev_goal: str | None,
|
||||
prior_deliveries: list[tuple[str, str]],
|
||||
seat_task: str | None = None,
|
||||
) -> str:
|
||||
"""对齐会商第二步 ``_seat_message``:背景 + 职责 + 阶段接收/产出 + 前序全文 + 本轮任务 + 交付模板。"""
|
||||
stage_receive = _stage_receive_text(stage_index=stage_index, prev_goal=prev_goal, task=task)
|
||||
stage_produce = _stage_produce_text(
|
||||
stage_goal=stage_goal, seat_description=seat_description, seat_name=seat_name
|
||||
)
|
||||
assigned = (seat_task or "").strip()
|
||||
concrete_task = assigned or _fallback_seat_task(
|
||||
seat_name=seat_name,
|
||||
seat_description=seat_description,
|
||||
stage_receive=stage_receive,
|
||||
stage_produce=stage_produce,
|
||||
)
|
||||
|
||||
background = [
|
||||
f"外部任务:{task.get('name', '')}(任务号 {task.get('source_task_id', '')})",
|
||||
f"任务简介:{task.get('description') or '(无)'}",
|
||||
# 显式键值形式的外部任务号:task-data-submit 技能的 --task-id 参数直接取这一行。
|
||||
f"数据交付 task_id(调用 task-data-submit 技能入库时的 --task-id 参数):{task.get('source_task_id', '')}",
|
||||
]
|
||||
notes = binding.get("direction_notes") or []
|
||||
if notes:
|
||||
background.append("执行方向备注(历次问答沉淀):\n" + "\n".join(f"- {n}" for n in notes))
|
||||
coordinator_prompt = binding.get("coordinator_prompt")
|
||||
if coordinator_prompt:
|
||||
background.append(f"总控提示:{coordinator_prompt}")
|
||||
|
||||
duty = (seat_description or "").strip() or f"作为「{seat_name}」完成你的专业职责"
|
||||
# 总控派活必须放在最前面:抽屉默认看到的第一段就是「我要干什么」,
|
||||
# 避免席位把背景/职责复述一遍却找不到本轮任务。
|
||||
if assigned:
|
||||
lead = "【总控派给你的本轮任务 — 必须按此执行,不要自行改题】\n" + concrete_task
|
||||
else:
|
||||
lead = "【总控本轮未能完成派活 — 请按席位职责与阶段契约自行交付】\n" + concrete_task
|
||||
parts = [
|
||||
lead,
|
||||
"【本次任务背景】\n" + "\n".join(background),
|
||||
f"【你的席位职责】\n你是「{seat_name}」。{duty}\n请严格按该席位的专业角色完成本轮交付,不要越权做总控或其它席位的工作。",
|
||||
f"【本阶段契约】\n本阶段接收:{stage_receive}\n本阶段产出:{stage_produce}",
|
||||
]
|
||||
prior_block = _prior_deliveries_block(prior_deliveries)
|
||||
if prior_block:
|
||||
parts.append(
|
||||
"【前序各席位已完成的交付,请在此基础上承接、补充、不要重复或推翻】\n" + prior_block
|
||||
)
|
||||
parts.append(SEAT_DELIVERY_GUIDE)
|
||||
parts.append(SEAT_NO_ASK)
|
||||
return "\n\n---\n\n".join(parts)
|
||||
|
||||
async def _start_seat_run(
|
||||
self,
|
||||
*,
|
||||
seat_id: str,
|
||||
prompt: str,
|
||||
thread_id: str,
|
||||
user_id: str,
|
||||
run_meta: dict[str, Any],
|
||||
thread_metadata: dict[str, Any],
|
||||
model_name: str = "",
|
||||
):
|
||||
"""Run one seat round in-process (same trick as scheduler ``_start_agent_run``)."""
|
||||
from types import SimpleNamespace
|
||||
|
||||
from app.gateway.routers.thread_runs import RunCreateRequest
|
||||
from app.gateway.services import start_run
|
||||
from deerflow.runtime.user_context import reset_current_user, set_current_user
|
||||
|
||||
token = set_current_user(_RuntimeUser(id=user_id)) if user_id else None
|
||||
try:
|
||||
request = SimpleNamespace(app=self.app, state=SimpleNamespace(user=None, auth=None))
|
||||
body = RunCreateRequest(
|
||||
assistant_id="lead_agent",
|
||||
input={"messages": [{"type": "human", "content": prompt}]},
|
||||
metadata={
|
||||
**thread_metadata,
|
||||
"task_analysis_binding_id": run_meta.get("binding_id"),
|
||||
},
|
||||
context={
|
||||
"agent_name": seat_id,
|
||||
"is_scheduled_run": True,
|
||||
"thread_id": thread_id,
|
||||
"thinking_enabled": True,
|
||||
"is_plan_mode": False,
|
||||
"excluded_tools": ["ask_clarification"],
|
||||
**({"model_name": model_name} if model_name else {}),
|
||||
},
|
||||
multitask_strategy="reject",
|
||||
)
|
||||
return await start_run(body, thread_id, request) # type: ignore[arg-type]
|
||||
finally:
|
||||
if token is not None:
|
||||
reset_current_user(token)
|
||||
|
||||
# ── coordinator-first round (方案 A) ─────────────────────────────────────
|
||||
|
||||
async def _coordinator_dispatch(
|
||||
self,
|
||||
*,
|
||||
run: dict[str, Any],
|
||||
binding: dict[str, Any],
|
||||
task: dict[str, Any],
|
||||
user_id: str,
|
||||
emit,
|
||||
note_live=None,
|
||||
) -> dict[str, str]:
|
||||
"""无人值守总控先行:理解任务并给每个席位产出具体 task。
|
||||
|
||||
对齐会商第二步后台路径:``roundtable_run_policy("leader")`` + 进程内
|
||||
``_run_agent_turn``(关 thinking、禁写文件/bash、调用 ``agent_orchestration``
|
||||
后停图)。不走 HTTP loopback——后台 ``asyncio.create_task`` 没有浏览器 JWT,
|
||||
loopback ``/runs/stream`` 会把 thread 打成 404(总控抽屉里的 502,席位随即
|
||||
用兜底任务抢跑)。本函数会一直等到总控这一轮结束才返回;任何失败返回空
|
||||
dict,由调用方先把总控标成失败再启动席位。
|
||||
"""
|
||||
ctx_token = None
|
||||
try:
|
||||
from types import SimpleNamespace
|
||||
|
||||
from app.gateway.roundtable_inprocess_gateway import (
|
||||
_latest_ai_text,
|
||||
_run_agent_turn,
|
||||
_tool_calls_since_last_human,
|
||||
)
|
||||
from app.gateway.roundtable_run_policy import roundtable_run_policy
|
||||
from app.gateway.routers._task_analysis_seed import (
|
||||
TASK_ANALYSIS_COORDINATOR_ID,
|
||||
ensure_task_analysis_functional_agents,
|
||||
)
|
||||
from app.gateway.routers.multi_agent import _create_thread_direct, _extract_dispatch
|
||||
from deerflow.runtime.user_context import set_current_user
|
||||
|
||||
ensure_task_analysis_functional_agents()
|
||||
if user_id:
|
||||
ctx_token = set_current_user(_RuntimeUser(id=user_id))
|
||||
|
||||
request = SimpleNamespace(
|
||||
app=self.app,
|
||||
state=SimpleNamespace(
|
||||
user=_RuntimeUser(id=user_id) if user_id else None,
|
||||
auth=None,
|
||||
),
|
||||
)
|
||||
seat_names: dict[str, str] = run.get("seat_names_snapshot") or {}
|
||||
stages: list[list[str]] = run.get("stages_snapshot") or []
|
||||
snapshot_seats = (binding.get("chain_snapshot") or {}).get("seats") or []
|
||||
descriptions = {seat.get("agent_id"): seat.get("description") or "" for seat in snapshot_seats}
|
||||
|
||||
thread_id = await _create_thread_direct(
|
||||
request,
|
||||
metadata=task_analysis_thread_metadata(
|
||||
task,
|
||||
run_id=run["id"],
|
||||
role="coordinator",
|
||||
),
|
||||
)
|
||||
if note_live is not None:
|
||||
await note_live(COORDINATOR_SEAT, thread_id=thread_id)
|
||||
seat_lines = [
|
||||
f"- agent_name: {agent_id}({seat_names.get(agent_id, agent_id)}):"
|
||||
f"{descriptions.get(agent_id, "")}"
|
||||
for stage in stages
|
||||
for agent_id in stage
|
||||
]
|
||||
roster = (
|
||||
"【圆桌系统初始化】本次定时执行可调度的席位清单如下,请严格按 agent_name 通过 "
|
||||
"agent_orchestration 工具派活,不要派给不在清单内的 agent:" + "\n\n"
|
||||
+ "\n".join(seat_lines)
|
||||
)
|
||||
prompt = self._build_coordinator_prompt(run=run, binding=binding, task=task)
|
||||
await emit([
|
||||
{"seat_agent_id": COORDINATOR_SEAT, "stage_index": 0,
|
||||
"event_type": "input", "content": roster + "\n\n" + prompt},
|
||||
{"seat_agent_id": COORDINATOR_SEAT, "stage_index": 0,
|
||||
"event_type": "artifact",
|
||||
"content": "【总控执行中】正在理解任务并给各席位派活,席位会等本轮结束再开跑。"},
|
||||
])
|
||||
|
||||
policy = roundtable_run_policy("leader")
|
||||
excluded = list(policy.excluded_tools)
|
||||
if "ask_clarification" not in excluded:
|
||||
excluded.append("ask_clarification")
|
||||
|
||||
valid_ids = set(seat_names)
|
||||
full_prompt = roster + "\n\n" + prompt
|
||||
for attempt in range(2):
|
||||
message = full_prompt if attempt == 0 else (
|
||||
full_prompt
|
||||
+ "\n\n【系统重申】上一轮未产生有效派活。请立即通过 agent_orchestration 工具"
|
||||
"给清单中**每个席位**派发具体任务;无人值守,禁止澄清,信息不足自行假设。"
|
||||
"每个 task 必须写清:该席位接收什么、产出什么、输出结构。"
|
||||
)
|
||||
async def _on_coordinator_started(record) -> None:
|
||||
if note_live is None:
|
||||
return
|
||||
await note_live(
|
||||
COORDINATOR_SEAT,
|
||||
thread_id=thread_id,
|
||||
agent_run_id=getattr(record, "run_id", None),
|
||||
)
|
||||
|
||||
messages = await _run_agent_turn(
|
||||
self.app,
|
||||
user_id=user_id or "default",
|
||||
thread_id=thread_id,
|
||||
agent_name=TASK_ANALYSIS_COORDINATOR_ID,
|
||||
message=message,
|
||||
model=binding.get("model") or None,
|
||||
excluded_tools=excluded,
|
||||
skill_stop_names=list(policy.skill_stop_names),
|
||||
thinking_enabled=False,
|
||||
reasoning_effort="low",
|
||||
stage="task_analysis_leader",
|
||||
on_started=_on_coordinator_started,
|
||||
)
|
||||
content = _latest_ai_text(messages)
|
||||
if content:
|
||||
await emit([
|
||||
{"seat_agent_id": COORDINATOR_SEAT, "stage_index": 0,
|
||||
"event_type": "llm.ai", "content": content},
|
||||
])
|
||||
turn_calls = _tool_calls_since_last_human(messages)
|
||||
if not turn_calls:
|
||||
turn_calls = await self._extract_last_tool_calls(thread_id)
|
||||
dispatch = _parse_orchestration_calls(turn_calls, valid_ids)
|
||||
if not dispatch:
|
||||
for tc in turn_calls:
|
||||
try:
|
||||
agent, task_text = _extract_dispatch(tc)
|
||||
except Exception:
|
||||
continue
|
||||
agent = _strip_display_suffix(agent)
|
||||
if agent in valid_ids and task_text and agent not in dispatch:
|
||||
dispatch[agent] = task_text
|
||||
if dispatch:
|
||||
return dispatch
|
||||
logger.warning(
|
||||
"task-analysis coordinator attempt %d no dispatch (run %s); calls=%s",
|
||||
attempt, run.get("id"), str(turn_calls)[:300],
|
||||
)
|
||||
return {}
|
||||
except Exception as exc:
|
||||
logger.exception(
|
||||
"task-analysis coordinator round crashed (run %s); falling back to static prompts",
|
||||
run.get("id"),
|
||||
)
|
||||
try:
|
||||
await emit([
|
||||
{"seat_agent_id": COORDINATOR_SEAT, "stage_index": 0,
|
||||
"event_type": "artifact",
|
||||
"content": "【总控轮异常】" + type(exc).__name__ + ": " + str(exc)[:300]}
|
||||
])
|
||||
except Exception:
|
||||
pass
|
||||
return {}
|
||||
finally:
|
||||
if ctx_token is not None:
|
||||
from deerflow.runtime.user_context import reset_current_user
|
||||
|
||||
reset_current_user(ctx_token)
|
||||
|
||||
def _build_coordinator_prompt(
|
||||
self, *, run: dict[str, Any], binding: dict[str, Any], task: dict[str, Any]
|
||||
) -> str:
|
||||
stages: list[list[str]] = run.get("stages_snapshot") or []
|
||||
seat_names: dict[str, str] = run.get("seat_names_snapshot") or {}
|
||||
stage_goals: list[Any] = run.get("stage_goals_snapshot") or []
|
||||
snapshot_seats = (binding.get("chain_snapshot") or {}).get("seats") or []
|
||||
descriptions = {seat.get("agent_id"): seat.get("description") or "" for seat in snapshot_seats}
|
||||
|
||||
lines: list[str] = [
|
||||
"【任务分析定时执行 · 总控派活】",
|
||||
f"外部任务:{task.get('name', '')}(任务号 {task.get('source_task_id', '')})",
|
||||
f"任务简介:{task.get('description') or '(无)'}",
|
||||
]
|
||||
notes = binding.get("direction_notes") or []
|
||||
if notes:
|
||||
lines.append("执行方向备注(历次问答沉淀,派活必须体现):\n" + "\n".join(f"- {n}" for n in notes))
|
||||
coordinator_prompt = binding.get("coordinator_prompt")
|
||||
if coordinator_prompt:
|
||||
lines.append(f"总控提示:{coordinator_prompt}")
|
||||
lines.append("本次编排席位清单(按业务链阶段结构;agent_name 必须逐字符复制):")
|
||||
for stage_index, stage in enumerate(stages):
|
||||
mode = f"并行 ×{len(stage)}" if len(stage) > 1 else "串行"
|
||||
goal = _goal_text(stage_goals[stage_index]) if stage_index < len(stage_goals) else ""
|
||||
prev_goal = (
|
||||
_goal_text(stage_goals[stage_index - 1])
|
||||
if stage_index > 0 and stage_index - 1 < len(stage_goals)
|
||||
else ""
|
||||
)
|
||||
receive = _stage_receive_text(stage_index=stage_index, prev_goal=prev_goal or None, task=task)
|
||||
produce = goal or "按本阶段各席位职责给出可被后续阶段承接的完整交付"
|
||||
lines.append(f"- 阶段 {stage_index + 1}({mode}):")
|
||||
lines.append(f" 本阶段接收:{receive}")
|
||||
lines.append(f" 本阶段产出:{produce}")
|
||||
for agent_id in stage:
|
||||
name = seat_names.get(agent_id, agent_id)
|
||||
desc = descriptions.get(agent_id)
|
||||
lines.append(f" - agent_name: {agent_id}({name}){(':' + desc) if desc else ''}")
|
||||
lines.append(
|
||||
"\n请立刻**直接调用 agent_orchestration 工具**给上面清单中的**每个席位**派发具体任务"
|
||||
"(它是已注册的工具,不是技能:不要先读技能文档、不要用 load_tool,直接在回复中发起工具调用)。"
|
||||
"每个 task 必须写清:(1)该席位本轮接收什么(2)该席位本轮产出什么(3)输出结构"
|
||||
"(①核心结论 ②要点 ③风险 ④承接关系),并贴合本次任务领域定制(目标 / 关注维度),"
|
||||
"不要原样转发任务简介。"
|
||||
"本任务无人值守:禁止调用 ask_clarification 等澄清工具,信息不足时自行做出合理假设并在任务中注明「假设:…」。"
|
||||
)
|
||||
return "\n".join(lines)
|
||||
|
||||
async def _extract_last_tool_calls(self, thread_id: str) -> list[dict[str, Any]]:
|
||||
"""停图时 tool_calls 可能还在 pending_writes,序列化后的 messages 里看不到。"""
|
||||
checkpointer = getattr(self.app.state, "checkpointer", None)
|
||||
if checkpointer is None:
|
||||
return []
|
||||
config = {"configurable": {"thread_id": thread_id, "checkpoint_ns": ""}}
|
||||
checkpoint_tuple = await checkpointer.aget_tuple(config)
|
||||
if checkpoint_tuple is None:
|
||||
return []
|
||||
candidates: list[Any] = []
|
||||
pending = getattr(checkpoint_tuple, "pending_writes", None) or []
|
||||
for write in pending:
|
||||
value = write[2] if isinstance(write, (tuple, list)) and len(write) > 2 else None
|
||||
if value is not None:
|
||||
candidates.append(value)
|
||||
checkpoint = getattr(checkpoint_tuple, "checkpoint", {}) or {}
|
||||
candidates.extend((checkpoint.get("channel_values", {}) or {}).get("messages") or [])
|
||||
for message in reversed(candidates):
|
||||
if isinstance(message, dict):
|
||||
message_type = message.get("type") or message.get("role")
|
||||
raw_calls = message.get("tool_calls")
|
||||
additional = message.get("additional_kwargs") or {}
|
||||
else:
|
||||
message_type = getattr(message, "type", None)
|
||||
raw_calls = getattr(message, "tool_calls", None)
|
||||
additional = getattr(message, "additional_kwargs", None) or {}
|
||||
if message_type not in {"ai", "assistant"}:
|
||||
continue
|
||||
coerced = [item for item in (_coerce_tool_call(call) for call in (raw_calls or [])) if item]
|
||||
if coerced:
|
||||
return coerced
|
||||
legacy = additional.get("tool_calls") if isinstance(additional, dict) else None
|
||||
if isinstance(legacy, list) and legacy:
|
||||
coerced = [item for item in (_coerce_tool_call(call) for call in legacy) if item]
|
||||
if coerced:
|
||||
return coerced
|
||||
return []
|
||||
return []
|
||||
|
||||
async def _await_delivery(self, thread_id: str, *, timeout_s: float = 180.0) -> str | None:
|
||||
# record.task 完成与 checkpoint 可见之间存在竞态:轮询等 AI 交付落盘。
|
||||
deadline = time.monotonic() + timeout_s
|
||||
while time.monotonic() < deadline:
|
||||
delivery = await self._extract_latest_ai_text(thread_id)
|
||||
if delivery is not None:
|
||||
return delivery
|
||||
await asyncio.sleep(1.0)
|
||||
return None
|
||||
|
||||
async def _extract_latest_ai_text(self, thread_id: str) -> str | None:
|
||||
"""Pull the seat's last AI delivery from the thread checkpoint."""
|
||||
checkpointer = getattr(self.app.state, "checkpointer", None)
|
||||
if checkpointer is None:
|
||||
return None
|
||||
config = {"configurable": {"thread_id": thread_id, "checkpoint_ns": ""}}
|
||||
checkpoint_tuple = await checkpointer.aget_tuple(config)
|
||||
if checkpoint_tuple is None:
|
||||
return None
|
||||
checkpoint = getattr(checkpoint_tuple, "checkpoint", {}) or {}
|
||||
channel_values = checkpoint.get("channel_values", {})
|
||||
messages = channel_values.get("messages") or []
|
||||
for message in reversed(messages):
|
||||
message_type = getattr(message, "type", None)
|
||||
if message_type != "ai":
|
||||
continue
|
||||
content = getattr(message, "content", None)
|
||||
raw = ""
|
||||
if isinstance(content, str) and content.strip():
|
||||
raw = content
|
||||
elif isinstance(content, list):
|
||||
raw = "".join(
|
||||
part.get("text", "") for part in content if isinstance(part, dict)
|
||||
).strip()
|
||||
if not raw:
|
||||
continue
|
||||
try:
|
||||
from deerflow.agents.roundtable_orchestrator.delivery import visible_seat_text
|
||||
|
||||
text = (visible_seat_text(raw) or raw).strip()
|
||||
except Exception:
|
||||
text = raw.strip()
|
||||
if text:
|
||||
return text[:MARKDOWN_BLOCK_MAX_CHARS]
|
||||
return None
|
||||
|
||||
async def _flush_seat_results(self, run_id: str, seat_results: dict[str, dict[str, Any]]) -> None:
|
||||
try:
|
||||
await self.store.update_run(run_id, {"seat_results": seat_results})
|
||||
except Exception:
|
||||
logger.exception("task-analysis run %s seat_results flush failed", run_id)
|
||||
|
||||
async def _note_live(
|
||||
self,
|
||||
run_id: str,
|
||||
seat_results: dict[str, dict[str, Any]],
|
||||
seat_id: str,
|
||||
*,
|
||||
thread_id: str | None = None,
|
||||
agent_run_id: str | None = None,
|
||||
) -> None:
|
||||
current = dict(seat_results.get(seat_id) or {})
|
||||
if thread_id:
|
||||
current["thread_id"] = thread_id
|
||||
if agent_run_id:
|
||||
current["agent_run_id"] = agent_run_id
|
||||
seat_results[seat_id] = current
|
||||
await self._flush_seat_results(run_id, seat_results)
|
||||
|
||||
# ── finalisation ────────────────────────────────────────────────────────
|
||||
|
||||
async def _finish_run(
|
||||
self,
|
||||
*,
|
||||
run: dict[str, Any],
|
||||
task: dict[str, Any],
|
||||
status: str,
|
||||
seat_results: dict[str, dict[str, Any]],
|
||||
seat_names: dict[str, str],
|
||||
error: str | None,
|
||||
duration_ms: int,
|
||||
) -> None:
|
||||
run_id = run["id"]
|
||||
|
||||
blocks: dict[str, dict[str, Any]] = {}
|
||||
if status in {"succeeded", "partial"}:
|
||||
for seat_id, result in seat_results.items():
|
||||
if seat_id == COORDINATOR_SEAT:
|
||||
continue
|
||||
if result.get("state") == "done" and result.get("delivery"):
|
||||
blocks[seat_id] = {
|
||||
"name": seat_names.get(seat_id, seat_id),
|
||||
"seat_agent_id": seat_id,
|
||||
"content": result["delivery"],
|
||||
"format": "markdown",
|
||||
}
|
||||
try:
|
||||
await self.store.create_version(
|
||||
{"external_task_id": run["external_task_id"], "run_id": run_id, "blocks": blocks}
|
||||
)
|
||||
except Exception:
|
||||
logger.exception("task-analysis run %s version persist failed", run_id)
|
||||
|
||||
await self.store.update_run(
|
||||
run_id,
|
||||
{
|
||||
"status": status,
|
||||
"finished_at": datetime.now(UTC).isoformat(),
|
||||
"seat_results": seat_results,
|
||||
"error": error,
|
||||
},
|
||||
)
|
||||
_ = duration_ms # per-seat durations live in seat_results
|
||||
+146
@@ -0,0 +1,146 @@
|
||||
"""Project live agent events into task-analysis process-message rows.
|
||||
|
||||
Scheduled tasks poll ``GET /runs/{id}/messages`` every few seconds and read the
|
||||
agent's RunEventStore / checkpoint. Task analysis uses the same sources so the
|
||||
drawer can show in-flight LLM turns and tool calls instead of waiting until the
|
||||
seat finishes.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
from typing import Any
|
||||
|
||||
_KIND_BY_EVENT = {
|
||||
"llm.human.input": "input",
|
||||
"llm.human": "input",
|
||||
"llm.ai.response": "llm.ai",
|
||||
"llm.ai": "llm.ai",
|
||||
"llm.tool.result": "tool.result",
|
||||
"llm.tool": "tool.result",
|
||||
}
|
||||
|
||||
|
||||
def flatten_message_content(content: Any) -> str:
|
||||
"""Turn a LangChain dump / OpenAI-style payload into drawer text."""
|
||||
if content is None:
|
||||
return ""
|
||||
if isinstance(content, str):
|
||||
return content.strip()
|
||||
if isinstance(content, list):
|
||||
parts: list[str] = []
|
||||
for item in content:
|
||||
if isinstance(item, dict):
|
||||
parts.append(str(item.get("text") or item.get("content") or ""))
|
||||
else:
|
||||
parts.append(str(item))
|
||||
return "".join(parts).strip()
|
||||
if not isinstance(content, dict):
|
||||
return str(content).strip()
|
||||
|
||||
inner = content.get("content")
|
||||
if inner is not None and inner is not content:
|
||||
text = flatten_message_content(inner)
|
||||
if text:
|
||||
return text
|
||||
tool_calls = content.get("tool_calls") or []
|
||||
if isinstance(tool_calls, list) and tool_calls:
|
||||
lines: list[str] = []
|
||||
for call in tool_calls:
|
||||
if not isinstance(call, dict):
|
||||
name = getattr(call, "name", "") or ""
|
||||
args = getattr(call, "args", {}) or {}
|
||||
else:
|
||||
name = str(call.get("name") or (call.get("function") or {}).get("name") or "")
|
||||
args = call.get("args")
|
||||
if args is None:
|
||||
args = (call.get("function") or {}).get("arguments")
|
||||
if isinstance(args, (dict, list)):
|
||||
args_text = json.dumps(args, ensure_ascii=False)
|
||||
else:
|
||||
args_text = str(args or "")
|
||||
lines.append(f"调用工具:{name}\n{args_text}".strip())
|
||||
if lines:
|
||||
return "\n\n".join(lines)
|
||||
name = str(content.get("name") or "").strip()
|
||||
if name:
|
||||
body = flatten_message_content(content.get("output") or content.get("result") or "")
|
||||
return f"{name}:{body}".strip(":")
|
||||
try:
|
||||
return json.dumps(content, ensure_ascii=False)
|
||||
except TypeError:
|
||||
return str(content)
|
||||
|
||||
|
||||
def map_live_event_kind(event_type: str) -> str | None:
|
||||
return _KIND_BY_EVENT.get(str(event_type or "").strip())
|
||||
|
||||
|
||||
def live_rows_to_process_messages(
|
||||
live_rows: list[dict[str, Any]],
|
||||
*,
|
||||
seat: str,
|
||||
stage_index: int = 0,
|
||||
) -> list[dict[str, Any]]:
|
||||
"""Convert event-store / checkpoint rows into task-analysis message dicts."""
|
||||
out: list[dict[str, Any]] = []
|
||||
for index, row in enumerate(live_rows):
|
||||
kind = map_live_event_kind(str(row.get("event_type") or ""))
|
||||
if kind is None:
|
||||
# Checkpoint snapshots use LangChain message types.
|
||||
raw_type = ""
|
||||
content = row.get("content")
|
||||
if isinstance(content, dict):
|
||||
raw_type = str(content.get("type") or content.get("role") or "")
|
||||
if raw_type in {"human", "user"}:
|
||||
kind = "input"
|
||||
elif raw_type in {"ai", "assistant"}:
|
||||
kind = "llm.ai"
|
||||
elif raw_type == "tool":
|
||||
kind = "tool.result"
|
||||
else:
|
||||
continue
|
||||
text = flatten_message_content(row.get("content"))
|
||||
if not text:
|
||||
continue
|
||||
seq = row.get("seq")
|
||||
out.append(
|
||||
{
|
||||
"id": str(row.get("id") or f"live-{seat}-{seq if seq is not None else index}"),
|
||||
"run_id": row.get("run_id"),
|
||||
"seq": seq if seq is not None else index,
|
||||
"seat_agent_id": seat,
|
||||
"stage_index": int(row.get("stage_index") or stage_index),
|
||||
"event_type": kind,
|
||||
"content": text,
|
||||
"created_at": row.get("created_at"),
|
||||
"metadata": {"source": (row.get("metadata") or {}).get("source") or "live"},
|
||||
}
|
||||
)
|
||||
return out
|
||||
|
||||
|
||||
def merge_process_messages(
|
||||
*,
|
||||
stored: list[dict[str, Any]],
|
||||
live: list[dict[str, Any]],
|
||||
limit: int = 500,
|
||||
) -> list[dict[str, Any]]:
|
||||
"""Keep orchestration notes (input/artifact) and overlay live LLM/tool turns.
|
||||
|
||||
Live human input is dropped — the stored ``input`` row is the prompt we
|
||||
already showed in the drawer. Live AI/tool rows replace stored ``llm.ai``
|
||||
once they appear, so the user sees in-flight output instead of waiting for
|
||||
the final flush.
|
||||
"""
|
||||
live_body = [row for row in live if row.get("event_type") != "input"]
|
||||
live_has_ai = any(row.get("event_type") in {"llm.ai", "tool.result"} for row in live_body)
|
||||
if not live_body:
|
||||
return stored[:limit]
|
||||
kept: list[dict[str, Any]] = []
|
||||
for row in stored:
|
||||
kind = row.get("event_type")
|
||||
if live_has_ai and kind in {"llm.ai", "tool.result"}:
|
||||
continue
|
||||
kept.append(row)
|
||||
return (kept + live_body)[:limit]
|
||||
+294
@@ -0,0 +1,294 @@
|
||||
"""Scheduler service for external-task chain bindings (任务分析定时).
|
||||
|
||||
Mirrors ``ScheduledTaskService``'s proven skeleton: a 30-second poll loop
|
||||
scans due bindings and spawns one asyncio task per due binding, refreshing
|
||||
each binding's chain snapshot before executing, and skipping bindings whose
|
||||
chain has been deleted / disabled (marked ``chain_missing``). A watchdog pass
|
||||
fails runs stuck in pending/running past a grace window so one wedged
|
||||
execution cannot block the schedule.
|
||||
|
||||
Overlap policy (数据交付第三期定稿口径):调度不管上一轮跑没跑完——到期照常触发、
|
||||
照常开新期,同任务允许多轮并行,不跳过不顺延。因此**没有**在跑守卫;去重仅靠
|
||||
``create_run_once`` 的 (binding_id, scheduled_for) 幂等键。每次执行建 run 的同时开
|
||||
一期数据交付刻度(``open_period``,run_id 幂等锚点),智能体提交的数据落在提交
|
||||
时刻的当前最新一期。
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import logging
|
||||
from datetime import UTC, datetime, timedelta
|
||||
from typing import Any
|
||||
from zoneinfo import ZoneInfo
|
||||
|
||||
from croniter import croniter
|
||||
|
||||
from deerflow.persistence.task_analysis.base import TaskAnalysisStore
|
||||
from deerflow.runtime.task_analysis.executor import ChainBindingExecutor
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
STUCK_GRACE_SECONDS = 60 * 60 # 1h without finishing → watchdog marks failed
|
||||
|
||||
|
||||
def next_run_at(cron_expr: str, timezone: str, base: datetime | None = None) -> datetime:
|
||||
tz = ZoneInfo(timezone or "UTC")
|
||||
base_local = (base or datetime.now(UTC)).astimezone(tz)
|
||||
next_local = croniter(cron_expr, base_local).get_next(datetime)
|
||||
if next_local.tzinfo is None:
|
||||
next_local = next_local.replace(tzinfo=tz)
|
||||
return next_local.astimezone(UTC)
|
||||
|
||||
|
||||
def expand_chain_stages(chain: dict[str, Any]) -> list[list[str]]:
|
||||
seats = chain.get("seats") or []
|
||||
stages = chain.get("stages")
|
||||
if stages:
|
||||
return [list(stage) for stage in stages]
|
||||
return [[seat["agent_id"]] for seat in seats]
|
||||
|
||||
|
||||
def build_chain_snapshot(chain: dict[str, Any]) -> dict[str, Any]:
|
||||
return {
|
||||
"title": chain.get("title") or chain.get("id") or "",
|
||||
"seats": chain.get("seats") or [],
|
||||
"stages": expand_chain_stages(chain),
|
||||
"stage_goals": chain.get("stage_goals") or [],
|
||||
"coordinator_prompt": chain.get("coordinator_prompt"),
|
||||
}
|
||||
|
||||
|
||||
class TaskAnalysisService:
|
||||
def __init__(
|
||||
self,
|
||||
app: Any,
|
||||
store: TaskAnalysisStore,
|
||||
*,
|
||||
poll_interval_seconds: float = 30.0,
|
||||
) -> None:
|
||||
self.app = app
|
||||
self.store = store
|
||||
self.poll_interval_seconds = poll_interval_seconds
|
||||
self._stopping = asyncio.Event()
|
||||
self._loop_task: asyncio.Task | None = None
|
||||
|
||||
# ── lifecycle ───────────────────────────────────────────────────────────
|
||||
|
||||
async def start(self) -> None:
|
||||
self._stopping = asyncio.Event()
|
||||
self._loop_task = asyncio.create_task(self._poll_loop(), name="task-analysis-scheduler")
|
||||
|
||||
async def stop(self) -> None:
|
||||
self._stopping.set()
|
||||
if self._loop_task is not None:
|
||||
try:
|
||||
await asyncio.wait_for(self._loop_task, timeout=5)
|
||||
except (TimeoutError, asyncio.CancelledError):
|
||||
self._loop_task.cancel()
|
||||
self._loop_task = None
|
||||
|
||||
async def _poll_loop(self) -> None:
|
||||
while not self._stopping.is_set():
|
||||
try:
|
||||
await self._reconcile_stuck_runs()
|
||||
except asyncio.CancelledError:
|
||||
raise
|
||||
except Exception:
|
||||
logger.exception("task-analysis watchdog scan failed")
|
||||
try:
|
||||
due = await self.store.due_bindings(datetime.now(UTC), limit=20)
|
||||
for binding in due:
|
||||
# 到期即触发,不管上一轮是否结束:同任务允许多轮并行。
|
||||
asyncio.create_task(self._execute_and_untrack(binding))
|
||||
except asyncio.CancelledError:
|
||||
raise
|
||||
except Exception:
|
||||
logger.exception("task-analysis scan failed")
|
||||
try:
|
||||
await asyncio.wait_for(self._stopping.wait(), timeout=self.poll_interval_seconds)
|
||||
except TimeoutError:
|
||||
pass
|
||||
|
||||
async def _execute_and_untrack(self, binding: dict[str, Any]) -> None:
|
||||
try:
|
||||
await self.execute_binding(binding["id"], manual=False)
|
||||
except Exception:
|
||||
logger.exception("task-analysis binding %s execution crashed", binding.get("id"))
|
||||
|
||||
async def _reconcile_stuck_runs(self) -> None:
|
||||
cutoff = datetime.now(UTC) - timedelta(seconds=STUCK_GRACE_SECONDS)
|
||||
for run in await self.store.stuck_runs(cutoff):
|
||||
logger.warning("task-analysis run %s stuck since %s — failing", run["id"], run["started_at"])
|
||||
await self.store.update_run(
|
||||
run["id"],
|
||||
{
|
||||
"status": "failed",
|
||||
"finished_at": datetime.now(UTC).isoformat(),
|
||||
"error": "执行超时,由调度器看门狗标记失败",
|
||||
},
|
||||
)
|
||||
|
||||
# ── execution entry (scheduler + manual trigger share this) ─────────────
|
||||
|
||||
async def execute_binding(self, binding_id: str, *, manual: bool) -> dict[str, Any] | None:
|
||||
"""Synchronous full path (scheduler loop / tests): prepare + carry out."""
|
||||
prepared = await self.prepare_binding_run(binding_id, manual=manual)
|
||||
if prepared is None:
|
||||
return None
|
||||
run, binding, task, snapshot = prepared
|
||||
await self._carry_out(run, binding, task, snapshot)
|
||||
return await self.store.get_run(run["id"])
|
||||
|
||||
async def launch_binding(self, binding_id: str, *, manual: bool) -> dict[str, Any] | None:
|
||||
"""Async entry (manual trigger API): create the run, execute in background.
|
||||
|
||||
Returns the freshly created run row (status=pending) immediately so the
|
||||
HTTP caller can start polling; None when skipped (chain/task missing).
|
||||
"""
|
||||
prepared = await self.prepare_binding_run(binding_id, manual=manual)
|
||||
if prepared is None:
|
||||
return None
|
||||
run, binding, task, snapshot = prepared
|
||||
asyncio.create_task(self._carry_out_and_swallow(run, binding, task, snapshot))
|
||||
return run
|
||||
|
||||
async def prepare_binding_run(
|
||||
self, binding_id: str, *, manual: bool
|
||||
) -> tuple[dict[str, Any], dict[str, Any], dict[str, Any], dict[str, Any]] | None:
|
||||
"""Validate + snapshot + create the run row. Shared by sync/async paths."""
|
||||
binding = await self.store.get_binding_by_id(binding_id)
|
||||
if binding is None:
|
||||
return None
|
||||
task = await self.store.get_task(binding["external_task_id"])
|
||||
if task is None:
|
||||
await self.store.update_binding(binding_id, {"last_status": "task_missing"})
|
||||
return None
|
||||
|
||||
chain = await self._load_chain(binding.get("chain_id") or "", binding.get("created_by") or "")
|
||||
if chain is None or chain.get("enabled") is False:
|
||||
# 口径:链被删/停用 → 跳过执行并标记,绑定保留。
|
||||
await self.store.update_binding(
|
||||
binding_id,
|
||||
{
|
||||
"last_status": "chain_missing",
|
||||
"next_run_at": None
|
||||
if (manual or self._is_once(binding))
|
||||
else self._advance(binding).isoformat(),
|
||||
},
|
||||
)
|
||||
return None
|
||||
|
||||
snapshot = build_chain_snapshot(chain)
|
||||
stages = snapshot["stages"]
|
||||
seat_names = {seat["agent_id"]: seat.get("name") or seat["agent_id"] for seat in snapshot["seats"]}
|
||||
scheduled_for = datetime.now(UTC).replace(microsecond=0) if manual else _scheduled_for(binding)
|
||||
run = await self.store.create_run_once(
|
||||
{
|
||||
"binding_id": binding_id,
|
||||
"external_task_id": binding["external_task_id"],
|
||||
"trigger": "manual" if manual else "schedule",
|
||||
"scheduled_for": scheduled_for,
|
||||
"status": "pending",
|
||||
"stages_snapshot": stages,
|
||||
"stage_goals_snapshot": snapshot["stage_goals"],
|
||||
"seat_names_snapshot": seat_names,
|
||||
"seat_results": {},
|
||||
}
|
||||
)
|
||||
await self.store.update_binding(
|
||||
binding_id,
|
||||
{
|
||||
"chain_snapshot": snapshot,
|
||||
# once 绑定永不排期(next_run_at 恒空,调度器自然不再触发)。
|
||||
**(
|
||||
{}
|
||||
if (manual or self._is_once(binding))
|
||||
else {"next_run_at": self._advance(binding).isoformat()}
|
||||
),
|
||||
},
|
||||
)
|
||||
# 数据交付已去掉时间轴(期)维度:调度轮次不再开新期,席位提交统一
|
||||
# 合并进任务唯一的当前数据(首次提交时由 submit 兜底开期)。
|
||||
return run, binding, task, snapshot
|
||||
|
||||
async def _carry_out_and_swallow(
|
||||
self,
|
||||
run: dict[str, Any],
|
||||
binding: dict[str, Any],
|
||||
task: dict[str, Any],
|
||||
snapshot: dict[str, Any],
|
||||
) -> None:
|
||||
try:
|
||||
await self._carry_out(run, binding, task, snapshot)
|
||||
except Exception:
|
||||
logger.exception("task-analysis background run %s crashed", run.get("id"))
|
||||
|
||||
async def _carry_out(
|
||||
self,
|
||||
run: dict[str, Any],
|
||||
binding: dict[str, Any],
|
||||
task: dict[str, Any],
|
||||
snapshot: dict[str, Any],
|
||||
) -> None:
|
||||
executor = ChainBindingExecutor(self.app, self.store)
|
||||
user_id = binding.get("created_by") or ""
|
||||
ctx_token = None
|
||||
if user_id:
|
||||
from deerflow.runtime.task_analysis.executor import _RuntimeUser
|
||||
from deerflow.runtime.user_context import reset_current_user, set_current_user
|
||||
|
||||
ctx_token = set_current_user(_RuntimeUser(id=user_id))
|
||||
try:
|
||||
await executor.execute(run, {**binding, "chain_snapshot": snapshot}, task)
|
||||
finally:
|
||||
if ctx_token is not None:
|
||||
reset_current_user(ctx_token)
|
||||
final = await self.store.get_run(run["id"])
|
||||
status = (final or {}).get("status") or "unknown"
|
||||
await self.store.update_binding(
|
||||
binding["id"],
|
||||
{
|
||||
"last_run_at": datetime.now(UTC).isoformat(),
|
||||
"last_status": status,
|
||||
},
|
||||
)
|
||||
|
||||
# ── helpers ─────────────────────────────────────────────────────────────
|
||||
|
||||
def _advance(self, binding: dict[str, Any]) -> datetime:
|
||||
return next_run_at(
|
||||
binding.get("cron_expr") or "0 9 * * *",
|
||||
binding.get("timezone") or "Asia/Shanghai",
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def _is_once(binding: dict[str, Any]) -> bool:
|
||||
return (binding.get("schedule_type") or "cron") == "once"
|
||||
|
||||
async def _load_chain(self, chain_id: str, user_id: str) -> dict[str, Any] | None:
|
||||
chain_store = getattr(self.app.state, "roundtable_chain_store", None)
|
||||
if chain_store is None or not chain_id:
|
||||
return None
|
||||
# created_by 为空(旧数据/未登录创建)时回退 default 用户,再试公共链可见性。
|
||||
effective_user = user_id or "default"
|
||||
try:
|
||||
chain = await chain_store.get_chain(chain_id, effective_user)
|
||||
if chain is None and effective_user != "default":
|
||||
chain = await chain_store.get_chain(chain_id, "default")
|
||||
return chain
|
||||
except Exception:
|
||||
logger.exception("task-analysis load chain %s failed", chain_id)
|
||||
return None
|
||||
|
||||
|
||||
def _scheduled_for(binding: dict[str, Any]) -> datetime:
|
||||
value = binding.get("next_run_at")
|
||||
if isinstance(value, datetime):
|
||||
return value
|
||||
if isinstance(value, str) and value:
|
||||
try:
|
||||
return datetime.fromisoformat(value)
|
||||
except ValueError:
|
||||
pass
|
||||
return datetime.now(UTC).replace(microsecond=0)
|
||||
+46
@@ -0,0 +1,46 @@
|
||||
"""Metadata contract for task-analysis runtime threads.
|
||||
|
||||
The LangGraph checkpoint is still the canonical transcript for a coordinator
|
||||
or a seat. These markers make that implementation detail unambiguous to the
|
||||
general thread registry: task-analysis transcripts belong to a task-analysis
|
||||
run and must never be presented as ordinary Q&A conversations.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any
|
||||
|
||||
|
||||
def task_analysis_thread_metadata(
|
||||
task: dict[str, Any],
|
||||
*,
|
||||
run_id: str | None = None,
|
||||
thread_type: str = "task-analysis",
|
||||
role: str | None = None,
|
||||
seat_id: str | None = None,
|
||||
) -> dict[str, Any]:
|
||||
"""Build durable metadata for one internal task-analysis transcript.
|
||||
|
||||
``task_analysis_task_id`` points at the dedicated ``task_analysis_tasks``
|
||||
row; the source id is retained for operators and external-system tracing.
|
||||
The fields are intentionally distinct from the task deep-link ``taskId``
|
||||
namespace, whose access and history semantics are different.
|
||||
"""
|
||||
|
||||
metadata: dict[str, Any] = {
|
||||
"thread_type": thread_type,
|
||||
"system": True,
|
||||
}
|
||||
task_id = task.get("id")
|
||||
if task_id is not None and str(task_id).strip():
|
||||
metadata["task_analysis_task_id"] = str(task_id)
|
||||
source_task_id = task.get("source_task_id")
|
||||
if source_task_id is not None and str(source_task_id).strip():
|
||||
metadata["task_analysis_source_task_id"] = str(source_task_id)
|
||||
if run_id and run_id.strip():
|
||||
metadata["task_analysis_run_id"] = run_id
|
||||
if role and role.strip():
|
||||
metadata["task_analysis_role"] = role
|
||||
if seat_id and seat_id.strip():
|
||||
metadata["task_analysis_seat"] = seat_id
|
||||
return metadata
|
||||
@@ -103,6 +103,12 @@ def resolve_path_user_id(thread_id: str | None) -> str:
|
||||
return get_effective_user_id()
|
||||
|
||||
|
||||
def remember_thread_owner(thread_id: str, owner: str) -> None:
|
||||
"""Cache a discovered thread owner for subsequent filesystem lookups."""
|
||||
if thread_id and owner and not _is_local_only_thread(thread_id):
|
||||
_cache_put(thread_id, owner)
|
||||
|
||||
|
||||
async def aresolve_path_user_id(thread_id: str | None) -> str:
|
||||
"""Async variant of :func:`resolve_path_user_id` for FastAPI handlers."""
|
||||
if not thread_id or _is_local_only_thread(thread_id):
|
||||
|
||||
Reference in new issue
Block a user