Initial commit
This commit is contained in:
commit
57fc3525eb
7311 files changed
+1291398
No files matched your search
@@ -0,0 +1,581 @@
|
||||
import copy
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from typing import Any, Dict, List, Optional, TYPE_CHECKING
|
||||
|
||||
from app.core.config import get_logger
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from app.core.tab_pool import TabSession
|
||||
|
||||
|
||||
logger = get_logger("CMD_ENG")
|
||||
|
||||
|
||||
class CommandEngineRuntimeMixin:
|
||||
def _workflow_queue_key(
|
||||
self,
|
||||
command: Dict[str, Any],
|
||||
trigger_rollback: Optional[Dict[str, Any]] = None,
|
||||
) -> str:
|
||||
cmd_id = str((command or {}).get("id", "")).strip()
|
||||
rollback = trigger_rollback or {}
|
||||
kind = str(rollback.get("kind", "") or "").strip()
|
||||
token = str(rollback.get("token", "") or "").strip()
|
||||
if cmd_id and kind and token:
|
||||
return f"{cmd_id}:{kind}:{token}"
|
||||
return cmd_id
|
||||
|
||||
def _dedupe_deferred_items(self, items: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
|
||||
deduped: List[Dict[str, Any]] = []
|
||||
seen: set[str] = set()
|
||||
for item in items or []:
|
||||
if not isinstance(item, dict):
|
||||
continue
|
||||
queue_key = str(item.get("queue_key", "") or "").strip()
|
||||
if not queue_key:
|
||||
queue_key = self._workflow_queue_key(
|
||||
item.get("command") or {},
|
||||
item.get("trigger_rollback") if isinstance(item.get("trigger_rollback"), dict) else None,
|
||||
)
|
||||
if queue_key:
|
||||
item = dict(item)
|
||||
item["queue_key"] = queue_key
|
||||
if queue_key and queue_key in seen:
|
||||
continue
|
||||
if queue_key:
|
||||
seen.add(queue_key)
|
||||
deduped.append(item)
|
||||
return deduped
|
||||
|
||||
def _has_active_workflow(self, session: 'TabSession') -> bool:
|
||||
runtime = self._get_active_workflow_runtime(session)
|
||||
return bool(runtime and runtime.get("active"))
|
||||
|
||||
def begin_workflow_runtime(
|
||||
self,
|
||||
session: 'TabSession',
|
||||
*,
|
||||
task_id: str = "",
|
||||
preset_name: str = "",
|
||||
priority: Optional[int] = None,
|
||||
) -> Dict[str, Any]:
|
||||
runtime = {
|
||||
"runtime_id": uuid.uuid4().hex,
|
||||
"task_id": str(task_id or "").strip(),
|
||||
"preset_name": str(preset_name or "").strip(),
|
||||
"parser_id": str(getattr(session, "_workflow_parser_id", "") or "").strip().lower(),
|
||||
"target_side": str(getattr(session, "_workflow_target_side", "") or "").strip().lower(),
|
||||
"priority": self._normalize_priority(priority, self._get_request_priority_baseline()),
|
||||
"current_step_index": -1,
|
||||
"current_step_action": "",
|
||||
"pending_interrupts": [],
|
||||
"pending_interrupt_ids": set(),
|
||||
"deferred_commands": [],
|
||||
"deferred_command_ids": set(),
|
||||
"active": True,
|
||||
"interrupting": False,
|
||||
}
|
||||
with self._lock:
|
||||
stack = list(getattr(session, "_workflow_runtime_stack", None) or [])
|
||||
stack.append(runtime)
|
||||
setattr(session, "_workflow_runtime_stack", stack)
|
||||
setattr(session, "_workflow_runtime_id", runtime["runtime_id"])
|
||||
setattr(session, "_workflow_target_side", runtime["target_side"])
|
||||
return runtime
|
||||
|
||||
def update_workflow_runtime_step(
|
||||
self,
|
||||
session: 'TabSession',
|
||||
step_index: int,
|
||||
step: Optional[Dict[str, Any]] = None,
|
||||
):
|
||||
runtime = self._get_active_workflow_runtime(session)
|
||||
if not runtime:
|
||||
return
|
||||
runtime["current_step_index"] = int(step_index)
|
||||
runtime["current_step_action"] = str((step or {}).get("action", "") or "")
|
||||
|
||||
def update_workflow_target_side(self, session: 'TabSession', side: str) -> bool:
|
||||
normalized = str(side or "").strip().lower()
|
||||
if normalized not in {"left", "right"}:
|
||||
return False
|
||||
runtime = self._get_active_workflow_runtime(session)
|
||||
if not runtime:
|
||||
return False
|
||||
runtime["target_side"] = normalized
|
||||
setattr(session, "_workflow_target_side", normalized)
|
||||
return True
|
||||
|
||||
def finish_workflow_runtime(
|
||||
self,
|
||||
session: 'TabSession',
|
||||
*,
|
||||
aborted: bool = False,
|
||||
) -> Optional[Dict[str, Any]]:
|
||||
with self._lock:
|
||||
stack = list(getattr(session, "_workflow_runtime_stack", None) or [])
|
||||
if not stack:
|
||||
return None
|
||||
runtime = stack.pop()
|
||||
setattr(session, "_workflow_runtime_stack", stack)
|
||||
|
||||
pending_interrupts = list(runtime.get("pending_interrupts") or [])
|
||||
deferred_commands = list(runtime.get("deferred_commands") or [])
|
||||
stop_reason = str(getattr(session, "_workflow_stop_reason", "") or "").strip()
|
||||
preserve_pending_interrupts = bool(pending_interrupts) and (
|
||||
not aborted or stop_reason in {"command_interrupt", "command_interrupt_abort"}
|
||||
)
|
||||
if preserve_pending_interrupts:
|
||||
deferred_ids = {
|
||||
str(item.get("queue_key", "") or "").strip()
|
||||
or self._workflow_queue_key(
|
||||
item.get("command") or {},
|
||||
item.get("trigger_rollback") if isinstance(item.get("trigger_rollback"), dict) else None,
|
||||
)
|
||||
for item in deferred_commands
|
||||
if isinstance(item, dict)
|
||||
}
|
||||
for item in pending_interrupts:
|
||||
if not isinstance(item, dict):
|
||||
continue
|
||||
command = copy.deepcopy(item.get("command") or {})
|
||||
queue_key = str(item.get("queue_key", "") or "").strip() or self._workflow_queue_key(
|
||||
command,
|
||||
item.get("trigger_rollback") if isinstance(item.get("trigger_rollback"), dict) else None,
|
||||
)
|
||||
if queue_key and queue_key in deferred_ids:
|
||||
continue
|
||||
deferred_commands.append({
|
||||
"command": command,
|
||||
"chain": list(item.get("chain") or []),
|
||||
"interrupt_context": copy.deepcopy(item.get("interrupt_context") or {}),
|
||||
"trigger_rollback": copy.deepcopy(item.get("trigger_rollback") or {}),
|
||||
"queue_key": queue_key,
|
||||
"queued_at": float(item.get("requested_at", time.time()) or time.time()),
|
||||
})
|
||||
if queue_key:
|
||||
deferred_ids.add(queue_key)
|
||||
|
||||
runtime["active"] = False
|
||||
runtime["interrupting"] = False
|
||||
runtime["pending_interrupts"] = []
|
||||
runtime["pending_interrupt_ids"] = set()
|
||||
|
||||
preserve_deferred = bool(deferred_commands) and (
|
||||
not aborted or stop_reason == "command_interrupt_abort"
|
||||
)
|
||||
if stack:
|
||||
parent = stack[-1]
|
||||
if preserve_deferred:
|
||||
parent_deferred = parent.setdefault("deferred_commands", [])
|
||||
parent_ids = parent.setdefault("deferred_command_ids", set())
|
||||
for item in deferred_commands:
|
||||
queue_key = str(item.get("queue_key", "") or "").strip() or self._workflow_queue_key(
|
||||
item.get("command") or {},
|
||||
item.get("trigger_rollback") if isinstance(item.get("trigger_rollback"), dict) else None,
|
||||
)
|
||||
if queue_key and queue_key in parent_ids:
|
||||
continue
|
||||
parent_deferred.append(item)
|
||||
if queue_key:
|
||||
parent_ids.add(queue_key)
|
||||
elif preserve_deferred:
|
||||
existing = list(getattr(session, "_pending_post_workflow_commands", None) or [])
|
||||
existing_ids = {
|
||||
str((item.get("command") or {}).get("id", "")).strip()
|
||||
for item in existing
|
||||
if isinstance(item, dict)
|
||||
}
|
||||
merged = self._dedupe_deferred_items(existing + deferred_commands)
|
||||
setattr(session, "_pending_post_workflow_commands", merged)
|
||||
else:
|
||||
setattr(session, "_pending_post_workflow_commands", [])
|
||||
|
||||
parent = stack[-1] if stack else None
|
||||
if parent:
|
||||
setattr(session, "_workflow_runtime_id", str(parent.get("runtime_id") or ""))
|
||||
setattr(session, "_workflow_parser_id", str(parent.get("parser_id") or ""))
|
||||
setattr(session, "_workflow_target_side", str(parent.get("target_side") or ""))
|
||||
else:
|
||||
setattr(session, "_workflow_runtime_id", "")
|
||||
setattr(session, "_workflow_parser_id", "")
|
||||
setattr(session, "_workflow_target_side", "")
|
||||
|
||||
return runtime
|
||||
|
||||
def flush_deferred_workflow_commands(self, session: 'TabSession'):
|
||||
if bool(getattr(self, "_shutdown_requested", False)):
|
||||
return
|
||||
with self._lock:
|
||||
items = list(getattr(session, "_pending_post_workflow_commands", None) or [])
|
||||
setattr(session, "_pending_post_workflow_commands", [])
|
||||
if not items:
|
||||
return
|
||||
|
||||
requeued = 0
|
||||
for item in items:
|
||||
command = copy.deepcopy((item or {}).get("command") or {})
|
||||
if not command or not command.get("enabled", True):
|
||||
continue
|
||||
dispatched = self._execute_command_async(
|
||||
command,
|
||||
session,
|
||||
chain=list((item or {}).get("chain") or []),
|
||||
interrupt_context=copy.deepcopy((item or {}).get("interrupt_context") or {}) or None,
|
||||
trigger_rollback=copy.deepcopy((item or {}).get("trigger_rollback") or {}) or None,
|
||||
)
|
||||
if dispatched:
|
||||
requeued += 1
|
||||
|
||||
logger.info(
|
||||
f"[CMD] 已将延后命令交回命令调度器执行 "
|
||||
f"(标签页={getattr(session, 'id', '')}, count={requeued})"
|
||||
)
|
||||
|
||||
def schedule_deferred_workflow_commands(
|
||||
self,
|
||||
session: 'TabSession',
|
||||
*,
|
||||
delay_sec: float = 0.25,
|
||||
):
|
||||
if bool(getattr(self, "_shutdown_requested", False)):
|
||||
return False
|
||||
delay = max(0.0, float(delay_sec or 0.0))
|
||||
|
||||
thread = threading.Thread(
|
||||
target=self.flush_deferred_workflow_commands,
|
||||
args=(session,),
|
||||
daemon=True,
|
||||
name=f"cmd-resume-delay-{getattr(session, 'id', 'tab')}",
|
||||
)
|
||||
if delay > 0:
|
||||
# Timer waits before dispatching, while command execution itself stays in
|
||||
# the command scheduler path instead of touching the tab from this helper.
|
||||
thread = threading.Timer(delay, self.flush_deferred_workflow_commands, args=(session,))
|
||||
thread.daemon = True
|
||||
thread.name = f"cmd-resume-delay-{getattr(session, 'id', 'tab')}"
|
||||
thread.start()
|
||||
return True
|
||||
|
||||
def _get_workflow_interrupt_policy(self, command: Dict[str, Any]) -> str:
|
||||
trigger = command.get("trigger", {}) or {}
|
||||
policy = str(
|
||||
trigger.get("interrupt_policy", command.get("interrupt_policy", "auto"))
|
||||
or "auto"
|
||||
).strip().lower()
|
||||
return policy if policy in {"auto", "resume", "abort"} else "auto"
|
||||
|
||||
def _build_workflow_interrupt_message(self, command: Dict[str, Any]) -> str:
|
||||
trigger = command.get("trigger", {}) or {}
|
||||
custom = str(
|
||||
trigger.get("interrupt_message", command.get("interrupt_message", ""))
|
||||
or ""
|
||||
).strip()
|
||||
if custom:
|
||||
return custom
|
||||
return f"触发 {command.get('name', '命令')},后续工作流已打断,请重试"
|
||||
|
||||
def _allow_command_during_workflow(self, command: Dict[str, Any]) -> bool:
|
||||
trigger = command.get("trigger", {}) or {}
|
||||
raw = trigger.get("allow_during_workflow", None)
|
||||
if raw is None:
|
||||
trigger_type = str(trigger.get("type", "")).strip().lower()
|
||||
if trigger_type != "page_check":
|
||||
return False
|
||||
policy = self._get_workflow_interrupt_policy(command)
|
||||
if policy in {"resume", "abort"}:
|
||||
return True
|
||||
return self._get_command_priority(command) > self._get_request_priority_baseline()
|
||||
return bool(raw)
|
||||
|
||||
def _queue_workflow_interrupt(
|
||||
self,
|
||||
command: Dict[str, Any],
|
||||
session: 'TabSession',
|
||||
chain: Optional[List[str]] = None,
|
||||
interrupt_context: Optional[Dict[str, Any]] = None,
|
||||
trigger_rollback: Optional[Dict[str, Any]] = None,
|
||||
) -> bool:
|
||||
runtime = self._get_active_workflow_runtime(session)
|
||||
if not runtime or not runtime.get("active"):
|
||||
return False
|
||||
if not self._allow_command_during_workflow(command):
|
||||
return False
|
||||
|
||||
queue_key = self._workflow_queue_key(command, trigger_rollback)
|
||||
if not queue_key:
|
||||
return False
|
||||
|
||||
with self._lock:
|
||||
pending_ids = runtime.setdefault("pending_interrupt_ids", set())
|
||||
if queue_key in pending_ids:
|
||||
return False
|
||||
|
||||
runtime.setdefault("pending_interrupts", []).append({
|
||||
"command": copy.deepcopy(command),
|
||||
"chain": list(chain or []),
|
||||
"interrupt_context": copy.deepcopy(interrupt_context or {}),
|
||||
"trigger_rollback": copy.deepcopy(trigger_rollback or {}),
|
||||
"queue_key": queue_key,
|
||||
"requested_at": time.time(),
|
||||
"priority": self._get_command_priority(command),
|
||||
})
|
||||
pending_ids.add(queue_key)
|
||||
setattr(session, "_workflow_stop_reason", "command_interrupt")
|
||||
logger.info(
|
||||
f"[CMD] 请求暂停工作流: {command.get('name')} "
|
||||
f"(标签页={session.id}, 工作流优先级={runtime.get('priority')}, "
|
||||
f"命令优先级={self._get_command_priority(command)})"
|
||||
)
|
||||
return True
|
||||
|
||||
def _schedule_command_for_active_workflow(
|
||||
self,
|
||||
command: Dict[str, Any],
|
||||
session: 'TabSession',
|
||||
chain: Optional[List[str]] = None,
|
||||
interrupt_context: Optional[Dict[str, Any]] = None,
|
||||
trigger_rollback: Optional[Dict[str, Any]] = None,
|
||||
) -> bool:
|
||||
runtime = self._get_active_workflow_runtime(session)
|
||||
if not runtime or not runtime.get("active"):
|
||||
return False
|
||||
|
||||
if self._allow_command_during_workflow(command):
|
||||
return self._queue_workflow_interrupt(
|
||||
command,
|
||||
session,
|
||||
chain=chain,
|
||||
interrupt_context=interrupt_context,
|
||||
trigger_rollback=trigger_rollback,
|
||||
)
|
||||
|
||||
self._defer_command_until_workflow_resume(
|
||||
runtime,
|
||||
command,
|
||||
chain=chain,
|
||||
interrupt_context=interrupt_context,
|
||||
trigger_rollback=trigger_rollback,
|
||||
)
|
||||
logger.info(
|
||||
f"[CMD] 工作流忙碌,延后执行命令: {command.get('name')} "
|
||||
f"(标签页={session.id}, 工作流优先级={runtime.get('priority')}, "
|
||||
f"命令优先级={self._get_command_priority(command)})"
|
||||
)
|
||||
return True
|
||||
|
||||
def workflow_interrupt_requested(self, session: 'TabSession') -> bool:
|
||||
runtime = self._get_active_workflow_runtime(session)
|
||||
if not runtime:
|
||||
return False
|
||||
with self._lock:
|
||||
return bool(runtime.get("pending_interrupts"))
|
||||
|
||||
def _defer_command_until_workflow_resume(
|
||||
self,
|
||||
runtime: Dict[str, Any],
|
||||
command: Dict[str, Any],
|
||||
chain: Optional[List[str]] = None,
|
||||
interrupt_context: Optional[Dict[str, Any]] = None,
|
||||
trigger_rollback: Optional[Dict[str, Any]] = None,
|
||||
):
|
||||
queue_key = self._workflow_queue_key(command, trigger_rollback)
|
||||
if not queue_key:
|
||||
return
|
||||
with self._lock:
|
||||
deferred_ids = runtime.setdefault("deferred_command_ids", set())
|
||||
if queue_key in deferred_ids:
|
||||
return
|
||||
runtime.setdefault("deferred_commands", []).append({
|
||||
"command": copy.deepcopy(command),
|
||||
"chain": list(chain or []),
|
||||
"interrupt_context": copy.deepcopy(interrupt_context or {}),
|
||||
"trigger_rollback": copy.deepcopy(trigger_rollback or {}),
|
||||
"queue_key": queue_key,
|
||||
"queued_at": time.time(),
|
||||
})
|
||||
deferred_ids.add(queue_key)
|
||||
|
||||
def _mark_interrupt_abort(
|
||||
self,
|
||||
command: Dict[str, Any],
|
||||
interrupt_context: Dict[str, Any],
|
||||
):
|
||||
if interrupt_context.get("abort"):
|
||||
return
|
||||
policy = self._get_workflow_interrupt_policy(command)
|
||||
priority = self._get_command_priority(command)
|
||||
workflow_priority = self._normalize_priority(
|
||||
interrupt_context.get("workflow_priority", self._get_request_priority_baseline()),
|
||||
self._get_request_priority_baseline(),
|
||||
)
|
||||
if policy == "abort" or (policy == "auto" and priority > workflow_priority):
|
||||
interrupt_context["abort"] = True
|
||||
interrupt_context["message"] = self._build_workflow_interrupt_message(command)
|
||||
interrupt_context["abort_by"] = command.get("name", "")
|
||||
|
||||
def _dispatch_interrupt_followup_command(
|
||||
self,
|
||||
command: Dict[str, Any],
|
||||
session: 'TabSession',
|
||||
chain: Optional[List[str]],
|
||||
interrupt_context: Dict[str, Any],
|
||||
):
|
||||
runtime = interrupt_context.get("runtime") or {}
|
||||
workflow_priority = self._normalize_priority(
|
||||
interrupt_context.get("workflow_priority", self._get_request_priority_baseline()),
|
||||
self._get_request_priority_baseline(),
|
||||
)
|
||||
priority = self._get_command_priority(command)
|
||||
policy = self._get_workflow_interrupt_policy(command)
|
||||
|
||||
if priority > workflow_priority or policy == "abort":
|
||||
logger.info(
|
||||
f"[CMD] 工作流暂停期间继续执行高优先级命令: {command.get('name')} "
|
||||
f"(标签页={session.id}, 命令优先级={priority}, 工作流优先级={workflow_priority})"
|
||||
)
|
||||
self._execute_command(command, session, chain=chain, interrupt_context=interrupt_context)
|
||||
self._mark_interrupt_abort(command, interrupt_context)
|
||||
return
|
||||
|
||||
logger.info(
|
||||
f"[CMD] 延后命令至工作流恢复后执行: {command.get('name')} "
|
||||
f"(标签页={session.id}, 命令优先级={priority}, 工作流优先级={workflow_priority})"
|
||||
)
|
||||
self._defer_command_until_workflow_resume(
|
||||
runtime,
|
||||
command,
|
||||
chain=chain,
|
||||
interrupt_context=interrupt_context,
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def _interrupt_item_sort_key(item: Dict[str, Any]) -> tuple[int, float]:
|
||||
try:
|
||||
priority = int(item.get("priority", 0) or 0)
|
||||
except (TypeError, ValueError):
|
||||
priority = 0
|
||||
try:
|
||||
requested_at = float(item.get("requested_at", 0.0) or 0.0)
|
||||
except (TypeError, ValueError):
|
||||
requested_at = 0.0
|
||||
return -priority, requested_at
|
||||
|
||||
def _take_next_pending_interrupt(
|
||||
self,
|
||||
runtime: Dict[str, Any],
|
||||
) -> Optional[Dict[str, Any]]:
|
||||
with self._lock:
|
||||
raw_pending = runtime.get("pending_interrupts") or []
|
||||
pending = raw_pending if isinstance(raw_pending, list) else list(raw_pending)
|
||||
pending = [item for item in pending if isinstance(item, dict)]
|
||||
if not pending:
|
||||
runtime["pending_interrupts"] = []
|
||||
runtime["pending_interrupt_ids"] = set()
|
||||
return None
|
||||
|
||||
best_index = 0
|
||||
best_key = self._interrupt_item_sort_key(pending[0])
|
||||
for index in range(1, len(pending)):
|
||||
key = self._interrupt_item_sort_key(pending[index])
|
||||
if key < best_key:
|
||||
best_index = index
|
||||
best_key = key
|
||||
|
||||
item = pending.pop(best_index)
|
||||
runtime["pending_interrupts"] = pending
|
||||
return item
|
||||
|
||||
def _drop_pending_interrupts_by_key(
|
||||
self,
|
||||
runtime: Dict[str, Any],
|
||||
queue_key: str,
|
||||
) -> None:
|
||||
if not queue_key:
|
||||
return
|
||||
with self._lock:
|
||||
runtime["pending_interrupts"] = [
|
||||
existing for existing in runtime.get("pending_interrupts", [])
|
||||
if isinstance(existing, dict)
|
||||
and (
|
||||
str(existing.get("queue_key", "") or "").strip()
|
||||
or self._workflow_queue_key(
|
||||
(existing.get("command") or {}),
|
||||
existing.get("trigger_rollback") if isinstance(existing.get("trigger_rollback"), dict) else None,
|
||||
)
|
||||
) != queue_key
|
||||
]
|
||||
|
||||
def handle_pending_workflow_interrupts(self, session: 'TabSession') -> Dict[str, Any]:
|
||||
runtime = self._get_active_workflow_runtime(session)
|
||||
if not runtime or runtime.get("interrupting"):
|
||||
return {"handled": False, "abort": False, "message": ""}
|
||||
|
||||
with self._lock:
|
||||
pending = list(runtime.get("pending_interrupts") or [])
|
||||
if not pending:
|
||||
return {"handled": False, "abort": False, "message": ""}
|
||||
|
||||
with self._lock:
|
||||
if runtime.get("interrupting"):
|
||||
return {"handled": False, "abort": False, "message": ""}
|
||||
runtime["interrupting"] = True
|
||||
interrupt_context = {
|
||||
"workflow_priority": runtime.get("priority", self._get_request_priority_baseline()),
|
||||
"runtime": runtime,
|
||||
"abort": False,
|
||||
"message": "",
|
||||
"abort_by": "",
|
||||
}
|
||||
|
||||
try:
|
||||
while True:
|
||||
item = self._take_next_pending_interrupt(runtime)
|
||||
if not item:
|
||||
break
|
||||
cmd = copy.deepcopy(item.get("command") or {})
|
||||
chain = list(item.get("chain") or [])
|
||||
queue_key = str(item.get("queue_key", "") or "").strip() or self._workflow_queue_key(
|
||||
cmd,
|
||||
item.get("trigger_rollback") if isinstance(item.get("trigger_rollback"), dict) else None,
|
||||
)
|
||||
interrupt_payload = copy.deepcopy(item.get("interrupt_context") or {})
|
||||
|
||||
self._drop_pending_interrupts_by_key(runtime, queue_key)
|
||||
with self._lock:
|
||||
runtime.setdefault("pending_interrupt_ids", set()).discard(queue_key)
|
||||
|
||||
if not cmd or not cmd.get("enabled", True):
|
||||
continue
|
||||
|
||||
logger.info(
|
||||
f"[CMD] 工作流已暂停,执行插队命令: {cmd.get('name')} "
|
||||
f"(标签页={session.id}, 步骤={runtime.get('current_step_index')})"
|
||||
)
|
||||
merged_context = dict(interrupt_context)
|
||||
if interrupt_payload:
|
||||
merged_context.update(interrupt_payload)
|
||||
self._execute_command(cmd, session, chain=chain, interrupt_context=merged_context)
|
||||
self._mark_interrupt_abort(cmd, interrupt_context)
|
||||
if interrupt_context.get("abort"):
|
||||
with self._lock:
|
||||
runtime["pending_interrupts"] = []
|
||||
runtime["pending_interrupt_ids"] = set()
|
||||
break
|
||||
finally:
|
||||
with self._lock:
|
||||
runtime["interrupting"] = False
|
||||
|
||||
if interrupt_context.get("abort"):
|
||||
setattr(session, "_workflow_stop_reason", "command_interrupt_abort")
|
||||
else:
|
||||
setattr(session, "_workflow_stop_reason", None)
|
||||
|
||||
return {
|
||||
"handled": True,
|
||||
"abort": bool(interrupt_context.get("abort")),
|
||||
"message": str(interrupt_context.get("message", "") or ""),
|
||||
"abort_by": str(interrupt_context.get("abort_by", "") or ""),
|
||||
}
|
||||
Reference in new issue
Block a user