prediction attribute 统计和log改进. history下拉高度改进；某些demo从14b模型改为1.7b模型，更符合直觉

backend/access_log.py

@@ -213,6 +213,9 @@ def log_prediction_attribute_request(
     target_prediction: Optional[str],
     target_token_id: Optional[int],
     model: str,
+    source_page: str,
+    flow_id: Optional[str] = None,
+    flow_step: Optional[int] = None,
     client_ip: str = None,
 ) -> int:
     """
@@ -227,19 +230,30 @@ def log_prediction_attribute_request(
         _request_counter += 1
         request_id = _request_counter
 
-    context_preview = 150
+    context_preview = 200
     c_preview = _log_str_preview(context, context_preview)
     if target_token_id is not None:
         target_show = f"<token_id:{target_token_id}>"
     else:
         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='{target_show}', "
-        f"context_chars={len(context)}"
+        f"req_id={request_id}, model={model!r}, source_page={source_page!r}, "
+        f"context='{c_preview}', target='{target_show}', context_chars={len(context)}"
     )
-    _log_request("📥 prediction_attribute 请求", details, client_ip)
-
-    _hit_api("prediction_attribute")
+    if flow_id is not None:
+        details += f", flow_id={flow_id!r}, flow_step={flow_step}"
+
+    # 连续 flow 第 1 步后不再打印入站请求，避免日志噪声。
+    if flow_id is None or flow_step == 0:
+        _log_request("📥 prediction_attribute 请求", details, client_ip)
+
+    is_flow_request = source_page == "gen_attribute.html"
+    if is_flow_request:
+        if flow_step == 0:
+            _hit_api("causal_flow")
+        _hit_api("prediction_attribute")
+    else:
+        _hit_api(f"prediction_attribute__{source_page}")
     return request_id
 
 

backend/api/prediction_attribute.py

@@ -26,6 +26,9 @@ def prediction_attribute(attribution_request):
     target_prediction = attribution_request.get("target_prediction")
     target_token_id = attribution_request.get("target_token_id")
     model = attribution_request.get("model")
+    source_page = attribution_request.get("source_page")
+    flow_id = attribution_request.get("flow_id")
+    flow_step = attribution_request.get("flow_step")
 
     if context is None:
         return {"success": False, "message": "Missing required field: context"}, 400
@@ -52,6 +55,46 @@ def prediction_attribute(attribution_request):
     if model not in ("base", "instruct"):
         return {"success": False, "message": 'model must be "base" or "instruct"'}, 400
 
+    allowed_source_pages = {
+        "analysis.html",
+        "chat.html",
+        "attribution.html",
+        "gen_attribute.html",
+    }
+
+    if source_page is None:
+        return {"success": False, "message": "Missing required field: source_page"}, 400
+    if not isinstance(source_page, str):
+        return {"success": False, "message": "source_page must be a string"}, 400
+    if source_page == "":
+        return {"success": False, "message": "source_page must not be empty"}, 400
+    if source_page not in allowed_source_pages:
+        return {
+            "success": False,
+            "message": "source_page must be one of: analysis.html, chat.html, attribution.html, gen_attribute.html",
+        }, 400
+
+    if flow_id is not None and not isinstance(flow_id, str):
+        return {"success": False, "message": "flow_id must be a string"}, 400
+    if flow_id == "":
+        return {"success": False, "message": "flow_id must not be empty"}, 400
+    if flow_step is not None and not isinstance(flow_step, int):
+        return {"success": False, "message": "flow_step must be an integer"}, 400
+    if flow_step is not None and flow_step < 0:
+        return {"success": False, "message": "flow_step must be >= 0"}, 400
+
+    is_causal_flow = source_page == "gen_attribute.html"
+    if is_causal_flow:
+        if flow_id is None:
+            return {"success": False, "message": "Missing required field: flow_id for causal flow"}, 400
+        if flow_step is None:
+            return {"success": False, "message": "Missing required field: flow_step for causal flow"}, 400
+    elif flow_id is not None or flow_step is not None:
+        return {
+            "success": False,
+            "message": "flow_id/flow_step are only allowed when source_page is gen_attribute.html",
+        }, 400
+
     client_ip = get_client_ip()
     start_time = time.perf_counter()
     request_id = log_prediction_attribute_request(
@@ -59,6 +102,9 @@ def prediction_attribute(attribution_request):
         target_prediction=target_prediction,
         target_token_id=target_token_id,
         model=model,
+        source_page=source_page,
+        flow_id=flow_id,
+        flow_step=flow_step,
         client_ip=client_ip,
     )
 
@@ -93,9 +139,16 @@ 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"target={target_token!r}, tokens={tokens}, response_time={elapsed:.4f}s"
-    )
+    if flow_id is None:
+        print(
+            f"\t📤 API prediction_attribute response: req_id={request_id}, "
+            f"target={target_token!r}, tokens={tokens}, response_time={elapsed:.4f}s"
+        )
+    else:
+        print(
+            f"\t📤 API prediction_attribute response: req_id={request_id}, "
+            f"flow_id={flow_id!r}, flow_step={flow_step}, "
+            f"target={target_token!r}, tokens={tokens}, response_time={elapsed:.4f}s"
+        )
 
     return {"success": True, **result}, 200

client/src/css/attribution.scss

@@ -14,11 +14,9 @@
   }
 }
 
-// Cached history 下拉：覆盖全局 query-history（mixin 含 max-height:200px，须显式 max-height:none 才取消上限）；原生竖向 resize
+// Cached history 下拉：覆盖 mixin 的 max-height:200px；高度随条目、封顶 min(32vh,360px)，并可竖向 resize
 #attribution_cached_history_dropdown.semantic-search-history-dropdown {
-  height: min(32vh, 360px);
-  min-height: 120px;
-  max-height: none;
+  max-height: min(32vh, 360px);
   resize: vertical;
   overflow-y: auto;
 }

client/src/css/gen_attribute.scss

@@ -32,11 +32,10 @@
   position: static;
 }
 
+// Cached history / demos：随内容变高，封顶 min(32vh, 360px)，竖向 resize；覆盖 chat mixin 的 max-height:200px
 #gen_attr_cached_history_dropdown.semantic-search-history-dropdown,
 #gen_attr_cached_demos_dropdown.semantic-search-history-dropdown {
-  height: min(32vh, 360px);
-  min-height: 120px;
-  max-height: none;
+  max-height: min(32vh, 360px);
   resize: vertical;
   overflow-y: auto;
 }

client/src/ts/attribution.ts

@@ -272,6 +272,7 @@ async function runAnalyze(options?: { forceRefresh?: boolean }): Promise<void> {
             context,
             targetPrediction: target,
             model: currentAttributionModelVariant(),
+            sourcePage: 'attribution.html',
             forceRefresh,
         });
         applyAttributionResponse(context, json);

client/src/ts/attribution/densityAttributionSidebar.ts

@@ -72,6 +72,7 @@ export type DensityAttributionSidebarOptions = {
     getContextPrefix?: () => string;
     /** 首页 base；Chat instruct */
     predictionModelVariant: PredictionAttributeModelVariant;
+    sourcePage: 'analysis.html' | 'chat.html';
 };
 
 /**
@@ -299,6 +300,7 @@ export function initDensityAttributionSidebar(options: DensityAttributionSidebar
                             context,
                             targetPrediction: selectedTarget,
                             model: options.predictionModelVariant,
+                            sourcePage: options.sourcePage,
                             forceRefresh: false,
                         });
                         finish(json);

client/src/ts/attribution/predictionAttributeClient.ts

@@ -12,21 +12,35 @@ import {
 } from './attributionResultCache';
 
 const JSON_ERROR_SNIPPET_MAX = 160;
+export type PredictionAttributeSourcePage =
+    | 'analysis.html'
+    | 'chat.html'
+    | 'attribution.html'
+    | 'gen_attribute.html';
 
 export async function fetchPredictionAttribute(
     apiBaseForRequests: string,
     context: string,
     targetPrediction: string | null,
     model: PredictionAttributeModelVariant,
-    targetTokenId?: number
+    sourcePage: PredictionAttributeSourcePage,
+    targetTokenId?: number,
+    flowId?: string,
+    flowStep?: number,
 ): Promise<AttributionApiResponse> {
-    const bodyObj: Record<string, unknown> = { context, model };
+    const bodyObj: Record<string, unknown> = { context, model, source_page: sourcePage };
     if (targetPrediction !== null) {
         bodyObj.target_prediction = targetPrediction;
     }
     if (typeof targetTokenId === 'number' && Number.isInteger(targetTokenId) && targetTokenId >= 0) {
         bodyObj.target_token_id = targetTokenId;
     }
+    if (typeof flowId === 'string' && flowId.length > 0) {
+        bodyObj.flow_id = flowId;
+    }
+    if (typeof flowStep === 'number' && Number.isInteger(flowStep) && flowStep >= 0) {
+        bodyObj.flow_step = flowStep;
+    }
     const res = await fetch(`${apiBaseForRequests}/api/prediction-attribute`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
@@ -57,6 +71,7 @@ export type LoadPredictionAttributeWithCacheOptions = {
     context: string;
     targetPrediction: string;
     model: PredictionAttributeModelVariant;
+    sourcePage: PredictionAttributeSourcePage;
     /** 与归因页「Force retry」一致：先按 entry 删缓存再请求 */
     forceRefresh?: boolean;
 };
@@ -67,7 +82,7 @@ export type LoadPredictionAttributeWithCacheOptions = {
 export async function loadPredictionAttributeWithCache(
     options: LoadPredictionAttributeWithCacheOptions
 ): Promise<AttributionApiResponse> {
-    const { apiBaseForRequests, context, targetPrediction, model, forceRefresh } = options;
+    const { apiBaseForRequests, context, targetPrediction, model, sourcePage, forceRefresh } = options;
     if (forceRefresh) {
         await removeCachedEntryByContentKey(entryKey(context, targetPrediction));
     }
@@ -77,7 +92,7 @@ export async function loadPredictionAttributeWithCache(
             return hit;
         }
     }
-    const json = await fetchPredictionAttribute(apiBaseForRequests, context, targetPrediction, model);
+    const json = await fetchPredictionAttribute(apiBaseForRequests, context, targetPrediction, model, sourcePage);
     await save({ context, targetPrediction }, json, 'complete');
     return json;
 }

client/src/ts/attribution/tokenGenAttributionRunner.ts

@@ -7,6 +7,9 @@ import type { PromptTokenSpan } from './genAttributeDagPreprocess';
 import type { CompletionFinishReason } from '../utils/generationEndReasonLabel';
 import { fetchPredictionAttribute, fetchTokenize } from './predictionAttributeClient';
 
+/** 与生成归因页（含 DAG）「Max tokens」输入框默认值一致 */
+export const TOKEN_GEN_MAX_TOKENS_DEFAULT = 100;
+
 function splitCodePointPrefix(text: string, prefixLength: number): { prefix: string; rest: string } | null {
     if (prefixLength < 0) return null;
     const chars = Array.from(text);
@@ -45,12 +48,14 @@ export type TokenGenAttributionOptions = {
      * `true`：停止；`false`（默认）：切换为 top-1 继续生成，直到 maxTokens 或 EOS。
      */
     stopAfterTeacherForcing?: boolean;
-    /** 最大生成 token 数，默认 200 */
+    /** 最大生成 token 数，默认 {@link TOKEN_GEN_MAX_TOKENS_DEFAULT} */
     maxTokens?: number;
     /** 每生成一个 token 后的回调；`stepIndex` 从 0 起，与 {@link TokenGenAttributionHandle.getAllSteps} 下标一致 */
     onStep: (step: TokenGenStep, stepIndex: number) => void;
     onComplete: (reason: CompletionFinishReason) => void;
     onError: (err: Error) => void;
+    /** 单次连续生成归因会话 ID；用于后端日志压缩与统计归类。 */
+    flowId: string;
 };
 
 export type TokenGenAttributionHandle = {
@@ -62,7 +67,14 @@ export type TokenGenAttributionHandle = {
 };
 
 export function startTokenGenAttribution(opts: TokenGenAttributionOptions): TokenGenAttributionHandle {
-    const { initialContext, apiPrefix, model, maxTokens = 200, stopAfterTeacherForcing = false } = opts;
+    const {
+        initialContext,
+        apiPrefix,
+        model,
+        maxTokens = TOKEN_GEN_MAX_TOKENS_DEFAULT,
+        stopAfterTeacherForcing = false,
+        flowId,
+    } = opts;
     const tfOpt = opts.teacherForcingContinuation;
     const forcingEnabled = typeof tfOpt === 'string' && tfOpt.length > 0;
     const promptRegionEnd = initialContext.length;
@@ -164,7 +176,16 @@ export function startTokenGenAttribution(opts: TokenGenAttributionOptions): Toke
 
             let response: AttributionApiResponse;
             try {
-                response = await fetchPredictionAttribute(apiPrefix, context, null, model, targetTokenId);
+                response = await fetchPredictionAttribute(
+                    apiPrefix,
+                    context,
+                    null,
+                    model,
+                    'gen_attribute.html',
+                    targetTokenId,
+                    flowId,
+                    steps.length,
+                );
             } catch (err) {
                 const error = err instanceof Error ? err : new Error(String(err));
                 opts.onError(error);

client/src/ts/chat.ts

@@ -701,4 +701,5 @@ initDensityAttributionSidebar({
     showToast,
     getContextPrefix: () => currentPromptUsed,
     predictionModelVariant: 'instruct',
+    sourcePage: 'chat.html',
 });

client/src/ts/gen_attribute.ts

@@ -34,6 +34,7 @@ import {
 import {
     createHydratedTokenGenHandle,
     startTokenGenAttribution,
+    TOKEN_GEN_MAX_TOKENS_DEFAULT,
     type TokenGenAttributionHandle,
     type TokenGenStep,
 } from './attribution/tokenGenAttributionRunner';
@@ -90,7 +91,7 @@ const showToast = createToast('#toast').show;
 
 const GEN_ATTR_MODEL_VARIANT_STORAGE_KEY = 'info_radar_gen_attr_model_variant';
 const GEN_ATTR_MAX_TOKENS_STORAGE_KEY = 'info_radar_gen_attr_max_tokens';
-const GEN_ATTR_MAX_TOKENS_DEFAULT = 100;
+const GEN_ATTR_MAX_TOKENS_DEFAULT = TOKEN_GEN_MAX_TOKENS_DEFAULT;
 const GEN_ATTR_DAG_MEASURE_WIDTH_STORAGE_KEY = 'info_radar_gen_attr_dag_measure_width';
 const GEN_ATTR_DAG_LAYOUT_MODE_STORAGE_KEY = 'info_radar_gen_attr_dag_layout_mode';
 const GEN_ATTR_DAG_PLAYBACK_STEP_MS_STORAGE_KEY = 'info_radar_gen_attr_dag_playback_step_ms';
@@ -121,6 +122,12 @@ const GEN_ATTR_DAG_PLAYBACK_TOTAL_S_MAX = 3600;
 const GENERATE_BTN_LABEL = 'Start';
 const STOP_BTN_LABEL = 'Stop';
 
+function createFlowId(): string {
+    const timePart = Date.now().toString(36).slice(-6);
+    const randPart = Math.random().toString(36).slice(2, 6);
+    return `${timePart}-${randPart}`;
+}
+
 function readStoredModelVariant(): PredictionAttributeModelVariant {
     try {
         const v = localStorage.getItem(GEN_ATTR_MODEL_VARIANT_STORAGE_KEY);
@@ -1595,6 +1602,7 @@ async function runGeneration(): Promise<void> {
             apiPrefix: apiBaseForRequests,
             model: tokenizeModel,
             maxTokens,
+            flowId: createFlowId(),
             teacherForcingContinuation: teacherForcingText,
             stopAfterTeacherForcing: stopAfterTF,
             onStep(step, stepIndex) {

client/src/ts/start.ts

@@ -1007,6 +1007,7 @@ window.onload = () => {
         apiPrefix: api_prefix,
         showToast,
         predictionModelVariant: 'base',
+        sourcePage: 'analysis.html',
     });
 
     // 高亮清除事件监听已由 initHighlightClearListeners 处理

client/src/ts/utils/settingsMenuManager.ts

@@ -383,7 +383,16 @@ export class SettingsMenuManager {
             'attribution.html',
             'gen_attribute.html',
         ] as const;
-        const API_ORDER = ['analyze', 'analyze_semantic', 'chat', 'prediction_attribute'] as const;
+        const API_ORDER = [
+            'analyze',
+            'analyze_semantic',
+            'chat',
+            'causal_flow',
+            'prediction_attribute',
+            'prediction_attribute__attribution.html',
+            'prediction_attribute__chat.html',
+            'prediction_attribute__analysis.html',
+        ] as const;
         const OS_ORDER = ['ios', 'android', 'windows', 'macos', 'linux', 'unknown'] as const;
 
         type VisitStatsRow = NonNullable<Awaited<ReturnType<TextAnalysisAPI['getVisitStats']>>>;

server.yaml

@@ -505,9 +505,19 @@ paths:
                 type: string
                 enum: [base, instruct]
                 description: base 使用主槽位（--model），instruct 使用语义槽位（--semantic_model）
+              source_page:
+                type: string
+                description: 发起页面名（analysis.html / chat.html / attribution.html / gen_attribute.html）
+              flow_id:
+                type: string
+                description: 连续生成归因会话 ID；仅 source_page=gen_attribute.html 时允许
+              flow_step:
+                type: integer
+                description: 连续生成归因步骤（从 0 开始）；仅 source_page=gen_attribute.html 时允许
             required:
               - context
               - model
+              - source_page
       responses:
         200:
           description: 返回各输入 token 对目标预测的归因分