支持总时间和单步时间设置；追赶调度，排除渲染时间带来的误差；日志改进

backend/access_log.py

@@ -174,13 +174,14 @@ def log_openai_completions_request(
         _request_counter += 1
         request_id = _request_counter
 
-    preview = 50
+    preview = 100
     p_preview = prompt[:preview] + "..." if len(prompt) > preview else prompt
     details = (
         f"req_id={request_id}, model='{model}', "
         f"prompt='{p_preview}', chars={len(prompt)}"
     )
     _log_request("📥 openai completions 请求", details, client_ip)
+    _hit_api("chat")
     return request_id
 
 
@@ -202,18 +203,15 @@ def log_prediction_attribute_request(
         _request_counter += 1
         request_id = _request_counter
 
-    preview = 50
-    c_preview = context[:preview] + "..." if len(context) > preview else context
-    if target_prediction is None:
-        t_preview = "<top-1>"
-    else:
-        t_preview = (
-            target_prediction[:preview] + "..."
-            if len(target_prediction) > preview
-            else target_prediction
-        )
+    context_preview = 150
+    c_preview = (
+        context[:context_preview] + "..."
+        if len(context) > context_preview
+        else context
+    )
+    target_show = "<top-1>" if target_prediction is None else target_prediction
     details = (
-        f"req_id={request_id}, model={model!r}, context='{c_preview}', target='{t_preview}', "
+        f"req_id={request_id}, model={model!r}, context='{c_preview}', target='{target_show}', "
         f"context_chars={len(context)}"
     )
     _log_request("📥 prediction_attribute 请求", details, client_ip)

backend/api/prediction_attribute.py

@@ -71,9 +71,10 @@ def prediction_attribute(attribution_request):
 
     elapsed = time.perf_counter() - start_time
     tokens = len(result.get("token_attribution", []))
+    target_token = result.get("target_token")
     print(
         f"\t📤 API prediction_attribute response: req_id={request_id}, "
-        f"tokens={tokens}, response_time={elapsed:.4f}s"
+        f"target={target_token!r}, tokens={tokens}, response_time={elapsed:.4f}s"
     )
 
     return {"success": True, **result}, 200

backend/completion_generator.py

@@ -78,9 +78,7 @@ def _completion_without_generate(
 
 def _print_completion_stream_delta(text: str, stream_end: bool) -> None:
     """接收 TextStreamer 切分好的增量片段，由本模块打印（与默认 TextStreamer 输出一致）。"""
-    # 仅在verbose时打印
-    if get_verbose():
-        print(text, flush=True, end="" if not stream_end else None)
+    print(text, flush=True, end="" if not stream_end else None)
 
 
 def _compose_stream_delta(
@@ -429,12 +427,12 @@ def core_generate_from_text(
         effective_max_new = remaining
     else:
         effective_max_new = min(max_tokens, remaining)
-    if get_verbose():
-        print(
-            f"📌 completion: 推理原文 (tokens={input_len}, ctx_limit={ctx_limit}, max_new={effective_max_new}):\n"
-            f"{formatted_text}",
-            end="", # 不换行, 用于和后续打印推理结果拼在一起
-        )
+
+    print(
+        f"📌 completion: 推理原文 (tokens={input_len}, ctx_limit={ctx_limit}, max_new={effective_max_new}):\n"
+        f"{formatted_text}",
+        end="", # 不换行, 用于和后续打印推理结果拼在一起
+    )
 
     prompt_tokens = int(input_len)
     # 主要防止：排队等推理锁期间用户已取消，拿到锁后在此短路，避免无意义进入 generate。

backend/visit_stats.py

@@ -63,12 +63,13 @@ def print_visit_summary():
                 os_cnt[o] += 1
     os_order = ("ios", "android", "windows", "macos", "linux", "unknown")
     os_pg = [f"  {k}: {os_cnt[k]}" for k in os_order if os_cnt[k]]
+    now = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
 
-    body = ["========== [访问统计] ==========",
+    body = [f"========== [访问统计] {now} ==========",
             f"进程约 {h:.2f}h | 页面访问IP:{n_ip} | 真实活跃IP:{n_act}", "--- 活跃IP中OS统计 ---",
             *(os_pg or ["  （尚无）"]), "--- 页面活跃时间统计(秒) ---",
-            *(pg or ["  （尚无）"]), "--- 分析API调用统计 ---",
-            *[f"  {k}: {apis.get(k, 0)}" for k in ("analyze", "analyze_semantic", "prediction_attribute")],
+            *(pg or ["  （尚无）"]), "--- API调用统计 ---",
+            *[f"  {k}: {apis.get(k, 0)}" for k in ("analyze", "analyze_semantic", "prediction_attribute", "chat")],
             "=" * 42]
     print("\n".join(body), flush=True)
 

client/src/css/gen_attribute.scss

@@ -345,6 +345,29 @@
   text-align: right;
 }
 
+.gen-attr-dag-replay-speed-row {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 6px 10px;
+}
+
+select.gen-attr-dag-replay-mode-select {
+  width: auto;
+  min-width: 7.5rem;
+  text-align: left;
+}
+
+.gen-attr-dag-replay-value-wrap {
+  align-items: center;
+  gap: 4px;
+
+  // 仅非 hidden 时设 flex，否则会覆盖浏览器对 [hidden] 的 display:none（两列输入会同时出现）
+  &:not([hidden]) {
+    display: inline-flex;
+  }
+}
+
 .attribution-exclude-prompt-patterns-input {
   width: 100%;
   box-sizing: border-box;

client/src/gen_attribute.html

@@ -211,13 +211,28 @@
                         </span>
                     </div>
                     <div class="gen-attr-dag-measure-width-row semantic-submode-row">
-                        <span class="semantic-submode-group">
-                            <label class="semantic-submode-label" for="gen_attr_dag_playback_step_ms">DAG play step</label>
-                            <input type="number" id="gen_attr_dag_playback_step_ms" class="gen-attr-dag-measure-width-input"
-                                value="200" min="0" max="10000" step="10"
-                                title="Delay in milliseconds between steps during DAG playback. Stored locally; the value is read when you press play—changing it mid-playback does not affect the current run."
+                        <span class="semantic-submode-group gen-attr-dag-replay-speed-row">
+                            <label class="semantic-submode-label" for="gen_attr_dag_replay_mode" data-i18n>DAG replay speed</label>
+                            <select id="gen_attr_dag_replay_mode" class="gen-attr-dag-replay-mode-select gen-attr-dag-measure-width-input"
+                                title="Total duration vs. fixed delay per step. Waits shrink if a step is slow; long idle realigns the beat."
                                 data-i18n="title">
-                            <span class="semantic-submode-label">ms</span>
+                                <option value="total" data-i18n>Total time</option>
+                                <option value="step" data-i18n>Step time</option>
+                            </select>
+                            <span id="gen_attr_dag_replay_total_wrap" class="gen-attr-dag-replay-value-wrap">
+                                <input type="number" id="gen_attr_dag_playback_total_s" class="gen-attr-dag-measure-width-input"
+                                    value="7" min="1" max="3600" step="1"
+                                    title="Nominal delay = total seconds ÷ (steps − 1). Saved locally; applied when you press play."
+                                    data-i18n="title">
+                                <span class="semantic-submode-label">s</span>
+                            </span>
+                            <span id="gen_attr_dag_replay_step_wrap" class="gen-attr-dag-replay-value-wrap" hidden>
+                                <input type="number" id="gen_attr_dag_playback_step_ms" class="gen-attr-dag-measure-width-input"
+                                    value="200" min="0" max="10000" step="10"
+                                    title="Nominal ms between steps. Saved locally; applied when you press play (not mid-run)."
+                                    data-i18n="title">
+                                <span class="semantic-submode-label">ms</span>
+                            </span>
                         </span>
                     </div>
                 </section>

client/src/ts/gen_attribute.ts

@@ -78,8 +78,13 @@ const GEN_ATTR_MAX_TOKENS_STORAGE_KEY = 'info_radar_gen_attr_max_tokens';
 const GEN_ATTR_MAX_TOKENS_DEFAULT = 100;
 const GEN_ATTR_DAG_MEASURE_WIDTH_STORAGE_KEY = 'info_radar_gen_attr_dag_measure_width';
 const GEN_ATTR_DAG_PLAYBACK_STEP_MS_STORAGE_KEY = 'info_radar_gen_attr_dag_playback_step_ms';
+const GEN_ATTR_DAG_REPLAY_PACING_MODE_STORAGE_KEY = 'info_radar_gen_attr_dag_replay_pacing_mode';
+const GEN_ATTR_DAG_PLAYBACK_TOTAL_S_STORAGE_KEY = 'info_radar_gen_attr_dag_playback_total_s';
 const GEN_ATTR_DAG_HIDE_INACTIVE_EDGES_STORAGE_KEY = 'info_radar_gen_attr_dag_hide_inactive_edges';
 
+/** 步进回放节奏：`total`＝整段剩余回放总时长内均分间隔；`step`＝固定每步间隔（ms）。 */
+type DagReplayPacingMode = 'total' | 'step';
+
 const GEN_ATTR_DAG_MEASURE_WIDTH_DEFAULT = 500;
 const GEN_ATTR_DAG_MEASURE_WIDTH_MIN = 200;
 const GEN_ATTR_DAG_MEASURE_WIDTH_MAX = 4000;
@@ -88,6 +93,10 @@ const GEN_ATTR_DAG_PLAYBACK_STEP_MS_DEFAULT = 200;
 const GEN_ATTR_DAG_PLAYBACK_STEP_MS_MIN = 0;
 const GEN_ATTR_DAG_PLAYBACK_STEP_MS_MAX = 10000;
 
+const GEN_ATTR_DAG_PLAYBACK_TOTAL_S_DEFAULT = 7;
+const GEN_ATTR_DAG_PLAYBACK_TOTAL_S_MIN = 1;
+const GEN_ATTR_DAG_PLAYBACK_TOTAL_S_MAX = 3600;
+
 const GENERATE_BTN_LABEL = 'Start';
 const STOP_BTN_LABEL = 'Stop';
 
@@ -148,6 +157,34 @@ function readStoredDagPlaybackStepMs(): number {
     return GEN_ATTR_DAG_PLAYBACK_STEP_MS_DEFAULT;
 }
 
+function clampDagPlaybackTotalS(n: number): number {
+    return Math.max(
+        GEN_ATTR_DAG_PLAYBACK_TOTAL_S_MIN,
+        Math.min(GEN_ATTR_DAG_PLAYBACK_TOTAL_S_MAX, Math.round(n))
+    );
+}
+
+function readStoredDagPlaybackTotalS(): number {
+    try {
+        const v = localStorage.getItem(GEN_ATTR_DAG_PLAYBACK_TOTAL_S_STORAGE_KEY);
+        const n = v !== null ? parseInt(v, 10) : NaN;
+        if (Number.isFinite(n)) return clampDagPlaybackTotalS(n);
+    } catch {
+        // ignore
+    }
+    return GEN_ATTR_DAG_PLAYBACK_TOTAL_S_DEFAULT;
+}
+
+function readStoredDagReplayPacingMode(): DagReplayPacingMode {
+    try {
+        const v = localStorage.getItem(GEN_ATTR_DAG_REPLAY_PACING_MODE_STORAGE_KEY);
+        if (v === 'total' || v === 'step') return v;
+    } catch {
+        // ignore
+    }
+    return 'total';
+}
+
 const apiPrefix = URLHandler.parameters['api'] || '';
 const bodyElement = d3.select('body').node() as Element;
 const { totalSurprisalFormat, api } = initializeCommonApp(apiPrefix, bodyElement);
@@ -203,9 +240,31 @@ const maxTokensInput = document.getElementById('gen_attr_max_tokens') as HTMLInp
 const dagMeasureWidthInput = document.getElementById(
     'gen_attr_dag_measure_width'
 ) as HTMLInputElement | null;
+/** 步进回放：固定间隔（ms）或总时长（s），由 {@link DagReplayPacingMode} 选择。 */
 const dagPlaybackStepMsInput = document.getElementById(
     'gen_attr_dag_playback_step_ms'
 ) as HTMLInputElement | null;
+const dagReplayModeSelect = document.getElementById(
+    'gen_attr_dag_replay_mode'
+) as HTMLSelectElement | null;
+const dagPlaybackTotalSInput = document.getElementById(
+    'gen_attr_dag_playback_total_s'
+) as HTMLInputElement | null;
+const dagReplayTotalWrap = document.getElementById('gen_attr_dag_replay_total_wrap');
+const dagReplayStepWrap = document.getElementById('gen_attr_dag_replay_step_wrap');
+
+/** 与 `#gen_attr_dag_replay_mode` 同步；非法或缺失时视为 `total`。 */
+function currentDagReplayPacingMode(): DagReplayPacingMode {
+    return dagReplayModeSelect?.value === 'step' ? 'step' : 'total';
+}
+
+/** 切换下拉时更新 `hidden`；样式见 `.gen-attr-dag-replay-value-wrap:not([hidden])`。 */
+function applyDagReplaySpeedUi(): void {
+    const mode = currentDagReplayPacingMode();
+    if (dagReplayTotalWrap) dagReplayTotalWrap.hidden = mode !== 'total';
+    if (dagReplayStepWrap) dagReplayStepWrap.hidden = mode !== 'step';
+}
+
 const dagHideInactiveEdgesInput = document.getElementById(
     'gen_attr_dag_hide_inactive_edges'
 ) as HTMLInputElement | null;
@@ -215,8 +274,15 @@ if (modelVariantSelect) modelVariantSelect.value = readStoredModelVariant();
 if (maxTokensInput) maxTokensInput.value = String(readStoredMaxTokens());
 const initialDagMeasureWidth = readStoredDagMeasureWidth();
 if (dagMeasureWidthInput) dagMeasureWidthInput.value = String(initialDagMeasureWidth);
+
+// DAG 回放节奏：步长 / 总时长 / 模式下拉 — 自 localStorage 恢复后再同步展示哪块输入
 const initialDagPlaybackStepMs = readStoredDagPlaybackStepMs();
 if (dagPlaybackStepMsInput) dagPlaybackStepMsInput.value = String(initialDagPlaybackStepMs);
+const initialDagReplayPacingMode = readStoredDagReplayPacingMode();
+if (dagReplayModeSelect) dagReplayModeSelect.value = initialDagReplayPacingMode;
+const initialDagPlaybackTotalS = readStoredDagPlaybackTotalS();
+if (dagPlaybackTotalSInput) dagPlaybackTotalSInput.value = String(initialDagPlaybackTotalS);
+applyDagReplaySpeedUi();
 
 const genAttrResultsNode = genAttrResultsEl.node() as HTMLElement | null;
 function applyDagHideInactiveEdges(hide: boolean): void {
@@ -265,6 +331,7 @@ maxTokensInput?.addEventListener('change', () => {
     syncSubmitButtonState();
 });
 
+// DAG 回放节奏（与上节「DAG 测量宽度」无关；宽度 listener 在后文）
 dagPlaybackStepMsInput?.addEventListener('change', () => {
     const raw = parseInt(dagPlaybackStepMsInput.value, 10);
     const ms = Number.isFinite(raw)
@@ -278,6 +345,29 @@ dagPlaybackStepMsInput?.addEventListener('change', () => {
     }
 });
 
+dagReplayModeSelect?.addEventListener('change', () => {
+    const mode = currentDagReplayPacingMode();
+    try {
+        localStorage.setItem(GEN_ATTR_DAG_REPLAY_PACING_MODE_STORAGE_KEY, mode);
+    } catch {
+        /* ignore */
+    }
+    applyDagReplaySpeedUi();
+});
+
+dagPlaybackTotalSInput?.addEventListener('change', () => {
+    const raw = parseInt(dagPlaybackTotalSInput.value, 10);
+    const s = Number.isFinite(raw)
+        ? clampDagPlaybackTotalS(raw)
+        : GEN_ATTR_DAG_PLAYBACK_TOTAL_S_DEFAULT;
+    dagPlaybackTotalSInput.value = String(s);
+    try {
+        localStorage.setItem(GEN_ATTR_DAG_PLAYBACK_TOTAL_S_STORAGE_KEY, String(s));
+    } catch {
+        /* ignore */
+    }
+});
+
 function isSkipChatTemplate(): boolean {
     return skipChatTemplateInput?.checked ?? false;
 }
@@ -419,14 +509,30 @@ function scheduleDagLastTokenDwell(action: () => void, dwellMs: number = DAG_LAS
     }, dwellMs);
 }
 
-/** 仅在点击播放时调用：读当前输入、写回规范化值，返回本轮重放使用的步进间隔。 */
-function sampleDagPlaybackStepMsOnPlay(): number {
-    const raw = parseInt(dagPlaybackStepMsInput?.value ?? '', 10);
-    const ms = Number.isFinite(raw)
-        ? clampDagPlaybackStepMs(raw)
-        : readStoredDagPlaybackStepMs();
-    if (dagPlaybackStepMsInput) dagPlaybackStepMsInput.value = String(ms);
-    return ms;
+/**
+ * 点击播放时：读界面值并写回规范化结果，得到本轮「相邻两步 DAG 更新」之间的延时（ms）。
+ * - `step`：固定间隔。
+ * - `total`：`totalS` 按**整段 DAG 步数**均分间隔，与「从头回放」相同（`fullStepCount - 1` 段）；不管当前 `dagPlaybackNextIndex`。首步立即执行，与末 token dwell 无关。
+ */
+function resolveDagPlaybackStepDelayMsOnPlay(fullStepCount: number): number {
+    if (currentDagReplayPacingMode() === 'step') {
+        const raw = parseInt(dagPlaybackStepMsInput?.value ?? '', 10);
+        const ms = Number.isFinite(raw)
+            ? clampDagPlaybackStepMs(raw)
+            : readStoredDagPlaybackStepMs();
+        if (dagPlaybackStepMsInput) dagPlaybackStepMsInput.value = String(ms);
+        return ms;
+    }
+
+    const rawS = parseInt(dagPlaybackTotalSInput?.value ?? '', 10);
+    const totalS = Number.isFinite(rawS)
+        ? clampDagPlaybackTotalS(rawS)
+        : readStoredDagPlaybackTotalS();
+    if (dagPlaybackTotalSInput) dagPlaybackTotalSInput.value = String(totalS);
+
+    const transitionCount = Math.max(0, fullStepCount - 1);
+    if (transitionCount <= 0) return 0;
+    return Math.round((totalS * 1000) / transitionCount);
 }
 
 function stopDagPlayback(): void {
@@ -456,9 +562,12 @@ function handleDagPlaybackToggle(wantPlay: boolean): void {
         dagHandle.reset(true);
         dagPlaybackNextIndex = 0;
     }
-    const playbackStepMs = sampleDagPlaybackStepMsOnPlay();
+    const stepDelayMs = resolveDagPlaybackStepDelayMsOnPlay(steps.length);
     dagHandle.setDagPlaybackPlaying(true);
 
+    /** 相邻两步「理想触发」之间的名义间隔；与 {@link resolveDagPlaybackStepDelayMsOnPlay} 一致。 */
+    let nextDue = performance.now();
+
     const isStalePlaybackHandle = (): boolean => {
         if (runnerHandle === h) return false;
         dagPlaybackTimer = null;
@@ -473,12 +582,22 @@ function handleDagPlaybackToggle(wantPlay: boolean): void {
         dagHandle.setDagPlaybackPlaying(false);
     };
 
-    const afterPlaybackDelay = (fn: () => void): void => {
+    /**
+     * 步间节拍：理想时刻 `nextDue` 每次前进 `stepDelayMs`，实际等待 `max(0, nextDue - now)`。
+     * 若已迟到（`delay === 0`），则 `nextDue = now + stepDelayMs` 重锚，避免长时间暂停 / 后台节流后连发多步。
+     */
+    const scheduleNextPlaybackTick = (): void => {
+        const now = performance.now();
+        nextDue += stepDelayMs;
+        let delay = Math.max(0, nextDue - now);
+        if (delay === 0) {
+            nextDue = now + stepDelayMs;
+        }
         dagPlaybackTimer = setTimeout(() => {
             dagPlaybackTimer = null;
             if (isStalePlaybackHandle()) return;
-            fn();
-        }, playbackStepMs);
+            tick();
+        }, delay);
     };
 
     const tick = (): void => {
@@ -503,7 +622,7 @@ function handleDagPlaybackToggle(wantPlay: boolean): void {
             });
             return;
         }
-        afterPlaybackDelay(tick);
+        scheduleNextPlaybackTick();
     };
     tick();
 }