openclaw-agent-dashboard 1.0.42 → 1.0.44

package/dashboard/api/timeline.py

@@ -86,12 +86,13 @@ async def get_timeline(
         record_error("unknown", str(e), "api:timeline:get", exc=e)
         raise HTTPException(status_code=500, detail=safe_api_error_detail(e)) from e
     elapsed_ms = (time.perf_counter() - t0) * 1000
-    if elapsed_ms >= 200.0:
+    steps_count = len(result.get("steps", []))
+    if elapsed_ms >= 100.0:
         LOG.info(
             "timeline agent=%s limit=%d steps=%d ms=%.1f",
             agent_id,
             limit,
-            len(result.get("steps", [])),
+            steps_count,
             elapsed_ms,
         )
 

package/dashboard/data/config_reader.py

@@ -152,22 +152,32 @@ def get_models_configured_by_agents() -> List[str]:
     """
     从配置中收集「各 Agent 实际配置使用」的模型 ID（仅 primary + fallbacks）。
     用于协作流程右侧模型面板：只显示有 Agent 配置的模型，不含白名单中未使用的。
+
+    策略：仅包含作为 primary 使用、或被某 agent 配置过的模型。
+    不包含 defaults.model.fallbacks 中没有任何 agent 当 primary 使用的模型。
     """
     agents = get_agents_list()
-    model_ids = set()
-    defaults = get_default_config()
-    default_model = defaults.get('model', {})
-    if default_model.get('primary'):
-        model_ids.add(default_model['primary'])
-    for fb in default_model.get('fallbacks') or []:
-        model_ids.add(fb)
+    # Step 1: 收集所有 primary 模型（用于判断 fallback 是否被实际使用）
+    primaries: List[str] = []
     for agent in agents:
         cfg = get_agent_models(agent.get('id', ''))
         if cfg.get('primary'):
-            model_ids.add(cfg['primary'])
+            primaries.append(cfg['primary'])
+    primary_set = set(primaries)
+
+    # Step 2: 收集所有 primary
+    model_ids: List[str] = list(dict.fromkeys(primaries))  # 保持顺序去重
+
+    # Step 3: 只添加被某 agent 实际配置过的 fallback（不被 primary_set 包含的不添加）
+    seen = set(primary_set)
+    for agent in agents:
+        cfg = get_agent_models(agent.get('id', ''))
         for fb in cfg.get('fallbacks', []):
-            model_ids.add(fb)
-    return sorted(model_ids)
+            if fb and fb not in seen:
+                model_ids.append(fb)
+                seen.add(fb)
+
+    return model_ids
 
 
 def get_all_models_from_agents() -> List[str]:
@@ -187,6 +197,23 @@ def get_all_models_from_agents() -> List[str]:
     return sorted(model_ids)
 
 
+def get_default_models_from_defaults() -> List[str]:
+    """
+    仅返回 agents.defaults.model.primary + fallbacks 中的模型。
+    用于协作流程右侧模型面板：当没有任何 Agent 实际配置某模型时，
+    不应因白名单而显示该模型（避免「配置未使用但显示在右侧」）。
+    """
+    defaults = get_default_config()
+    default_model = defaults.get('model', {})
+    result = []
+    if default_model.get('primary'):
+        result.append(default_model['primary'])
+    for fb in default_model.get('fallbacks') or []:
+        if fb not in result:
+            result.append(fb)
+    return result
+
+
 def get_model_display_name(model_id: str) -> str:
     """获取模型显示名。展示策略：使用 id 不用别名（与 OpenClaw 白名单逻辑一致）"""
     if not model_id:

package/dashboard/data/session_reader.py

@@ -269,9 +269,12 @@ def has_recent_errors(agent_id: str, minutes: int = 5) -> bool:
 
 
 def get_last_error(agent_id: str) -> Optional[Dict[str, Any]]:
-    """获取最近的错误信息"""
+    """
+    获取最近的错误信息，优先从 session stopReason=error 获取，
+    若无则从 runs.json 中最近结束的 error run 兜底。
+    """
     messages = get_recent_messages(agent_id, limit=100)
-    
+
     for msg in reversed(messages):
         if msg.get('stopReason') == 'error':
             return {
@@ -279,7 +282,39 @@ def get_last_error(agent_id: str) -> Optional[Dict[str, Any]]:
                 'message': msg.get('errorMessage', ''),
                 'timestamp': msg.get('timestamp', 0)
             }
-    
+
+    # 兜底：检查 runs.json 中最近结束的 error run
+    run_error = _get_last_run_error(agent_id)
+    if run_error:
+        return run_error
+
+    return None
+
+
+def _get_last_run_error(agent_id: str) -> Optional[Dict[str, Any]]:
+    """
+    从 runs.json 获取最近结束的 error run 的错误信息。
+    用于补充 session 中未落 stopReason=error 的 Gateway 中断等场景。
+    """
+    import time
+    from data.subagent_reader import get_agent_runs
+
+    runs = get_agent_runs(agent_id, limit=20)
+    cutoff = int(time.time() * 1000) - 5 * 60 * 1000
+    for run in runs:
+        ended = run.get('endedAt')
+        if not ended or ended < cutoff:
+            continue
+        outcome = run.get('outcome')
+        if not isinstance(outcome, dict) or outcome.get('status') != 'error':
+            continue
+        error_msg = outcome.get('error', '') or ''
+        return {
+            'type': detect_error_type(error_msg),
+            'message': error_msg,
+            'timestamp': ended,
+            'source': 'run'  # 标记来源，便于调试
+        }
     return None
 
 

package/dashboard/data/timeline_reader.py

@@ -15,6 +15,8 @@ LOG = logging.getLogger(__name__)
 LARGE_JSONL_BYTES = 512 * 1024
 TAIL_JSONL_BYTES = 2 * 1024 * 1024
 TAIL_JSONL_MAX_LINES = 4000
+# 主 Agent 头部安全行数（超大文件且步骤不足 limit 时补充读）
+_HEAD_JSONL_LINES = 2000
 
 
 class StepType(str, Enum):
@@ -115,9 +117,12 @@ def _read_session_header_timestamp(path: Path) -> Optional[int]:
     return None
 
 
-def _read_jsonl_tail_line_slice(path: Path) -> Optional[List[str]]:
+def _read_jsonl_tail_line_slice(path: Path, target_lines: int = 0) -> Optional[List[str]]:
     """
     大文件时返回尾部若干行（字节与行数双上限），否则返回 None 表示应整文件读取。
+
+    当 target_lines > 0 时：优先满足 target_lines（但最少读 TAIL_JSONL_MAX_LINES/2 行保证有足够数据），
+    上限为 TAIL_JSONL_MAX_LINES。当 target_lines = 0 时退化为原行为。
     """
     try:
         size = path.stat().st_size
@@ -125,6 +130,12 @@ def _read_jsonl_tail_line_slice(path: Path) -> Optional[List[str]]:
         return None
     if size <= LARGE_JSONL_BYTES:
         return None
+
+    # 目标行数转换为行数上限：多读一些（2x）以便有足够步骤，但不超过 TAIL_JSONL_MAX_LINES
+    max_lines = TAIL_JSONL_MAX_LINES
+    if target_lines > 0:
+        max_lines = min(max_lines, max(target_lines * 2, TAIL_JSONL_MAX_LINES // 2))
+
     with open(path, 'rb') as f:
         f.seek(max(0, size - TAIL_JSONL_BYTES))
         raw = f.read()
@@ -134,14 +145,40 @@ def _read_jsonl_tail_line_slice(path: Path) -> Optional[List[str]]:
         return []
     if size > TAIL_JSONL_BYTES:
         lines = lines[1:]
-    if len(lines) > TAIL_JSONL_MAX_LINES:
-        lines = lines[-TAIL_JSONL_MAX_LINES:]
+    if len(lines) > max_lines:
+        lines = lines[-max_lines:]
     return lines
 
 
-def _read_text_lines(path: Path) -> List[str]:
+def _read_text_lines(path: Path, max_lines: int = 0) -> List[str]:
+    """读取文件全部行，或当 max_lines > 0 时只读尾部 max_lines 行。"""
+    if max_lines <= 0:
+        with open(path, 'r', encoding='utf-8') as f:
+            return f.readlines()
+    # 只读尾部 max_lines 行（从头读，跳过后半部分）
     with open(path, 'r', encoding='utf-8') as f:
-        return f.readlines()
+        f.seek(0, 2)
+        file_size = f.tell()
+        if file_size <= 64 * 1024:
+            lines = f.read().splitlines()
+        else:
+            # 从文件末尾读取约 1MB 再提取最后 max_lines 行
+            chunk_size = min(1024 * 1024, file_size)
+            f.seek(max(0, file_size - chunk_size))
+            tail = f.read()
+            all_lines = tail.splitlines()
+            # 如果不够，继续向前读
+            lines = all_lines
+            lines_read = len(all_lines)
+            while lines_read < max_lines and file_size > chunk_size:
+                f.seek(max(0, file_size - chunk_size * 2))
+                more = f.read(chunk_size)
+                more_lines = more.splitlines()
+                lines = more_lines + lines
+                lines_read = len(lines)
+    if len(lines) > max_lines:
+        lines = lines[-max_lines:]
+    return lines
 
 
 # 子 Agent 回传消息的特征
@@ -629,22 +666,9 @@ def resolve_agent_session_jsonl(
         if isinstance(index_map.get(k), dict) and str(k).startswith(prefix)
     ]
 
-    # 1) 与当前子任务最一致：runs.json 中该 agent 最近一次 run 的 childSessionKey
-    runs = get_subagent_runs().get(state_id, [])
-    if runs:
-        runs.sort(key=lambda x: x.get('startedAt', 0), reverse=True)
-        preferred_key = runs[0].get('childSessionKey')
-        if preferred_key and preferred_key in index_map:
-            ent = index_map[preferred_key]
-            if isinstance(ent, dict):
-                p = resolve_session_jsonl_path(sessions_path, ent)
-                if p and p.is_file():
-                    sid = ent.get('sessionId') or preferred_key
-                    return p, sid, preferred_key
-
-    # 2) 按 sessions.json 的 updatedAt/lastMessageAt 选最近会话（在 glob mtime 之前）
-    #    OpenClaw 在任务结束后可能从 runs.json 移除 run，此处仍可定位「最近活跃」子会话 jsonl。
-    #    多文件时比仅凭 *.jsonl 的 mtime 更稳，且与 4/24 当晚最晚更新 session 一致。
+    # 直接按 sessions.json 的 updatedAt 选最新会话。
+    # runs.json 中的 run 即使已结束也仍保留在列表中，用它优先会错误选中旧 session；
+    # 而 updatedAt 由 OpenClaw 维护，能准确反映会话的实际最后活跃时间。
     if agent_keys:
         agent_keys.sort(
             key=lambda k: (index_map[k].get('updatedAt') or index_map[k].get('lastMessageAt') or 0),
@@ -1358,44 +1382,52 @@ def _parse_session_file(
             )
         elif file_size <= _SUBAGENT_READ_SAFETY_BYTES:
             steps, started_at, session_status = _parse_session_lines(
-                _read_text_lines(path), requester_info, started_at_hint=header_ts
+                _read_text_lines(path, limit * 3), requester_info, started_at_hint=header_ts
             )
             if subagent_anchor_ms is None:
                 steps = _slice_subagent_steps_from_first_user(steps)
         elif subagent_anchor_ms is not None:
             # 超大 + 有 run：以尾部为窗口（近期）再交给 get_timeline 的 _apply 锚定
-            tail_lines = _read_jsonl_tail_line_slice(path)
+            tail_lines = _read_jsonl_tail_line_slice(path, target_lines=limit)
             if tail_lines is not None:
                 steps, started_at, session_status = _parse_session_lines(
                     tail_lines, requester_info, started_at_hint=header_ts
                 )
             else:
                 steps, started_at, session_status = _parse_session_lines(
-                    _read_text_line_window(path, 0, _MAX_LINES_AFTER_TASK_START),
+                    _read_text_line_window(path, 0, limit * 3),
                     requester_info, started_at_hint=header_ts
                 )
         else:
             # 超大 + 无 run：先定位首条 user 行，自 PM/主控下发起读有限行
             uidx = _line_index_of_first_user_message(path)
             start = uidx if uidx is not None else 0
-            part = _read_text_line_window(path, start, _MAX_LINES_AFTER_TASK_START)
+            part = _read_text_line_window(path, start, limit * 3)
             steps, started_at, session_status = _parse_session_lines(
                 part, requester_info, started_at_hint=header_ts
             )
             steps = _slice_subagent_steps_from_first_user(steps)
     else:
-        tail_lines = _read_jsonl_tail_line_slice(path)
+        tail_lines = _read_jsonl_tail_line_slice(path, target_lines=limit)
         if tail_lines is not None:
             steps, started_at, session_status = _parse_session_lines(
                 tail_lines, requester_info, started_at_hint=header_ts
             )
             if len(steps) < limit:
-                steps, started_at, session_status = _parse_session_lines(
-                    _read_text_lines(path), requester_info, started_at_hint=header_ts
-                )
+                # 尾部步骤不够，从头部补充（最多读 limit 步对应的行数缓冲）
+                head_lines = _read_text_lines(path, _HEAD_JSONL_LINES)
+                if head_lines:
+                    more_steps, _, _ = _parse_session_lines(
+                        head_lines, requester_info, started_at_hint=header_ts
+                    )
+                    # 合并并重新截取最新的 limit 步
+                    combined = more_steps + steps
+                    if len(combined) > limit:
+                        combined = combined[-limit:]
+                    steps, started_at, session_status = combined, started_at, session_status
         else:
             steps, started_at, session_status = _parse_session_lines(
-                _read_text_lines(path), requester_info, started_at_hint=header_ts
+                _read_text_lines(path, limit * 3), requester_info, started_at_hint=header_ts
             )
 
     if len(steps) > step_budget:

package/dashboard/status/status_calculator.py

@@ -30,6 +30,28 @@ MAIN_AGENT_SOLO_STREAM_GRACE_SEC = 20
 
 AgentStatus = Literal['idle', 'working', 'down']
 
+# 最近多久内的 error run 应视为 down 状态（分钟）
+_RECENT_ERROR_RUN_WINDOW_MINUTES = 5
+
+
+def _has_recent_error_run(agent_id: str, minutes: int = _RECENT_ERROR_RUN_WINDOW_MINUTES) -> bool:
+    """
+    检查 runs.json 中是否有最近结束且 outcome.status == 'error' 的 run。
+    用于补充 session stopReason=error：Gateway 重启等原因导致的 run 中断
+    会写入 runs.json 但不一定会话落 stopReason=error。
+    """
+    import time
+    runs = get_agent_runs(agent_id, limit=20)
+    cutoff = int(time.time() * 1000) - minutes * 60 * 1000
+    for run in runs:
+        ended = run.get('endedAt')
+        if not ended or ended < cutoff:
+            continue
+        outcome = run.get('outcome')
+        if isinstance(outcome, dict) and outcome.get('status') == 'error':
+            return True
+    return False
+
 
 def _main_agent_solo_processing(agent_id: str) -> bool:
     """
@@ -58,16 +80,16 @@ def _main_agent_solo_processing(agent_id: str) -> bool:
 def calculate_agent_status(agent_id: str, use_cache: bool = True) -> AgentStatus:
     """
     计算 Agent 状态（基于 runs.json + sessions.json）
-    
+
     优先级:
-    1. 异常 (down) - 最近5分钟有 stopReason=error
+    1. 异常 (down) - 最近5分钟有 stopReason=error，或有最近结束的 error run
     2. 工作中 (working) - 有活跃 subagent run；或主 Agent 且无 run 时 thinking / 未完成工具 / 短窗内会话写入
     3. 空闲 (idle) - 其余情况（子 Agent 无 run 即空闲，与协作图 activePath 一致）
-    
+
     Args:
         agent_id: Agent ID
         use_cache: 是否使用缓存（默认 True）
-    
+
     Returns:
         Agent 状态
     """
@@ -82,6 +104,8 @@ def calculate_agent_status(agent_id: str, use_cache: bool = True) -> AgentStatus
         # 重新计算
         if has_recent_errors(agent_id, minutes=5):
             status = 'down'
+        elif _has_recent_error_run(agent_id, minutes=5):
+            status = 'down'
         elif is_agent_working(agent_id):
             status = 'working'
         elif _main_agent_solo_processing(agent_id):
@@ -124,7 +148,8 @@ def get_agents_with_status() -> list:
         try:
             status = calculate_agent_status(agent_id)
             current_task = get_current_task(agent_id)
-            if status == 'idle':
+            # idle 且无已结束 run 任务时才清空 currentTask
+            if status == 'idle' and not current_task:
                 current_task = ''
             last_active = get_last_active_time(agent_id)
             last_error = get_last_error(agent_id) if status == 'down' else None
@@ -155,16 +180,32 @@ def get_agents_with_status() -> list:
 def get_current_task(agent_id: str) -> str:
     """
     获取 Agent 当前任务描述。
-    仅从未结束的 run（endedAt 为空）读取；已结束的 run 只代表历史，不应在空闲时仍当「当前任务」展示。
+
+    优先级：
+    1. 活跃 run（endedAt 为空）—— 代表正在执行的任务
+    2. 最近结束的 run——即使已结束也要展示（run 失败中断后仍需可见）
     """
     runs = get_agent_runs(agent_id, limit=40)
+
+    # 优先级1：未结束的 run
+    for run in runs:
+        if run.get('endedAt') is None:
+            task = run.get('task', '') or ''
+            if len(task) > 60:
+                task = task[:57] + '...'
+            return task
+
+    # 优先级2：最近的已结束 run（确保失败中断的任务也能在 Dashboard 上看到）
     for run in runs:
         if run.get('endedAt') is not None:
-            continue
-        task = run.get('task', '') or ''
-        if len(task) > 60:
-            task = task[:57] + '...'
-        return task
+            task = run.get('task', '') or ''
+            if task:
+                outcome = run.get('outcome', {})
+                status = outcome.get('status') if isinstance(outcome, dict) else None
+                prefix = '[失败] ' if status == 'error' else '[已结束] '
+                if len(task) > 57:
+                    task = task[:57] + '...'
+                return prefix + task
 
     return ''