import threading import time from dataclasses import dataclass, field from enum import Enum from typing import Any, Dict, Optional from urllib.parse import urlsplit from app.core.config import logger from app.utils.site_url import ( encode_tab_url_route_token, extract_remote_site_domain, get_preferred_route_domain, ) from ._utils import _TAB_HEALTH_CACHE_TTL_SEC, _should_skip_pool_url from app.core.driver import driver_for_tab class TabStatus(Enum): """标签页状态""" IDLE = "idle" BUSY = "busy" ERROR = "error" CLOSED = "closed" @dataclass class TabSession: """标签页会话""" id: str tab: Any status: TabStatus = TabStatus.IDLE current_task_id: Optional[str] = None current_command_name: Optional[str] = None current_domain: Optional[str] = None last_known_url: Optional[str] = None created_at: float = field(default_factory=time.time) last_used_at: float = field(default_factory=time.time) request_count: int = 0 error_count: int = 0 persistent_index: int = 0 # 🆕 持久化编号(重启前不变) preset_name: Optional[str] = None # 🆕 当前显式指定的预设名称(None = 跟随站点默认预设) preset_override_source: Optional[str] = None # 预设来源(url: 来自 URL 记忆, tab: 标签页临时指定, None: 默认) model_name_override: Optional[str] = None # 当前标签页临时暴露模型名(关闭标签页后失效) browser_context_id: Optional[str] = None is_isolated_context: bool = False transient_disconnect_until: float = 0.0 transient_disconnect_reason: Optional[str] = None last_conversation_activity_at: float = 0.0 last_conversation_domain: Optional[str] = None last_conversation_preset_name: Optional[str] = None command_loop_started_at: float = 0.0 command_loop_iteration: Optional[int] = None command_loop_total: Optional[int] = None command_loop_label: Optional[str] = None command_loop_cancel_requested: bool = False command_loop_cancel_reason: Optional[str] = None command_loop_cancel_requested_at: float = 0.0 _health_cache_until: float = field(default=0.0, repr=False) _health_cache_result: bool = field(default=False, repr=False) _health_cache_url: str = field(default="", repr=False) _health_cache_domain: str = field(default="", repr=False) _release_in_progress: bool = field(default=False, repr=False) _termination_in_progress: bool = field(default=False, repr=False) _termination_task_id: Optional[str] = field(default=None, repr=False) _termination_interrupt_done: bool = field(default=False, repr=False) _workflow_parser_id: str = field(default="", repr=False) _workflow_target_side: str = field(default="", repr=False) _workflow_runtime_id: str = field(default="", repr=False) _request_occupied_url: Optional[str] = field(default=None, repr=False) _lock: threading.RLock = field(default_factory=threading.RLock, repr=False) @property def driver(self): """R2-1:该标签页的统一驱动(按标签页对象复用同一个包装)。迁移中的代码通过它访问浏览器。""" return driver_for_tab(self.tab) def is_available(self) -> bool: with self._lock: return self.status == TabStatus.IDLE and not self._termination_in_progress def is_in_transient_disconnect(self) -> bool: return self.transient_disconnect_until > time.time() def mark_transient_disconnect(self, seconds: float, reason: str = None): with self._lock: self.transient_disconnect_until = time.time() + max(0.1, float(seconds)) self.transient_disconnect_reason = str(reason or "").strip() or None def clear_transient_disconnect(self): with self._lock: self.transient_disconnect_until = 0.0 self.transient_disconnect_reason = None def set_preset(self, preset_name: Optional[str], source: Optional[str] = None) -> bool: """线程安全地设置预设及来源""" with self._lock: old_preset = self.preset_name self.preset_name = str(preset_name).strip() if preset_name else None self.preset_override_source = str(source).strip() if (source and self.preset_name) else None if old_preset != self.preset_name: self._reset_conversation_state_unlocked() return True def _clear_health_cache_unlocked(self): self._health_cache_until = 0.0 self._health_cache_result = False self._health_cache_url = "" self._health_cache_domain = "" def _clear_command_loop_unlocked(self): self.command_loop_started_at = 0.0 self.command_loop_iteration = None self.command_loop_total = None self.command_loop_label = None self.command_loop_cancel_requested = False self.command_loop_cancel_reason = None self.command_loop_cancel_requested_at = 0.0 def begin_command_loop( self, *, iteration: Optional[int] = None, total: Optional[int] = None, label: str = "", ) -> Dict[str, Any]: now = time.time() with self._lock: self.command_loop_started_at = now self.command_loop_iteration = iteration if iteration is None else int(iteration) self.command_loop_total = total if total is None else int(total) self.command_loop_label = str(label or "").strip() or None self.command_loop_cancel_requested = False self.command_loop_cancel_reason = None self.command_loop_cancel_requested_at = 0.0 return self._command_loop_info_unlocked(now=now) def end_command_loop(self, status: str = "completed") -> Dict[str, Any]: now = time.time() with self._lock: info = self._command_loop_info_unlocked(now=now) info["final_status"] = str(status or "").strip() or "completed" self._clear_command_loop_unlocked() return info def request_command_loop_cancel(self, reason: str = "manual_loop_cancel") -> bool: now = time.time() with self._lock: if not self.command_loop_started_at: return False self.command_loop_cancel_requested = True self.command_loop_cancel_reason = str(reason or "").strip() or "manual_loop_cancel" self.command_loop_cancel_requested_at = now return True def is_command_loop_cancelled(self) -> bool: with self._lock: return bool(self.command_loop_cancel_requested) def _command_loop_info_unlocked(self, *, now: Optional[float] = None) -> Dict[str, Any]: current_time = time.time() if now is None else float(now) started_at = float(self.command_loop_started_at or 0.0) active = started_at > 0 elapsed = max(0.0, current_time - started_at) if active else 0.0 return { "active": active, "iteration": self.command_loop_iteration, "total": self.command_loop_total, "label": self.command_loop_label or "", "started_at": started_at or None, "elapsed_sec": round(elapsed, 1), "cancel_requested": bool(self.command_loop_cancel_requested), "cancel_reason": self.command_loop_cancel_reason or "", } def get_command_loop_info(self) -> Dict[str, Any]: with self._lock: return self._command_loop_info_unlocked() def touch_activity(self) -> None: with self._lock: self.last_used_at = time.time() def get_busy_timeout_info(self, *, now: Optional[float] = None) -> Dict[str, Any]: current_time = time.time() if now is None else float(now) with self._lock: loop_started_at = float(self.command_loop_started_at or 0.0) if loop_started_at > 0: reference_at = loop_started_at basis = "command_loop" else: reference_at = float(self.last_used_at or current_time) basis = "session" return { "basis": basis, "started_at": reference_at, "duration": max(0.0, current_time - reference_at), "command_loop": self._command_loop_info_unlocked(now=current_time), } def is_healthy(self, *, allow_live_check: bool = True) -> bool: """检查标签页是否健康,避免在忙碌时额外触发 live CDP 读取。""" now = time.time() with self._lock: status = self.status cached_url = str(self.last_known_url or "").strip() cached_domain = str(self.current_domain or "").strip() cache_valid = ( status == TabStatus.IDLE and self._health_cache_until > now and self._health_cache_url == cached_url and self._health_cache_domain == cached_domain ) if cache_valid: return bool(self._health_cache_result) if status == TabStatus.CLOSED: return False if status == TabStatus.BUSY: if cached_url: return not _should_skip_pool_url(cached_url) return bool(cached_domain) if not allow_live_check: if cached_url: return not _should_skip_pool_url(cached_url) return bool(cached_domain) url = self._safe_get_url() result = bool(url and not _should_skip_pool_url(url)) with self._lock: self._health_cache_result = result self._health_cache_url = str(self.last_known_url or "").strip() self._health_cache_domain = str(self.current_domain or "").strip() self._health_cache_until = time.time() + _TAB_HEALTH_CACHE_TTL_SEC return result def get_cached_route_snapshot(self) -> tuple[str, str]: """Return cached URL/domain without touching the live tab/CDP endpoint.""" with self._lock: cached_url = str(self.last_known_url or "").strip() cached_domain = str(self.current_domain or "").strip() if cached_url: cached_domain = self._refresh_current_domain(cached_url) return cached_url, cached_domain def _debug_summary_unlocked(self) -> str: status_value = getattr(self.status, "value", str(self.status)) return ( f"idx=#{self.persistent_index or '-'}, " f"status={status_value}, " f"task={str(self.current_task_id or '').strip() or '-'}, " f"bound_req={str(getattr(self, '_bound_request_id', '') or '').strip() or '-'}, " f"cmd_req={str(getattr(self, '_command_request_id', '') or '').strip() or '-'}, " f"req_count={self.request_count}, " f"domain={str(self.current_domain or '').strip() or '-'}" ) def debug_summary(self) -> str: with self._lock: return self._debug_summary_unlocked() # B5:解冻失败后的冷却期,期间 acquire 直接跳过该会话,避免每次都卡 2 秒 CDP 超时 _RESUME_FAILURE_BACKOFF_SEC = 10.0 def acquire(self, task_id: str) -> bool: if self._resume_recently_failed(): return False if not self._acquire_request_unlocked_entry(task_id): return False if not self._resume_after_acquire("acquire"): self._rollback_failed_acquire(task_id, request_mode=True) return False return True def acquire_for_command(self, task_id: str) -> bool: """Acquire tab for command execution without incrementing request counter.""" if self._resume_recently_failed(): return False if not self._acquire_command_unlocked_entry(task_id): return False if not self._resume_after_acquire("acquire_for_command"): self._rollback_failed_acquire(task_id, request_mode=False) return False return True def _resume_recently_failed(self) -> bool: if not getattr(self, "_uwapi_frozen", False): return False failed_at = float(getattr(self, "_uwapi_resume_failed_at", 0.0) or 0.0) return bool(failed_at) and (time.time() - failed_at) < self._RESUME_FAILURE_BACKOFF_SEC def _resume_after_acquire(self, reason: str) -> bool: """P0-6:被空闲冻结的标签页在交给调用方之前恢复为 active。 B5:返回该会话是否可交付——解冻失败(仍处于冻结态)返回 False。 """ try: from .idle_maintenance import resume_if_frozen resume_if_frozen(self, reason=reason) except Exception as e: logger.debug(f"[{self.id}] resume frozen tab failed: {e}") return not bool(getattr(self, "_uwapi_frozen", False)) def _rollback_failed_acquire(self, task_id: str, *, request_mode: bool) -> None: """B5:解冻失败时撤销本次占用,把会话退回 IDLE(保留冻结标记),不交付给调用方。""" with self._lock: if self.status != TabStatus.BUSY or str(self.current_task_id or "") != str(task_id or ""): return self.status = TabStatus.IDLE self.current_task_id = None if request_mode and self.request_count > 0: self.request_count -= 1 self._clear_health_cache_unlocked() logger.warning( f"[{self.id}] 标签页解冻失败,本次不交付该会话(task={task_id})," f"{self._RESUME_FAILURE_BACKOFF_SEC:.0f}s 内跳过" ) def _acquire_request_unlocked_entry(self, task_id: str) -> bool: with self._lock: if self.status != TabStatus.IDLE or self._termination_in_progress: return False prev_status = self.status.value prev_task = str(self.current_task_id or "").strip() prev_request_count = self.request_count self.status = TabStatus.BUSY self.current_task_id = task_id self._clear_health_cache_unlocked() self._clear_command_loop_unlocked() self._workflow_parser_id = "" self._workflow_target_side = "" self._workflow_runtime_id = "" self._request_occupied_url = None setattr(self, "_last_cancel_request_task_id", None) setattr(self, "_last_cancel_request_reason", None) self.last_used_at = time.time() self.request_count += 1 logger.debug( f"[{self.id}] 会话占用: mode=request, idx=#{self.persistent_index or '-'}, " f"prev_status={prev_status}, prev_task={prev_task or '-'}, " f"new_task={str(task_id or '').strip() or '-'}, " f"req_count={prev_request_count}->{self.request_count}" ) return True def _acquire_command_unlocked_entry(self, task_id: str) -> bool: with self._lock: if self.status != TabStatus.IDLE or self._termination_in_progress: return False prev_status = self.status.value prev_task = str(self.current_task_id or "").strip() self.status = TabStatus.BUSY self.current_task_id = task_id self._clear_health_cache_unlocked() self._clear_command_loop_unlocked() self._workflow_parser_id = "" self._workflow_target_side = "" self._workflow_runtime_id = "" setattr(self, "_last_cancel_request_task_id", None) setattr(self, "_last_cancel_request_reason", None) self.last_used_at = time.time() logger.debug( f"[{self.id}] 会话占用: mode=command, idx=#{self.persistent_index or '-'}, " f"prev_status={prev_status}, prev_task={prev_task or '-'}, " f"new_task={str(task_id or '').strip() or '-'}, " f"req_count={self.request_count}" ) return True def _begin_release_state( self, *, clear_page: bool, rollback_request_count: bool = False, force: bool = False, expected_task_id: str = "", reject_ownerless: bool = False, ) -> Optional[Dict[str, Any]]: with self._lock: if self._release_in_progress: action = "force_release" if force else "release" logger.debug(f"[{self.id}] {action} skipped: another release is already in progress") return None expected_task = str(expected_task_id or "").strip() current_task = str(self.current_task_id or "").strip() if current_task and reject_ownerless and not expected_task: logger.warning( f"[{self.id}] release skipped without ownership (current_task={current_task})" ) return None if expected_task and current_task != expected_task: logger.warning( f"[{self.id}] release ownership mismatch " f"(expected_task={expected_task}, current_task={current_task or '-'})" ) return None prev_status_obj = self.status prev_status = prev_status_obj.value prev_task = str(self.current_task_id or "").strip() prev_bound_request_id = str(getattr(self, "_bound_request_id", "") or "").strip() prev_command_request_id = str(getattr(self, "_command_request_id", "") or "").strip() prev_request_count = self.request_count prev_was_error = prev_status_obj == TabStatus.ERROR prev_was_closed = prev_status_obj == TabStatus.CLOSED if rollback_request_count and self.request_count > 0 and ( prev_task or prev_status_obj == TabStatus.BUSY ): self.request_count -= 1 needs_cleanup_window = True if needs_cleanup_window: self._release_in_progress = True if not prev_was_error and not prev_was_closed: self.status = TabStatus.BUSY elif not prev_was_error and not prev_was_closed: self.status = TabStatus.IDLE self.current_task_id = None self.current_command_name = None self._clear_health_cache_unlocked() self._clear_command_loop_unlocked() setattr(self, "_bound_request_id", None) setattr(self, "_command_request_id", None) setattr(self, "_command_loop_request_id", None) setattr(self, "_command_vars", {}) self._workflow_parser_id = "" self._workflow_target_side = "" self._workflow_runtime_id = "" self._request_occupied_url = None self.last_used_at = time.time() return { "prev_status": prev_status, "prev_task": prev_task, "prev_bound_request_id": prev_bound_request_id, "prev_command_request_id": prev_command_request_id, "prev_request_count": prev_request_count, "new_request_count": self.request_count, "prev_was_error": prev_was_error, "prev_was_closed": prev_was_closed, "needs_cleanup_window": needs_cleanup_window, } def _finish_release_state(self, state: Dict[str, Any], success: bool) -> None: if not state.get("needs_cleanup_window"): return with self._lock: if success: if ( self.status == TabStatus.BUSY and not state.get("prev_was_error") and not state.get("prev_was_closed") ): self.status = TabStatus.IDLE elif self.status != TabStatus.CLOSED: self.status = TabStatus.ERROR self.error_count += 1 termination_task = str(self._termination_task_id or "").strip() released_task = str(state.get("prev_task") or "").strip() if self._termination_in_progress and self._termination_interrupt_done and ( not termination_task or termination_task == released_task ): self._termination_in_progress = False self._termination_task_id = None self._termination_interrupt_done = False self._release_in_progress = False def begin_termination(self, expected_task_id: str = "") -> Dict[str, Any]: """Quarantine this session until its current owner finishes releasing it.""" with self._lock: expected_task = str(expected_task_id or "").strip() current_task = str(self.current_task_id or "").strip() if expected_task and current_task != expected_task: return { "ok": False, "error": "task_ownership_changed", "expected_task_id": expected_task, "current_task_id": current_task, } if self._release_in_progress: return {"ok": False, "error": "release_in_progress"} if self._termination_in_progress: return { "ok": False, "error": "termination_in_progress", "current_task_id": current_task, } self._termination_in_progress = True self._termination_task_id = current_task or expected_task or None self._termination_interrupt_done = False return { "ok": True, "task_id": current_task, "status": self.status.value, "command_request_id": str( getattr(self, "_command_request_id", "") or "" ).strip(), "command_loop_request_id": str( getattr(self, "_command_loop_request_id", "") or "" ).strip(), } def finish_ownerless_termination(self) -> None: """Release the quarantine for a session that had no active owner.""" with self._lock: if self.current_task_id or self._release_in_progress: return self._termination_in_progress = False self._termination_task_id = None self._termination_interrupt_done = False def is_termination_in_progress(self) -> bool: with self._lock: return bool(self._termination_in_progress) def interrupt_for_termination(self, clear_page: bool = False) -> bool: """Interrupt page activity without making the session available for reuse.""" self.clear_visibility_emulation("terminate") success = True try: if hasattr(self.tab, "stop_loading"): self.tab.stop_loading() driver_for_tab(self.tab).run_js("if (window.stop) { window.stop(); }") except Exception: pass if clear_page: try: self.tab.refresh() self.reset_conversation_state() self.notify_navigated(reason="termination_clear") except Exception as e: logger.warning(f"[{self.id}] terminate refresh failed: {e}") success = False with self._lock: self._termination_interrupt_done = True if not self.current_task_id and not self._release_in_progress: self._termination_in_progress = False self._termination_task_id = None self._termination_interrupt_done = False return success def _run_release_from_state( self, state: Dict[str, Any], *, clear_page: bool, check_triggers: bool, rollback_request_count: bool, ) -> None: clear_page_success = True if clear_page: try: self.tab.get("about:blank") with self._lock: self.current_domain = None self.last_known_url = None self.preset_name = None self.preset_override_source = None self._clear_health_cache_unlocked() self.last_conversation_activity_at = 0.0 self.last_conversation_domain = None self.last_conversation_preset_name = None self.notify_navigated(reason="release_clear_page") except Exception as e: clear_page_success = False logger.debug(f"clear page failed: {e}") logger.debug( f"[{self.id}] 会话释放: idx=#{self.persistent_index or '-'}, " f"prev_status={state['prev_status']}, prev_task={state['prev_task'] or '-'}, " f"prev_bound_req={state['prev_bound_request_id'] or '-'}, " f"prev_cmd_req={state['prev_command_request_id'] or '-'}, " f"clear_page={clear_page}, check_triggers={check_triggers}, " f"rollback_request_count={rollback_request_count}, " f"req_count={state['prev_request_count']}->{state['new_request_count']}, " f"clear_page_success={clear_page_success}" ) self.clear_visibility_emulation("release") self._finish_release_state(state, clear_page_success) try: from app.services.command_engine import command_engine if check_triggers: command_engine.check_triggers(self) except Exception as e: logger.debug(f"命令触发检查异常: {e}") def release( self, clear_page: bool = False, check_triggers: bool = True, rollback_request_count: bool = False, expected_task_id: str = "", ) -> bool: state = self._begin_release_state( clear_page=clear_page, rollback_request_count=rollback_request_count, force=False, expected_task_id=expected_task_id, reject_ownerless=True, ) if state is None: return False self._run_release_from_state( state, clear_page=clear_page, check_triggers=check_triggers, rollback_request_count=rollback_request_count, ) return self.status == TabStatus.IDLE def _run_force_release_from_state( self, state: Dict[str, Any], *, clear_page: bool, check_triggers: bool, ) -> None: logger.warning( f"[{self.id}] 强制释放开始: idx=#{self.persistent_index or '-'}, " f"prev_status={state['prev_status']}, prev_task={state['prev_task'] or '-'}, " f"prev_bound_req={state['prev_bound_request_id'] or '-'}, " f"prev_cmd_req={state['prev_command_request_id'] or '-'}, " f"req_count={state['prev_request_count']}, clear_page={clear_page}, " f"check_triggers={check_triggers}" ) self.clear_visibility_emulation("force_release") try: if hasattr(self.tab, "stop_loading"): self.tab.stop_loading() driver_for_tab(self.tab).run_js("if (window.stop) { window.stop(); }") except Exception: pass reset_success = True if clear_page: try: self.tab.refresh() self.reset_conversation_state() self.notify_navigated(reason="force_release_clear") except Exception as e: logger.warning(f"[{self.id}] force_release refresh failed: {e}") reset_success = False self._finish_release_state(state, reset_success) with self._lock: final_status = self.status.value final_task = str(self.current_task_id or "").strip() request_count = self.request_count error_count = self.error_count if reset_success: logger.info( f"[{self.id}] force_release done " f"(idx=#{self.persistent_index or '-'}, final_status={final_status}, " f"task={final_task or '-'}, req_count={request_count})" ) else: logger.warning( f"[{self.id}] force_release failed, set ERROR " f"(idx=#{self.persistent_index or '-'}, req_count={request_count}, " f"error_count={error_count})" ) if check_triggers: try: from app.services.command_engine import command_engine command_engine.check_triggers(self) except Exception as e: logger.debug(f"command trigger check failed: {e}") def force_release(self, clear_page: bool = False, check_triggers: bool = False): """Force release tab lock and optionally refresh current page.""" state = self._begin_release_state(clear_page=clear_page, force=True) if state is None: return self._run_force_release_from_state( state, clear_page=clear_page, check_triggers=check_triggers, ) def activate(self) -> bool: """激活标签页(使其成为浏览器焦点)""" try: self.tab.set.activate() logger.debug(f"[{self.id}] 已激活") return True except Exception as e: logger.warning(f"[{self.id}] 激活失败: {e}") return False def mark_error(self, reason: str = None): with self._lock: self.status = TabStatus.ERROR self._clear_health_cache_unlocked() self.error_count += 1 logger.warning(f"[{self.id}] 标记为错误: {reason}") def mark_closed(self, reason: str = None): with self._lock: if self.status == TabStatus.CLOSED: return self.status = TabStatus.CLOSED self.current_task_id = None self._release_in_progress = False self._termination_in_progress = False self._termination_task_id = None self._termination_interrupt_done = False self.transient_disconnect_until = 0.0 self.transient_disconnect_reason = None self._clear_health_cache_unlocked() logger.debug(f"[{self.id}] 标记为关闭: {reason or '-'}") def _reset_conversation_state_unlocked(self): self.last_conversation_activity_at = 0.0 self.last_conversation_domain = None self.last_conversation_preset_name = None def reset_conversation_state(self): with self._lock: self._reset_conversation_state_unlocked() def mark_conversation_activity(self, domain: str = "", preset_name: str = ""): normalized_domain = str(domain or "").strip().lower() or None normalized_preset = str(preset_name or "").strip() or None now = time.time() with self._lock: self.last_conversation_activity_at = now self.last_conversation_domain = normalized_domain self.last_conversation_preset_name = normalized_preset logger.debug( f"[{self.id}] 记录会话活动: idx=#{self.persistent_index or '-'}, " f"domain={normalized_domain or '-'}, preset={normalized_preset or '-'}, " f"at={round(now, 3)}" ) def get_conversation_status( self, current_domain: str = "", preset_name: str = "", threshold_seconds: float = 0.0, force_new: bool = False, ) -> Dict[str, Any]: normalized_domain = str(current_domain or self.current_domain or "").strip().lower() normalized_preset = str(preset_name or "").strip() or None threshold_value = max(0.0, float(threshold_seconds or 0.0)) with self._lock: last_activity_at = float(self.last_conversation_activity_at or 0.0) last_domain = str(self.last_conversation_domain or "").strip().lower() last_preset = str(self.last_conversation_preset_name or "").strip() or None elapsed_seconds = None if last_activity_at > 0: elapsed_seconds = max(0.0, time.time() - last_activity_at) reason = "no_previous_conversation" will_start_new = True if force_new: reason = "force_new_enabled" elif threshold_value <= 0: reason = "threshold_disabled_reuse" elif not normalized_domain: reason = "missing_current_domain" elif not last_activity_at: reason = "no_previous_conversation" elif last_domain and normalized_domain != last_domain: reason = "domain_changed" elif normalized_preset and last_preset and normalized_preset != last_preset: reason = "preset_changed" elif elapsed_seconds is not None and elapsed_seconds < threshold_value: will_start_new = False reason = "reuse_existing" else: reason = "timeout_expired" return { "id": self.id, "persistent_index": self.persistent_index, "current_domain": normalized_domain, "current_preset_name": normalized_preset, "last_conversation_domain": last_domain or None, "last_conversation_preset_name": last_preset, "last_conversation_at": last_activity_at or None, "elapsed_seconds": round(elapsed_seconds, 1) if elapsed_seconds is not None else None, "threshold_seconds": threshold_value, "force_new_conversation": bool(force_new), "will_start_new_conversation": will_start_new, "reason": reason, } def should_start_new_conversation( self, current_domain: str = "", preset_name: str = "", threshold_seconds: float = 0.0, force_new: bool = False, ) -> bool: return bool( self.get_conversation_status( current_domain=current_domain, preset_name=preset_name, threshold_seconds=threshold_seconds, force_new=force_new, ).get("will_start_new_conversation", True) ) def get_info( self, *, use_cached_url: bool = False, allow_live_when_busy: bool = False, ) -> Dict: with self._lock: status = self.status last_used_at = self.last_used_at current_task_id = self.current_task_id command_request_id = str(getattr(self, "_command_request_id", "") or "").strip() current_command_id = str(getattr(self, "_current_command_id", "") or "").strip() current_command_name = str(self.current_command_name or "").strip() current_command = getattr(self, "_current_command", None) current_domain_snapshot = str(self.current_domain or "").strip() cached_url = str(self.last_known_url or "").strip() request_count = self.request_count preset_name = self.preset_name preset_override_source = self.preset_override_source model_name_override = self.model_name_override is_isolated_context = self.is_isolated_context browser_context_id = self.browser_context_id last_conversation_activity_at = self.last_conversation_activity_at last_conversation_domain = self.last_conversation_domain last_conversation_preset_name = self.last_conversation_preset_name command_loop = self._command_loop_info_unlocked() termination_in_progress = self._termination_in_progress busy_duration = None if status == TabStatus.BUSY: try: busy_duration = round(self.get_busy_timeout_info(now=time.time()).get("duration") or 0.0, 1) except Exception: busy_duration = round(time.time() - last_used_at, 1) if use_cached_url: current_url = cached_url if current_url: current_domain = self._refresh_current_domain(current_url) else: current_domain = current_domain_snapshot else: current_url = self._safe_get_url(allow_live_when_busy=allow_live_when_busy) current_domain = self._refresh_current_domain(current_url) url_route_token = encode_tab_url_route_token(current_url) if not current_command_name and isinstance(current_command, dict): current_command_name = str(current_command.get("name") or "").strip() return { "id": self.id, "persistent_index": self.persistent_index, "status": status.value, "current_task": current_task_id, "command_task": command_request_id, "current_command_id": current_command_id, "current_command": current_command_name, "current_domain": current_domain, "route_domain": get_preferred_route_domain(current_domain), "domain_url": self._build_domain_url(current_url, current_domain), "url": current_url, "url_route_token": url_route_token, "request_count": request_count, "busy_duration": busy_duration, "preset_name": preset_name, # 🆕 "preset_override_source": preset_override_source, "model_name_override": model_name_override, "is_isolated_context": is_isolated_context, "browser_context_id": browser_context_id, "last_conversation_at": last_conversation_activity_at or None, "last_conversation_domain": last_conversation_domain, "last_conversation_preset_name": last_conversation_preset_name, "command_loop": command_loop, "terminating": termination_in_progress, } def _refresh_current_domain(self, url: str = "") -> str: current_url = str(url or "").strip() try: resolved = extract_remote_site_domain(current_url) or "" except Exception: resolved = "" if resolved: with self._lock: self.current_domain = resolved return resolved with self._lock: fallback = str(self.current_domain or "").strip() if _should_skip_pool_url(current_url) or "://" in current_url: with self._lock: self.current_domain = None return "" return fallback @staticmethod def _build_domain_url(url: str, current_domain: str) -> str: source_url = str(url or "").strip() domain = str(current_domain or "").strip() if not source_url or not domain: return "" try: parsed = urlsplit(source_url) except Exception: return "" scheme = parsed.scheme if parsed.scheme in {"http", "https", "ws", "wss"} else "https" return f"{scheme}://{domain}/" def _remember_url(self, url: str) -> str: normalized = str(url or "").strip() with self._lock: if str(self.last_known_url or "").strip() != normalized: self._clear_health_cache_unlocked() if self.preset_override_source == "url": self.preset_name = None self.preset_override_source = None self.last_known_url = normalized or None return normalized def get_occupied_url(self) -> Optional[str]: with self._lock: return self._request_occupied_url def set_occupied_url(self, url: Optional[str]) -> None: with self._lock: normalized = str(url or "").strip() if normalized and "challenges.cloudflare.com" not in normalized and "challenge-platform" not in normalized and normalized.startswith("http"): self._request_occupied_url = normalized elif not normalized: self._request_occupied_url = None def _safe_get_url(self, allow_live_when_busy: bool = False) -> str: with self._lock: status = self.status cached_url = str(self.last_known_url or "").strip() if status == TabStatus.CLOSED: return "" if status == TabStatus.BUSY and not allow_live_when_busy: return cached_url try: current_url = self._remember_url(self.tab.url or "") if current_url: return current_url except Exception: pass return cached_url def clear_visibility_emulation(self, reason: str = "") -> None: try: from app.core.page_lifecycle import restore_visibility_emulation restore_visibility_emulation(self.tab, owner=self, reason=reason) except Exception as e: logger.debug(f"[{self.id}] visibility emulation cleanup failed: {e}") def notify_navigated(self, reason: str = "page_reload") -> None: """Notify command engine of page reload/navigation.""" try: from app.services.command_engine import command_engine if hasattr(command_engine, "notify_tab_navigated"): command_engine.notify_tab_navigated(self, reason=reason) except Exception as e: logger.debug(f"[{self.id}] notify_navigated failed (ignored): {e}")