"""Application service for agent entry. 这层的职责是把“接口层如何调用 AgentLoop”统一收口。 接口层以后不应该各自做这些事情： 1. 自己 new `AgentLoop` 2. 自己决定何时 `boot()` 3. 自己处理 direct run 的同步/异步包装 统一放在 `AgentService` 后，CLI / Web / Gateway 才能共享同一条运行主链。 """ from __future__ import annotations import asyncio from pathlib import Path from time import perf_counter from typing import Any from uuid import uuid4 from beaver.engine import AgentLoop, AgentProfile, AgentRunResult, EngineLoader from beaver.engine.providers import make_provider_bundle from beaver.foundation.events import InboundMessage, OutboundMessage from beaver.foundation.models import CronJob, CronRunRecord from beaver.prompts.main_agent import normalize_main_agent_prompt_locale from beaver.tasks import ( MainAgentRouter, TaskRecord, ) from beaver.tasks.attempt_orchestrator import TaskAttemptOrchestrator from beaver.tasks.service import normalize_acceptance_type NOTIFICATION_SESSION_ID = "notify:default:scheduled" class AgentService: """面向 interfaces 的统一 agent 运行入口。 这里明确区分两种调用模式： 1. direct mode - 不启动后台运行循环 - 直接调用 `process_direct()` / `run_direct()` 2. running mode - 先 `await start()` - 之后所有外部任务都必须走 `submit_direct()` - 不允许再直接调用 `process_direct()` """ def __init__( self, *, workspace: str | Path | None = None, config_path: str | Path | None = None, profile: AgentProfile | None = None, loader: EngineLoader | None = None, ) -> None: self.profile = profile or AgentProfile() self.loader = loader or EngineLoader(workspace=workspace, config_path=config_path) self._apply_configured_profile_defaults() self._loop: AgentLoop | None = None self._run_task: asyncio.Task[None] | None = None self._main_agent_router = MainAgentRouter() self._runtime_services: dict[str, Any] = {} def _apply_configured_profile_defaults(self) -> None: defaults = self.loader.config.agents_defaults self.profile.max_tokens = None self.profile.temperature = 0.2 self.profile.max_context_messages = 1000 self.profile.max_tool_iterations = 30 if defaults.max_tokens is not None: self.profile.max_tokens = max(1, defaults.max_tokens) if defaults.temperature is not None: self.profile.temperature = defaults.temperature if defaults.max_context_messages is not None: self.profile.max_context_messages = max(1, defaults.max_context_messages) if defaults.max_tool_iterations is not None: self.profile.max_tool_iterations = max(0, defaults.max_tool_iterations) def create_loop(self) -> AgentLoop: """创建并缓存当前 service 使用的 AgentLoop。""" if self._loop is None: self._loop = AgentLoop(profile=self.profile, loader=self.loader) self._loop.runtime_services.update(self._runtime_services) self._loop.boot() return self._loop def create_isolated_loop(self) -> AgentLoop: loop = AgentLoop(profile=self.profile, loader=self.loader) loop.runtime_services.update(self._runtime_services) return loop def register_runtime_service(self, name: str, service: Any) -> None: """Expose process-level services to tools during agent runs.""" self._runtime_services[name] = service if self._loop is not None: self._loop.runtime_services[name] = service @property def has_loop(self) -> bool: """当前 service 是否已经创建过 loop。""" return self._loop is not None @property def is_running(self) -> bool: """当前 service 是否处于 running mode。""" return self._run_task is not None and not self._run_task.done() def close(self) -> None: """关闭当前 service 持有的 runtime。""" if self._run_task is not None and not self._run_task.done(): raise RuntimeError("AgentService.close() requires stop() before closing a running loop") self._run_task = None if self._loop is None: return try: self._loop.close() finally: self._loop = None async def start(self) -> None: """启动后台运行循环，进入 running mode。 进入 running mode 后： - 外部任务必须通过 `submit_direct()` 提交 - `process_direct()` 不再允许直接调用 """ if self._run_task is not None and not self._run_task.done(): return loop = self.create_loop() self._run_task = asyncio.create_task(loop.run()) while not loop.is_running: if self._run_task.done(): await self._run_task break await asyncio.sleep(0) async def _stop_impl( self, *, timeout_seconds: float | None = None, force: bool = False, ) -> None: """内部停止实现，支持 graceful timeout 和可选 force cancel。""" if self._run_task is None: return run_task = self._run_task loop = self.create_loop() try: await loop.stop() if timeout_seconds is None: await run_task else: try: await asyncio.wait_for(asyncio.shield(run_task), timeout=timeout_seconds) except asyncio.TimeoutError as exc: if force: run_task.cancel() try: await run_task except asyncio.CancelledError: pass else: raise TimeoutError( f"AgentService.stop() timed out after {timeout_seconds} seconds while draining queued tasks" ) from exc finally: if run_task.done(): self._run_task = None async def stop( self, *, timeout_seconds: float | None = None, force: bool = False, ) -> None: """停止后台运行循环并等待退出。 参数： - `timeout_seconds`: graceful drain 的最长等待时间；`None` 表示一直等 - `force`: 超时后是否 cancel 掉运行循环 task """ await self._stop_impl(timeout_seconds=timeout_seconds, force=force) async def shutdown( self, *, timeout_seconds: float | None = None, force: bool = False, ) -> None: """先停运行循环，再释放 runtime。""" await self._stop_impl(timeout_seconds=timeout_seconds, force=force) self.close() async def process_direct( self, message: str, **kwargs: Any, ) -> AgentRunResult: """异步 direct run 入口。 仅在 direct mode 下可用。 如果 service 已经 `start()` 进入 running mode， 调用方必须改用 `submit_direct()`，不能绕过运行队列直接执行。 """ if self._run_task is not None and not self._run_task.done(): raise RuntimeError( "AgentService.process_direct() is unavailable while the service is running; " "use 'await AgentService.submit_direct(...)' after start()." ) loop = self.create_loop() return await self._process_with_main_agent(message, runner=loop.process_direct, kwargs=kwargs) async def submit_direct( self, message: str, **kwargs: Any, ) -> AgentRunResult: """向 running mode 下的 loop 提交 direct task。 这是 `start()` 之后唯一合法的外部任务入口。 """ loop = self.create_loop() return await self._process_with_main_agent(message, runner=loop.submit_direct, kwargs=kwargs) async def run_scheduled_task( self, message: str, *, session_id: str, cron_job_id: str, cron_job_name: str, scheduled_run_id: str | None = None, requires_followup: bool = False, ) -> AgentRunResult: """Run a cron trigger as a normal internal Task. Scheduled jobs are product-level Tasks, not hidden one-off agent turns. This entry bypasses the main-agent classifier and forces Task mode so every trigger produces a TaskRecord, evidence, acceptance state, and a run_id that the scheduled-task history can link to. """ loaded = self.create_loop().boot() task_service = self._require_loaded(loaded, "task_service") loop = self.create_loop() task = task_service.create_task( session_id=session_id, description=message, creator="cron", metadata={ "source": "scheduled_cron", "cron_job_id": cron_job_id, "cron_job_name": cron_job_name, "scheduled_run_id": scheduled_run_id, "user_engaged": False, "requires_followup": requires_followup, }, ) execution_context = ( "This turn was triggered automatically by a scheduled task.\n\n" f"Cron Job ID: {cron_job_id}\n" f"Cron Job Name: {cron_job_name}\n" f"Scheduled Run ID: {scheduled_run_id or 'unknown'}\n" "Run it as a normal Beaver Task. Do not ask the user for confirmation; " "execute the task and report the concrete outcome." ) runner = loop.submit_direct if self.is_running else loop.process_direct result = await self._run_task_mode( message, runner=runner, task=task, kwargs={ "session_id": session_id, "source": "cron", "user_id": "cron", "title": cron_job_name, "execution_context": execution_context, }, ) loaded = self.create_loop().boot() session_manager = self._require_loaded(loaded, "session_manager") session_manager.update_latest_assistant_event_payload( result.session_id, result.run_id, { "message_type": "scheduled_reply", "scheduled_job_id": cron_job_id, "scheduled_run_id": scheduled_run_id, "cron_job_name": cron_job_name, "mode": "notification", }, ) return result async def run_scheduled_notification( self, message: str, *, session_id: str = NOTIFICATION_SESSION_ID, cron_job_id: str, cron_job_name: str, scheduled_run_id: str, ) -> AgentRunResult: """Run a cron trigger as a notification result, not as an active Task.""" loop = self.create_loop() loaded = loop.boot() session_manager = self._require_loaded(loaded, "session_manager") runner = loop.submit_direct if self.is_running else loop.process_direct execution_context = ( "This turn was triggered automatically by a scheduled notification.\n\n" f"Cron Job ID: {cron_job_id}\n" f"Cron Job Name: {cron_job_name}\n" f"Scheduled Run ID: {scheduled_run_id}\n" "Generate the notification content directly for the user. Do not ask for confirmation." ) result = await runner( message, session_id=session_id, source="notification", user_id="cron", title=cron_job_name, execution_context=execution_context, ) session_manager.update_latest_assistant_event_payload( result.session_id, result.run_id, { "message_type": "scheduled_result", "scheduled_job_id": cron_job_id, "scheduled_run_id": scheduled_run_id, "cron_job_name": cron_job_name, "mode": "notification", }, ) return result def engage_scheduled_run( self, *, job: CronJob, run: CronRunRecord, intent: str = "revise_once", thinking_enabled: bool | None = None, ) -> TaskRecord: """Create or mark the Task that lets the user work on a scheduled result.""" loaded = self.create_loop().boot() task_service = self._require_loaded(loaded, "task_service") if run.task_id: existing = task_service.get_task(run.task_id) if existing is not None: existing.metadata["user_engaged"] = True existing.metadata["engage_intent"] = intent task_service.store.upsert_task(existing) return existing task = task_service.create_task( session_id=run.notification_session_id or NOTIFICATION_SESSION_ID, description=f"修改定时通知：{job.name}", creator="cron", metadata={ "source": "scheduled_run", "cron_job_id": job.id, "cron_job_name": job.name, "scheduled_run_id": run.scheduled_run_id, "scheduled_output": run.output, "user_engaged": True, "engage_intent": intent, }, ) return task async def submit_scheduled_reply( self, message: str, *, job: CronJob, run: CronRunRecord, intent: str = "revise_once", ) -> AgentRunResult: task = self.engage_scheduled_run(job=job, run=run, intent=intent) loop = self.create_loop() runner = loop.submit_direct if self.is_running else loop.process_direct execution_context = ( "The user is replying to a scheduled notification result.\n\n" f"Cron Job ID: {job.id}\n" f"Cron Job Name: {job.name}\n" f"Scheduled Run ID: {run.scheduled_run_id}\n" f"Engagement intent: {intent}\n" f"Original scheduled instruction: {job.payload.message}\n" f"Original notification output:\n{run.output or ''}\n\n" "Handle this as a Task continuation. If the intent is update_future, explain the durable change " "that should apply to future notifications." ) return await self._run_task_mode( message, runner=runner, task=task, kwargs={ "session_id": task.session_id, "source": "notification", "user_id": "web", "title": job.name, "execution_context": execution_context, "thinking_enabled": thinking_enabled, }, ) async def submit_acceptance( self, *, session_id: str, run_id: str, acceptance_type: str, comment: str | None = None, ) -> dict[str, Any]: """Record user acceptance for the internal task linked to a run.""" loaded = self.create_loop().boot() task_service = self._require_loaded(loaded, "task_service") task = task_service.get_task_by_run_id(run_id) if task is None or task.session_id != session_id: raise ValueError(f"No internal task found for run_id={run_id!r}") normalized = normalize_acceptance_type(acceptance_type) legacy_feedback_type = "satisfied" if normalized == "accept" else normalized already_recorded = any( item.get("run_id") == run_id and item.get("acceptance_type") == normalized for item in task.feedback ) conflicting_acceptance = next( ( item for item in task.feedback if item.get("run_id") == run_id and item.get("acceptance_type") != normalized ), None, ) if conflicting_acceptance is not None: raise ValueError( f"Acceptance for run_id={run_id!r} was already recorded as " f"{conflicting_acceptance.get('acceptance_type')!r}" ) if task.status in {"closed", "abandoned"} and not already_recorded: raise ValueError(f"Task {task.task_id} is already finalized as {task.status!r}") updated = task if already_recorded else task_service.add_acceptance( task.task_id, acceptance_type=normalized, comment=comment, run_id=run_id, ) session_manager = self._require_loaded(loaded, "session_manager") session_manager.update_latest_assistant_event_payload( session_id, run_id, { "task_id": updated.task_id, "task_status": updated.status, "acceptance_state": normalized, "feedback_state": legacy_feedback_type, }, ) if not already_recorded: session_manager.append_message( session_id, run_id=run_id, role="system", event_type="task_acceptance_recorded", event_payload={ "task_id": task.task_id, "acceptance_type": normalized, "feedback_type": legacy_feedback_type, "comment": comment, "task_status": updated.status, }, content=comment, context_visible=False, ) generated_candidates = [] if not already_recorded: run_memory_store = self._require_loaded(loaded, "run_memory_store") acceptance_payload = { "acceptance_type": normalized, "feedback_type": legacy_feedback_type, "comment": comment or "", "task_status": updated.status, "final_accepted_run_id": updated.metadata.get("final_accepted_run_id"), } run_memory_store.update_run_record( run_id, success=normalized == "accept", feedback=acceptance_payload, ) run_memory_store.update_skill_effects_for_run( run_id, success=normalized == "accept", feedback_score=self._acceptance_score_for_learning(normalized), notes=(comment or normalized).strip(), ) skill_learning_service = self._require_loaded(loaded, "skill_learning_service") skill_learning_service.rescore_skill_versions() if already_recorded: generated_candidates = [] elif normalized == "accept": generated_candidates = [ item.to_dict() for item in skill_learning_service.build_learning_candidates_for_task( updated.task_id, final_accepted_run_id=run_id, ) ] elif normalized == "abandon": session_manager.append_message( session_id, run_id=run_id, role="system", event_type="task_failure_evidence_recorded", event_payload={ "task_id": updated.task_id, "acceptance_type": normalized, "feedback_type": legacy_feedback_type, "comment": comment or "", "task_status": updated.status, "durable_memory_written": False, }, content=(comment or "Task abandoned; retained as run/session failure evidence."), context_visible=False, ) return { "session_id": session_id, "run_id": run_id, "task_id": updated.task_id, "task_status": updated.status, "acceptance_type": normalized, "feedback_type": legacy_feedback_type, "learning_candidates": generated_candidates, } async def submit_feedback( self, *, session_id: str, run_id: str, feedback_type: str, comment: str | None = None, ) -> dict[str, Any]: """Backward-compatible wrapper for older clients.""" return await self.submit_acceptance( session_id=session_id, run_id=run_id, acceptance_type=feedback_type, comment=comment, ) async def _process_with_main_agent( self, message: str, *, runner: Any, kwargs: dict[str, Any], ) -> AgentRunResult: loaded = self.create_loop().boot() task_service = self._require_loaded(loaded, "task_service") session_manager = self._require_loaded(loaded, "session_manager") session_id = kwargs.get("session_id") or uuid4().hex kwargs = dict(kwargs) kwargs["session_id"] = session_id provider_bundle = kwargs.get("provider_bundle") or self._make_provider_bundle_for_task(loaded, kwargs) kwargs["provider_bundle"] = provider_bundle router_provider = provider_bundle.auxiliary_provider or provider_bundle.main_provider router_runtime = provider_bundle.auxiliary_runtime or provider_bundle.main_runtime active_task = task_service.get_latest_open_task(session_id) router_started = perf_counter() try: decision = await self._main_agent_router.classify( message, active_task=active_task, provider=router_provider, model=getattr(router_runtime, "model", None), recent_messages=session_manager.get_messages_as_conversation(session_id), intent_skill=self._load_intent_agent_skill(loaded), thinking_enabled=kwargs.get("thinking_enabled"), ) finally: kwargs["pre_run_latency_ms"] = self._merge_latency_ms( kwargs.get("pre_run_latency_ms"), {"router_ms": (perf_counter() - router_started) * 1000}, ) kwargs["intent_agent_decision"] = self._intent_decision_payload( decision, active_task=active_task, ) if active_task is not None and decision.short_title and not active_task.metadata.get("short_title"): active_task.metadata["short_title"] = decision.short_title task_service.store.upsert_task(active_task) if active_task is not None and (decision.action == "simple_chat" or decision.starts_new_task): await self._accept_active_task_for_new_topic(active_task) if active_task is not None and decision.closes_task: task_service.close_task(active_task.task_id, reason=decision.reason) return await runner(message, **kwargs) if active_task is not None and decision.abandons_task: task_service.abandon_task(active_task.task_id, reason=decision.reason) return await runner(message, **kwargs) if not decision.is_task: kwargs["include_skill_assembly"] = False kwargs["include_tools"] = False return await runner(message, **kwargs) task = ( task_service.create_task( session_id=session_id, description=message, metadata={ "prompt_locale": normalize_main_agent_prompt_locale(kwargs.get("prompt_locale")), "router_reason": decision.reason, **({"short_title": decision.short_title} if decision.short_title else {}), }, ) if active_task is None or decision.starts_new_task else active_task ) if active_task is not None and decision.action == "revise_task" and task.task_id == active_task.task_id: task = self._record_revision_acceptance_for_task( loaded, task=task, session_id=session_id, comment=message, ) return await self._run_task_mode(message, runner=runner, kwargs=kwargs, task=task) async def _accept_active_task_for_new_topic(self, task: TaskRecord) -> None: """Accept a completed active Task before routing an unrelated new topic.""" if task.status != "awaiting_acceptance": return run_id = next((item for item in reversed(task.run_ids) if item), None) if not run_id: return await self.submit_acceptance( session_id=task.session_id, run_id=run_id, acceptance_type="accept", ) def _record_revision_acceptance_for_task( self, loaded: Any, *, task: TaskRecord, session_id: str, comment: str, ) -> TaskRecord: """Mark the latest acceptance-eligible run as revised before continuing a task.""" if task.status not in {"awaiting_acceptance", "needs_revision"}: return task run_id = next((item for item in reversed(task.run_ids) if item), None) if not run_id: return task existing = next((item for item in task.feedback if item.get("run_id") == run_id), None) if existing is not None: if existing.get("acceptance_type") != "revise": return task updated = task already_recorded = True else: task_service = self._require_loaded(loaded, "task_service") updated = task_service.add_acceptance( task.task_id, acceptance_type="revise", comment=comment, run_id=run_id, ) already_recorded = False session_manager = self._require_loaded(loaded, "session_manager") session_manager.update_latest_assistant_event_payload( session_id, run_id, { "task_id": updated.task_id, "task_status": updated.status, "acceptance_state": "revise", "feedback_state": "revise", }, ) if already_recorded: return updated session_manager.append_message( session_id, run_id=run_id, role="system", event_type="task_acceptance_recorded", event_payload={ "task_id": updated.task_id, "acceptance_type": "revise", "feedback_type": "revise", "comment": comment, "task_status": updated.status, "auto_recorded": True, }, content=comment, context_visible=False, ) run_memory_store = self._require_loaded(loaded, "run_memory_store") run_memory_store.update_run_record( run_id, success=False, feedback={ "acceptance_type": "revise", "feedback_type": "revise", "comment": comment, "task_status": updated.status, }, ) run_memory_store.update_skill_effects_for_run( run_id, success=False, feedback_score=self._acceptance_score_for_learning("revise"), notes=comment.strip() or "revise", ) skill_learning_service = self._require_loaded(loaded, "skill_learning_service") skill_learning_service.rescore_skill_versions() return updated async def _run_task_mode( self, message: str, *, runner: Any, kwargs: dict[str, Any], task: TaskRecord, ) -> AgentRunResult: loaded = self.create_loop().boot() return await self._build_task_attempt_orchestrator(loaded).run( message=message, runner=runner, kwargs=kwargs, task=task, ) def _build_task_attempt_orchestrator(self, loaded: Any) -> TaskAttemptOrchestrator: return TaskAttemptOrchestrator( loaded=loaded, create_loop=self.create_loop, make_provider_bundle_for_task=self._make_provider_bundle_for_task, ) @staticmethod def _require_loaded(loaded: Any, field_name: str) -> Any: value = getattr(loaded, field_name) if value is None: raise RuntimeError(f"Engine loader did not provide required dependency {field_name!r}") return value @staticmethod def _load_intent_agent_skill(loaded: Any) -> str | None: skills_loader = getattr(loaded, "skills_loader", None) if skills_loader is None: return None return skills_loader.load_skill("intent-agent-router") @staticmethod def _intent_decision_payload(decision: Any, *, active_task: TaskRecord | None) -> dict[str, Any]: action = decision.action or ("create_task" if decision.is_task and active_task is None else decision.mode) return { "agent": "intent_agent", "choice": action, "mode": "task" if decision.is_task else "simple", "reason": decision.reason, "active_task_id": active_task.task_id if active_task is not None else None, "starts_new_task": bool(decision.starts_new_task or (decision.is_task and active_task is None)), "closes_task": bool(decision.closes_task), "abandons_task": bool(decision.abandons_task), "short_title": decision.short_title, } @staticmethod def _merge_latency_ms(current: Any, updates: dict[str, float]) -> dict[str, float]: merged: dict[str, float] = {} if isinstance(current, dict): for key, value in current.items(): if isinstance(value, (int, float)): merged[str(key)] = float(value) for key, value in updates.items(): merged[key] = merged.get(key, 0.0) + float(value) return merged @staticmethod def _acceptance_score_for_learning(acceptance_type: str) -> float: if acceptance_type == "accept": return 1.0 if acceptance_type == "revise": return 0.5 return 0.0 def _make_provider_bundle_for_task(self, loaded: Any, kwargs: dict[str, Any]) -> Any: config = loaded.config configured_provider = config.resolve_provider_target( model=kwargs.get("model"), provider_name=kwargs.get("provider_name"), ) resolved_model = configured_provider.get("model") or self.profile.default_model resolved_provider_name = configured_provider.get("provider_name") or kwargs.get("provider_name") return make_provider_bundle( model=resolved_model, provider_name=resolved_provider_name, api_key=kwargs.get("api_key") or configured_provider.get("api_key"), api_base=kwargs.get("api_base") or configured_provider.get("api_base"), request_timeout_seconds=configured_provider.get("request_timeout_seconds"), extra_headers=kwargs.get("extra_headers") or configured_provider.get("extra_headers"), routing=kwargs.get("routing"), fallback_target=kwargs.get("fallback_target"), auxiliary_target=kwargs.get("auxiliary_target"), embedding_target=kwargs.get("embedding_target") or config.resolve_embedding_target(), embedding_model=kwargs.get("embedding_model") or config.default_embedding_model, ) async def handle_inbound_message(self, inbound: InboundMessage) -> OutboundMessage: """把 bus inbound 映射成标准 runtime 调用，并返回结构化 outbound。""" channel_identity = inbound.channel_identity try: runner = self.submit_direct if self.is_running else self.process_direct result = await runner( inbound.content, session_id=inbound.session_id, source=f"gateway:{inbound.channel}", user_id=inbound.user_id or (channel_identity.user_id if channel_identity else None), title=inbound.title, execution_context=inbound.execution_context, model=inbound.model, provider_name=inbound.provider_name, embedding_model=inbound.embedding_model, channel_identity=channel_identity, ) except Exception as exc: return self.build_outbound_error( inbound, detail=str(exc), finish_reason=self._classify_inbound_failure(exc), ) return self.build_outbound_message(inbound, result) @staticmethod def _classify_inbound_failure(exc: Exception) -> str: """把 runtime 异常收口为更稳定的 bus finish reason。""" if isinstance(exc, RuntimeError): detail = str(exc) if ( "requires an active run() loop" in detail or "not accepting new tasks after stop()" in detail ): return "stopped" return "error" @staticmethod def build_outbound_message(inbound: InboundMessage, result: AgentRunResult) -> OutboundMessage: """把一次 runtime 正常结果转成 bus outbound。""" return OutboundMessage( message_id=inbound.message_id, channel=inbound.channel, session_id=result.session_id, run_id=result.run_id, content=result.output_text, finish_reason=result.finish_reason, provider_name=result.provider_name, model=result.model, content_type=inbound.content_type, channel_identity=inbound.channel_identity, usage=dict(result.usage), metadata={ "inbound_metadata": dict(inbound.metadata), "task_id": getattr(result, "task_id", None), "task_status": getattr(result, "task_status", None), "evidence_status": "recorded" if getattr(result, "task_id", None) else None, "validation_result": None, }, ) @staticmethod def build_outbound_error( inbound: InboundMessage, *, detail: str, finish_reason: str = "error", ) -> OutboundMessage: """把 inbound 处理失败转换成结构化 outbound 错误消息。""" return OutboundMessage( message_id=inbound.message_id, channel=inbound.channel, session_id=inbound.session_id, content=detail, finish_reason=finish_reason, content_type=inbound.content_type, channel_identity=inbound.channel_identity, metadata={"error": detail, "inbound_metadata": dict(inbound.metadata)}, ) def run_direct( self, message: str, **kwargs: Any, ) -> AgentRunResult: """同步 direct run 包装。 主要给当前 CLI 或简单脚本使用。真正的长期方向仍然是让 interfaces 在 direct mode 下直接走 `await process_direct(...)`。 """ try: asyncio.get_running_loop() except RuntimeError: pass else: raise RuntimeError( "AgentService.run_direct() cannot be used inside an active event loop; " "use 'await AgentService.process_direct(...)' instead." ) return asyncio.run(self.process_direct(message, **kwargs))