675 lines
26 KiB
Python
675 lines
26 KiB
Python
"""Behavior regression for #5720 live reasoning presentation ownership."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import os
|
|
import shutil
|
|
import subprocess
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
NODE = shutil.which("node")
|
|
|
|
|
|
def _run_reasoning_scene(
|
|
*,
|
|
activity_mode: str = "transparent_stream",
|
|
fail_first_anchor_render: bool = False,
|
|
fail_anchor_render_on: int | None = None,
|
|
multi_segment_fallback: bool = False,
|
|
stale_active_stream: bool = False,
|
|
stale_live_turn: bool = False,
|
|
show_thinking: bool = True,
|
|
) -> dict:
|
|
assert NODE, "node is required for the #5720 browser-chain regression"
|
|
env = os.environ.copy()
|
|
env.setdefault("ISSUE5720_UI_JS", str(ROOT / "static" / "ui.js"))
|
|
env.setdefault("ISSUE5720_MESSAGES_JS", str(ROOT / "static" / "messages.js"))
|
|
env.setdefault(
|
|
"ISSUE5720_ANCHORS_JS",
|
|
str(ROOT / "static" / "assistant_turn_anchors.js"),
|
|
)
|
|
env["ISSUE5720_ACTIVITY_MODE"] = activity_mode
|
|
if fail_first_anchor_render:
|
|
env["ISSUE5720_FAIL_FIRST_ANCHOR_RENDER"] = "1"
|
|
if fail_anchor_render_on is not None:
|
|
env["ISSUE5720_FAIL_ANCHOR_RENDER_ON"] = str(fail_anchor_render_on)
|
|
if multi_segment_fallback:
|
|
env["ISSUE5720_MULTI_SEGMENT_FALLBACK"] = "1"
|
|
if stale_active_stream:
|
|
env["ISSUE5720_STALE_ACTIVE_STREAM"] = "1"
|
|
if stale_live_turn:
|
|
env["ISSUE5720_STALE_LIVE_TURN"] = "1"
|
|
if not show_thinking:
|
|
env["ISSUE5720_SHOW_THINKING"] = "0"
|
|
result = subprocess.run(
|
|
[NODE, "-e", _NODE_SCENE],
|
|
cwd=ROOT,
|
|
env=env,
|
|
text=True,
|
|
capture_output=True,
|
|
timeout=10,
|
|
check=False,
|
|
)
|
|
assert result.returncode == 0, result.stderr
|
|
return json.loads(result.stdout)
|
|
|
|
|
|
@pytest.mark.skipif(NODE is None, reason="node not on PATH")
|
|
def test_deepseek_reasoning_deltas_keep_one_live_row_owner():
|
|
result = _run_reasoning_scene()
|
|
|
|
assert result["first_text"] == "Plan"
|
|
assert result["second_text"] == "Plan step"
|
|
assert result["same_node"] is True
|
|
assert result["live_reasoning_rows"] == 1
|
|
assert result["render_passes"] == [1, 2]
|
|
assert result["anchor_reasoning_events"] == 1
|
|
assert result["anchor_reasoning_text"] == "Plan step"
|
|
assert result["inflight_reasoning_text"] == "Plan step"
|
|
|
|
|
|
@pytest.mark.skipif(NODE is None, reason="node not on PATH")
|
|
def test_reasoning_uses_visible_fallback_when_anchor_declines_first_paint():
|
|
result = _run_reasoning_scene(fail_first_anchor_render=True)
|
|
|
|
assert result["first_text"] is None
|
|
assert result["first_fallback_text"] == "Plan"
|
|
assert result["second_text"] == "Plan step"
|
|
assert result["live_reasoning_rows"] == 1
|
|
assert result["fallback_rows_after_recovery"] == 0
|
|
assert result["anchor_reasoning_events"] == 1
|
|
assert result["anchor_reasoning_text"] == "Plan step"
|
|
assert result["inflight_reasoning_text"] == "Plan step"
|
|
|
|
|
|
@pytest.mark.skipif(NODE is None, reason="node not on PATH")
|
|
def test_stale_stream_reasoning_cannot_claim_the_active_turn():
|
|
result = _run_reasoning_scene(stale_active_stream=True)
|
|
|
|
assert result["anchor_render_attempts"] == 0
|
|
assert result["live_reasoning_rows"] == 0
|
|
assert result["fallback_rows_after_recovery"] == 0
|
|
assert result["anchor_reasoning_events"] == 0
|
|
assert result["inflight_reasoning_text"] == ""
|
|
|
|
|
|
@pytest.mark.skipif(NODE is None, reason="node not on PATH")
|
|
def test_reasoning_fallback_respects_show_thinking_false():
|
|
result = _run_reasoning_scene(
|
|
fail_first_anchor_render=True,
|
|
show_thinking=False,
|
|
)
|
|
|
|
assert result["anchor_render_attempts"] == 0
|
|
assert result["live_reasoning_rows"] == 0
|
|
assert result["fallback_rows_after_recovery"] == 0
|
|
assert result["anchor_reasoning_events"] == 0
|
|
|
|
|
|
@pytest.mark.skipif(NODE is None, reason="node not on PATH")
|
|
def test_reasoning_rebuilds_when_another_sessions_live_turn_blocks_anchor():
|
|
result = _run_reasoning_scene(stale_live_turn=True)
|
|
|
|
assert result["first_text"] == "Plan"
|
|
assert result["second_text"] == "Plan step"
|
|
assert result["live_reasoning_rows"] == 1
|
|
assert result["fallback_rows_after_recovery"] == 0
|
|
assert result["anchor_reasoning_events"] == 1
|
|
assert result["anchor_reasoning_text"] == "Plan step"
|
|
assert result["inflight_reasoning_text"] == "Plan step"
|
|
|
|
|
|
@pytest.mark.skipif(NODE is None, reason="node not on PATH")
|
|
def test_reasoning_fallback_rebuilds_from_another_sessions_live_turn():
|
|
result = _run_reasoning_scene(
|
|
fail_first_anchor_render=True,
|
|
stale_live_turn=True,
|
|
)
|
|
|
|
assert result["first_text"] is None
|
|
assert result["first_fallback_text"] == "Plan"
|
|
assert result["second_text"] == "Plan step"
|
|
assert result["live_reasoning_rows"] == 1
|
|
assert result["fallback_rows_after_recovery"] == 0
|
|
assert result["anchor_reasoning_events"] == 1
|
|
assert result["anchor_reasoning_text"] == "Plan step"
|
|
assert result["inflight_reasoning_text"] == "Plan step"
|
|
|
|
|
|
@pytest.mark.skipif(NODE is None, reason="node not on PATH")
|
|
@pytest.mark.parametrize("activity_mode", ["transparent_stream", "compact_worklog"])
|
|
def test_later_deferred_anchor_paint_updates_existing_reasoning_owner(activity_mode):
|
|
result = _run_reasoning_scene(
|
|
activity_mode=activity_mode,
|
|
fail_anchor_render_on=2,
|
|
)
|
|
|
|
assert result["first_text"] == "Plan"
|
|
assert result["second_text"] == "Plan step"
|
|
assert result["same_node"] is True
|
|
assert result["live_reasoning_rows"] == 1
|
|
assert result["fallback_rows_after_recovery"] == 0
|
|
assert result["visible_reasoning_owners"] == 1
|
|
assert result["anchor_render_attempts"] == 2
|
|
assert result["anchor_reasoning_events"] == 1
|
|
assert result["anchor_reasoning_text"] == "Plan step"
|
|
assert result["inflight_reasoning_text"] == "Plan step"
|
|
|
|
|
|
@pytest.mark.skipif(NODE is None, reason="node not on PATH")
|
|
@pytest.mark.parametrize("activity_mode", ["transparent_stream", "compact_worklog"])
|
|
def test_later_deferred_anchor_paint_updates_exact_reasoning_owner(activity_mode):
|
|
result = _run_reasoning_scene(
|
|
activity_mode=activity_mode,
|
|
multi_segment_fallback=True,
|
|
)
|
|
exact = result["multi_segment_exact_fallback"]
|
|
|
|
assert exact["first_before"] == "Plan step"
|
|
assert exact["first_after"] == "Plan step"
|
|
assert exact["second_before"] == "Second draft"
|
|
assert exact["second_after"] == "Second updated"
|
|
assert exact["legacy_after"] == "Legacy unkeyed"
|
|
assert exact["anchor_run_id"] == "run-5720"
|
|
assert exact["second_row_id"] == "run-5720:2"
|
|
assert exact["second_local_id"] == "live-reasoning:stream-1:2"
|
|
assert exact["live_reasoning_rows"] == 2
|
|
assert exact["fallback_rows"] == 0
|
|
|
|
|
|
@pytest.mark.skipif(NODE is None, reason="node not on PATH")
|
|
def test_later_deferred_anchor_paint_remains_hidden_in_final_answer_only_mode():
|
|
result = _run_reasoning_scene(
|
|
activity_mode="hide_all_activity",
|
|
fail_anchor_render_on=2,
|
|
)
|
|
|
|
assert result["first_text"] is None
|
|
assert result["second_text"] is None
|
|
assert result["live_reasoning_rows"] == 0
|
|
assert result["fallback_rows_after_recovery"] == 0
|
|
assert result["visible_reasoning_owners"] == 0
|
|
assert result["anchor_render_attempts"] == 2
|
|
assert result["anchor_reasoning_events"] == 1
|
|
assert result["anchor_reasoning_text"] == "Plan step"
|
|
|
|
|
|
_NODE_SCENE = r"""
|
|
const fs = require('fs');
|
|
const uiSrc = fs.readFileSync(process.env.ISSUE5720_UI_JS, 'utf8');
|
|
const messagesSrc = fs.readFileSync(process.env.ISSUE5720_MESSAGES_JS, 'utf8');
|
|
const anchorsSrc = fs.readFileSync(process.env.ISSUE5720_ANCHORS_JS, 'utf8');
|
|
|
|
function extractFunc(src, name){
|
|
const start = src.indexOf('function ' + name);
|
|
if(start < 0){
|
|
if(name==='isFinalAnswerOnlyMode'||name==='isHideAllActivityMode'){
|
|
return `function ${name}(){ return false; }`;
|
|
}
|
|
if(name==='_anchorSceneRowTimestampSeconds'){
|
|
return `function ${name}(){ return null; }`;
|
|
}
|
|
throw new Error(name + ' not found');
|
|
}
|
|
const params = src.indexOf('(', start);
|
|
let depth = 0, close = -1;
|
|
for(let i=params; i<src.length; i++){
|
|
if(src[i] === '(') depth++;
|
|
else if(src[i] === ')' && --depth === 0){ close = i; break; }
|
|
}
|
|
const brace = src.indexOf('{', close);
|
|
depth = 0;
|
|
for(let i=brace; i<src.length; i++){
|
|
if(src[i] === '{') depth++;
|
|
else if(src[i] === '}' && --depth === 0) return src.slice(start, i + 1);
|
|
}
|
|
throw new Error(name + ' did not close');
|
|
}
|
|
|
|
class FakeElement {
|
|
constructor(tag='div'){
|
|
this.tagName=String(tag).toUpperCase();
|
|
this.children=[];
|
|
this.parentNode=null;
|
|
this.attributes=Object.create(null);
|
|
this.dataset=Object.create(null);
|
|
this.style=Object.create(null);
|
|
this.hidden=false;
|
|
this.id='';
|
|
this._text='';
|
|
this._classes=new Set();
|
|
const self=this;
|
|
this.classList={
|
|
add(...names){ names.forEach(name=>self._classes.add(name)); },
|
|
remove(...names){ names.forEach(name=>self._classes.delete(name)); },
|
|
contains(name){ return self._classes.has(name); },
|
|
toggle(name, force){
|
|
if(force===true){ self._classes.add(name); return true; }
|
|
if(force===false){ self._classes.delete(name); return false; }
|
|
if(self._classes.has(name)){ self._classes.delete(name); return false; }
|
|
self._classes.add(name); return true;
|
|
},
|
|
};
|
|
}
|
|
get parentElement(){ return this.parentNode; }
|
|
get nextSibling(){
|
|
if(!this.parentNode) return null;
|
|
const siblings=this.parentNode.children;
|
|
return siblings[siblings.indexOf(this)+1]||null;
|
|
}
|
|
get className(){ return Array.from(this._classes).join(' '); }
|
|
set className(value){ this._classes=new Set(String(value).split(/\s+/).filter(Boolean)); }
|
|
get textContent(){
|
|
return this.children.length ? this.children.map(child=>child.textContent).join('') : this._text;
|
|
}
|
|
set textContent(value){ this._text=String(value??''); this.children=[]; }
|
|
get innerHTML(){ return this.textContent; }
|
|
set innerHTML(value){ this.textContent=value; }
|
|
setAttribute(name, value){
|
|
const key=String(name), val=String(value);
|
|
this.attributes[key]=val;
|
|
if(key==='id') this.id=val;
|
|
if(key==='class') this.className=val;
|
|
if(key.startsWith('data-')){
|
|
const dataKey=key.slice(5).replace(/-([a-z])/g,(_,c)=>c.toUpperCase());
|
|
this.dataset[dataKey]=val;
|
|
}
|
|
}
|
|
getAttribute(name){
|
|
return Object.prototype.hasOwnProperty.call(this.attributes,name)?this.attributes[name]:null;
|
|
}
|
|
getAttributeNames(){ return Object.keys(this.attributes); }
|
|
removeAttribute(name){
|
|
delete this.attributes[name];
|
|
if(name==='id') this.id='';
|
|
if(name.startsWith('data-')){
|
|
const dataKey=name.slice(5).replace(/-([a-z])/g,(_,c)=>c.toUpperCase());
|
|
delete this.dataset[dataKey];
|
|
}
|
|
}
|
|
appendChild(child){
|
|
if(child.tagName==='#FRAGMENT'){
|
|
child.children.slice().forEach(node=>this.appendChild(node));
|
|
child.children=[];
|
|
return child;
|
|
}
|
|
if(child.parentNode) child.remove();
|
|
child.parentNode=this;
|
|
this.children.push(child);
|
|
return child;
|
|
}
|
|
insertBefore(child, ref){
|
|
if(child.parentNode) child.remove();
|
|
child.parentNode=this;
|
|
const idx=this.children.indexOf(ref);
|
|
if(idx<0) this.children.push(child); else this.children.splice(idx,0,child);
|
|
return child;
|
|
}
|
|
remove(){
|
|
if(!this.parentNode) return;
|
|
const siblings=this.parentNode.children;
|
|
const idx=siblings.indexOf(this);
|
|
if(idx>=0) siblings.splice(idx,1);
|
|
this.parentNode=null;
|
|
}
|
|
matches(selector){ return matchesSelector(this,selector); }
|
|
querySelector(selector){ return this.querySelectorAll(selector)[0]||null; }
|
|
querySelectorAll(selector){
|
|
const out=[];
|
|
const walk=node=>node.children.forEach(child=>{
|
|
if(matchesSelector(child,selector)) out.push(child);
|
|
walk(child);
|
|
});
|
|
walk(this);
|
|
return out;
|
|
}
|
|
closest(selector){
|
|
let node=this;
|
|
while(node){ if(matchesSelector(node,selector)) return node; node=node.parentNode; }
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function matchesSelector(el, selector){
|
|
return String(selector).split(',').some(part=>matchesChain(el,part.trim()));
|
|
}
|
|
function matchesChain(el, selector){
|
|
const parts=selector.split(/\s+/).filter(Boolean);
|
|
if(!parts.length||!matchesSimple(el,parts[parts.length-1])) return false;
|
|
let node=el.parentNode;
|
|
for(let i=parts.length-2;i>=0;i--){
|
|
while(node&&!matchesSimple(node,parts[i])) node=node.parentNode;
|
|
if(!node) return false;
|
|
node=node.parentNode;
|
|
}
|
|
return true;
|
|
}
|
|
function matchesSimple(el, selector){
|
|
selector=selector.replace(/^:scope\s*>\s*/,'');
|
|
const nots=[];
|
|
selector=selector.replace(/:not\(([^)]+)\)/g,(_,inner)=>{nots.push(inner);return '';});
|
|
if(nots.some(inner=>matchesSimple(el,inner))) return false;
|
|
const tag=selector.match(/^[A-Za-z][A-Za-z0-9-]*/);
|
|
if(tag&&el.tagName!==tag[0].toUpperCase()) return false;
|
|
const id=selector.match(/#([A-Za-z0-9_-]+)/);
|
|
if(id&&el.id!==id[1]) return false;
|
|
for(const match of selector.matchAll(/\.([A-Za-z0-9_-]+)/g)){
|
|
if(!el.classList.contains(match[1])) return false;
|
|
}
|
|
for(const match of selector.matchAll(/\[([^\]=]+)(?:=["']?([^\]"']*)["']?)?\]/g)){
|
|
const value=el.getAttribute(match[1]);
|
|
if(value===null) return false;
|
|
if(match[2]!==undefined&&String(value)!==String(match[2])) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
global.window={
|
|
_chatActivityDisplayMode:process.env.ISSUE5720_ACTIVITY_MODE||'transparent_stream',
|
|
_showThinking:process.env.ISSUE5720_SHOW_THINKING!=='0',
|
|
_simplifiedToolCalling:true,
|
|
};
|
|
global.document={
|
|
baseURI:'http://test.local/',
|
|
hidden:false,
|
|
createElement:tag=>new FakeElement(tag),
|
|
createTextNode:text=>{const node=new FakeElement('#text');node.textContent=text;return node;},
|
|
createDocumentFragment:()=>new FakeElement('#fragment'),
|
|
querySelector:()=>null,
|
|
};
|
|
global.location={href:'http://test.local/'};
|
|
global.CSS={escape:value=>String(value)};
|
|
global.requestAnimationFrame=fn=>{fn();return 1;};
|
|
global.setTimeout=()=>1;
|
|
global.clearTimeout=()=>{};
|
|
|
|
const emptyState=new FakeElement('div');
|
|
const msgInner=new FakeElement('div');
|
|
const messages=new FakeElement('div');
|
|
const turn=new FakeElement('div');
|
|
turn.id='liveAssistantTurn';
|
|
turn.className='assistant-turn';
|
|
turn.dataset.sessionId=process.env.ISSUE5720_STALE_LIVE_TURN==='1'?'sid-old':'sid-1';
|
|
msgInner.appendChild(turn);
|
|
const byId={emptyState,msgInner,messages,liveAssistantTurn:turn};
|
|
global.$=id=>byId[id]||null;
|
|
global._createAssistantTurn=()=>turn;
|
|
global._assistantTurnBlocks=()=>turn;
|
|
global._captureMessageScrollSnapshot=()=>({scrollHeight:1000});
|
|
global._prepareLiveAnchorScrollRebuildGuard=()=>({readerAwayFromBottom:false,release:null});
|
|
global._restoreMessageScrollSnapshotSameFrame=()=>{};
|
|
global.scrollIfPinned=()=>{};
|
|
global._moveLiveRunStatusToTurnEnd=()=>{};
|
|
global._messageUserUnpinned=false;
|
|
global._syncTransparentEventControls=()=>{};
|
|
global._syncToolCallGroupSummary=()=>{};
|
|
global._captureWorklogDetailDisclosureState=()=>null;
|
|
global._restoreWorklogDetailDisclosureState=()=>{};
|
|
global._startActivityElapsedTimer=()=>{};
|
|
global._dedupeLiveProcessedWorklogAnchors=()=>{};
|
|
global._toolWorklogListEl=group=>group&&group.querySelector&&group.querySelector('.tool-worklog-list')||group;
|
|
global.ensureActivityGroup=(blocks,opts)=>{
|
|
opts=opts||{};
|
|
const key=String(opts.activityKey||'');
|
|
let group=key&&blocks.querySelector&&blocks.querySelector(`.tool-worklog-group[data-tool-worklog-key="${CSS.escape(key)}"]`);
|
|
if(group) return group;
|
|
group=new FakeElement('div');
|
|
group.className='tool-worklog-group tool-call-group';
|
|
group.setAttribute('data-tool-worklog-group','1');
|
|
group.setAttribute('data-live-tool-call-group','1');
|
|
group.setAttribute('data-tool-worklog-key',key);
|
|
const list=new FakeElement('div');
|
|
list.className='tool-worklog-list';
|
|
group.appendChild(list);
|
|
blocks.appendChild(group);
|
|
return group;
|
|
};
|
|
global.ensureLiveWorklogContainer=(blocks,opts)=>ensureActivityGroup(blocks,opts);
|
|
global._thinkingActivityNode=text=>{
|
|
const row=new FakeElement('div');
|
|
row.className='agent-activity-thinking transparent-thinking-event';
|
|
const card=new FakeElement('div');
|
|
card.className='thinking-card open';
|
|
const header=new FakeElement('div');
|
|
header.className='thinking-card-header';
|
|
const preview=new FakeElement('span');
|
|
preview.className='transparent-event-thinking-preview';
|
|
preview.textContent=text;
|
|
const body=new FakeElement('div');
|
|
body.className='thinking-card-body';
|
|
const pre=new FakeElement('pre');
|
|
pre.textContent=text;
|
|
header.appendChild(preview);
|
|
body.appendChild(pre);
|
|
card.appendChild(header);
|
|
card.appendChild(body);
|
|
row.appendChild(card);
|
|
return row;
|
|
};
|
|
global._decorateTransparentEventRow=(row,opts)=>{
|
|
row.classList.add('transparent-event-row');
|
|
row.setAttribute('data-transparent-event-row','1');
|
|
row.setAttribute('data-event-type',String(opts&&opts.type||'activity'));
|
|
const preview=row.querySelector('.transparent-event-thinking-preview');
|
|
if(preview) preview.textContent=String(opts&&opts.preview||opts&&opts.text||'');
|
|
return row;
|
|
};
|
|
global._rehydrateTransparentLiveRow=()=>{};
|
|
global._sanitizeThinkingDisplayText=value=>String(value||'').trim();
|
|
global._firstValidTimestampSeconds=()=>null;
|
|
|
|
eval(anchorsSrc);
|
|
for(const name of [
|
|
'chatActivityMode','isTransparentStream','isFinalAnswerOnlyMode','isCompactWorklogMode','isSimplifiedToolCalling',
|
|
'_anchorSceneIsSettledSuccessfulCompression','_anchorSceneRowsForRendering',
|
|
'_anchorSceneRowTimestampSeconds','_anchorSceneTransparentNodeForRow',
|
|
'_transparentLiveRowKey','_transparentLiveRowsCompatible',
|
|
'_transparentLiveRowAttributePairs','_transparentLiveRowInteractiveState',
|
|
'_refreshTransparentThinkingLiveRow','_refreshTransparentLiveRow',
|
|
'_thinkingMarkup','_renderThinkingInto',
|
|
'_resetMismatchedLiveAssistantTurnForSession',
|
|
'_liveAnchorReasoningRowForFallback','_updateLiveAnchorReasoningRowForFallback',
|
|
'_anchorSceneNodeForRow','_anchorSceneWorklogGroup','_renderAnchorSceneRowsIntoWorklog',
|
|
'isLiveAnchorActivitySceneOwner','_projectLiveAnchorActivitySceneForStream',
|
|
'_restoreLiveAnchorScrollSnapshotAfterRebuild',
|
|
'_renderLiveAnchorActivitySceneTransparent','renderLiveAnchorActivityScene',
|
|
'_renderLiveAnchorActivitySceneForStream','appendThinking','updateThinking',
|
|
]) eval(extractFunc(uiSrc,name));
|
|
|
|
let transparentRenderPasses=0;
|
|
const realTransparentRender=_renderLiveAnchorActivitySceneTransparent;
|
|
_renderLiveAnchorActivitySceneTransparent=function(...args){
|
|
transparentRenderPasses+=1;
|
|
return realTransparentRender(...args);
|
|
};
|
|
const failFirstAnchorRender=process.env.ISSUE5720_FAIL_FIRST_ANCHOR_RENDER==='1';
|
|
const failAnchorRenderOn=Number(process.env.ISSUE5720_FAIL_ANCHOR_RENDER_ON||'0');
|
|
let anchorRenderAttempts=0;
|
|
window._renderLiveAnchorActivitySceneForStream=function(...args){
|
|
anchorRenderAttempts+=1;
|
|
if(failFirstAnchorRender&&anchorRenderAttempts===1) return false;
|
|
if(failAnchorRenderOn&&anchorRenderAttempts===failAnchorRenderOn) return false;
|
|
return _renderLiveAnchorActivitySceneForStream(...args);
|
|
};
|
|
window.isLiveAnchorActivitySceneOwner=isLiveAnchorActivitySceneOwner;
|
|
|
|
const S=global.S={
|
|
session:{session_id:'sid-1',pending_started_at:1},
|
|
messages:[{role:'user',content:'question'}],
|
|
activeStreamId:'stream-1',
|
|
};
|
|
const INFLIGHT=global.INFLIGHT={};
|
|
const LIVE_STREAMS=global.LIVE_STREAMS={};
|
|
const _STREAM_WAS_HIDDEN=global._STREAM_WAS_HIDDEN={};
|
|
const _STREAM_NOTIFICATION_BACKGROUND=global._STREAM_NOTIFICATION_BACKGROUND={};
|
|
const _desktopBackgroundedForNotifications=false;
|
|
global._bindStreamHiddenTracker=()=>{};
|
|
global.closeOtherLiveStreams=()=>{};
|
|
global.closeLiveStream=()=>{};
|
|
global.resetTurnWorkspaceMutations=()=>{};
|
|
global._resetStreamScrollFollow=()=>{};
|
|
global._suspendSessionStreamForLiveChat=()=>{};
|
|
global.ensureLiveWorklogShell=()=>null;
|
|
global._extractInlineThinkingFromContent=(content,reasoning)=>({content:String(content||''),reasoning:String(reasoning||'')});
|
|
|
|
class FakeEventSource {
|
|
static instances=[];
|
|
static OPEN=1;
|
|
static CONNECTING=0;
|
|
constructor(){ this.listeners=Object.create(null);this.readyState=1;FakeEventSource.instances.push(this); }
|
|
addEventListener(name,fn){ (this.listeners[name]||(this.listeners[name]=[])).push(fn); }
|
|
emit(name,data){ for(const fn of this.listeners[name]||[]) fn({data:JSON.stringify(data),lastEventId:''}); }
|
|
close(){ this.readyState=2; }
|
|
}
|
|
global.EventSource=FakeEventSource;
|
|
|
|
const attachStart=messagesSrc.indexOf('function attachLiveStream(');
|
|
const attachEnd=messagesSrc.indexOf('\nfunction transcript(){',attachStart);
|
|
if(attachStart<0||attachEnd<0) throw new Error('attachLiveStream source boundary not found');
|
|
eval(extractFunc(messagesSrc,'_dispatchExtensionTurnLifecycle'));
|
|
eval(messagesSrc.slice(attachStart,attachEnd));
|
|
attachLiveStream('sid-1','stream-1');
|
|
const source=FakeEventSource.instances[0];
|
|
if(!source) throw new Error('attachLiveStream did not create EventSource');
|
|
if(process.env.ISSUE5720_STALE_ACTIVE_STREAM==='1') S.activeStreamId='stream-new';
|
|
|
|
function anchorReasoningRows(){
|
|
return turn.querySelectorAll(
|
|
'[data-anchor-scene-row="1"][data-anchor-source-event-type="reasoning"],'+
|
|
'[data-anchor-scene-row="1"][data-anchor-row-role="thinking"]'
|
|
);
|
|
}
|
|
function fallbackReasoningRows(){
|
|
return turn.querySelectorAll('.agent-activity-thinking[data-live-thinking="1"]')
|
|
.filter(row=>row.getAttribute('data-anchor-scene-row')!=='1');
|
|
}
|
|
function reasoningText(row){
|
|
if(!row) return null;
|
|
const pre=row.querySelector&&row.querySelector('pre');
|
|
return pre?pre.textContent:row.textContent;
|
|
}
|
|
function applyProductionAnchorEvent(sourceEventType, data){
|
|
const registry=window._liveAnchorRegistries&&window._liveAnchorRegistries.get('stream-1');
|
|
if(!registry) throw new Error('missing live anchor registry');
|
|
window.HermesAssistantTurnAnchors.applyAssistantTurnAnchorSourceEvent(
|
|
registry,
|
|
{
|
|
source_event_type:sourceEventType,
|
|
run_id:'run-5720',
|
|
stream_id:'stream-1',
|
|
...data,
|
|
},
|
|
{
|
|
session_id:'sid-1',
|
|
stream_id:'stream-1',
|
|
run_id:'run-5720',
|
|
}
|
|
);
|
|
return registry;
|
|
}
|
|
function appendProductionAnchorReasoningRow(localId, text, seq){
|
|
applyProductionAnchorEvent('reasoning',{
|
|
local_id:localId,
|
|
seq,
|
|
text,
|
|
activitySegmentSeq:seq,
|
|
activityBurstId:0,
|
|
});
|
|
window._renderLiveAnchorActivitySceneForStream('stream-1','sid-1',{
|
|
mode:process.env.ISSUE5720_ACTIVITY_MODE||'transparent_stream',
|
|
});
|
|
const row=anchorReasoningRows().find(candidate=>
|
|
candidate.getAttribute('data-anchor-row-id')===`run-5720:${seq}`
|
|
);
|
|
if(!row) throw new Error('production anchor reasoning row not rendered');
|
|
return row;
|
|
}
|
|
function appendUnkeyedLegacyReasonRow(text){
|
|
const row=new FakeElement('div');
|
|
row.className='wl-reason';
|
|
row.setAttribute('data-worklog-anchor-reason','1');
|
|
row.textContent=text;
|
|
if(isTransparentStream()){
|
|
turn.appendChild(row);
|
|
}else{
|
|
const group=ensureActivityGroup(turn,{activityKey:'live:stream-1'});
|
|
const list=_toolWorklogListEl(group);
|
|
(list||group||turn).appendChild(row);
|
|
}
|
|
return row;
|
|
}
|
|
|
|
source.emit('reasoning',{text:'Plan '});
|
|
const first=anchorReasoningRows()[0]||null;
|
|
const firstText=reasoningText(first);
|
|
const firstFallback=fallbackReasoningRows()[0]||null;
|
|
const firstFallbackText=reasoningText(firstFallback);
|
|
const passAfterFirst=transparentRenderPasses;
|
|
source.emit('reasoning',{text:'step'});
|
|
const second=anchorReasoningRows()[0]||null;
|
|
const secondText=reasoningText(second);
|
|
const anchorRowsAfterRecovery=anchorReasoningRows();
|
|
const fallbackRowsAfterRecovery=fallbackReasoningRows();
|
|
const registry=window._liveAnchorRegistries&&window._liveAnchorRegistries.get('stream-1');
|
|
const anchorReasoningEvents=registry&®istry.anchor&&Array.isArray(registry.anchor.activity_events)
|
|
? registry.anchor.activity_events.filter(event=>event&&event.source_event_type==='reasoning')
|
|
: [];
|
|
let multiSegmentExactFallback=null;
|
|
if(process.env.ISSUE5720_MULTI_SEGMENT_FALLBACK==='1'){
|
|
const firstReasoningRow=anchorReasoningRows()[0]||null;
|
|
const firstBefore=reasoningText(firstReasoningRow);
|
|
const secondId='live-reasoning:stream-1:2';
|
|
const registry=applyProductionAnchorEvent('interim_assistant',{
|
|
seq:1,
|
|
text:'',
|
|
});
|
|
const secondReasoningRow=appendProductionAnchorReasoningRow(secondId,'Second draft',2);
|
|
const secondBefore=reasoningText(secondReasoningRow);
|
|
const legacyRow=appendUnkeyedLegacyReasonRow('Legacy unkeyed');
|
|
appendThinking('Second updated',{
|
|
anchorRenderFallback:true,
|
|
sessionId:'sid-1',
|
|
streamId:'stream-1',
|
|
anchorReasoningLocalId:secondId,
|
|
segmentSeq:2,
|
|
burstId:0,
|
|
});
|
|
multiSegmentExactFallback={
|
|
anchor_run_id:registry&®istry.anchor&®istry.anchor.identity&®istry.anchor.identity.run_id,
|
|
first_row_id:firstReasoningRow&&firstReasoningRow.getAttribute('data-anchor-row-id'),
|
|
first_before:firstBefore,
|
|
first_after:reasoningText(firstReasoningRow),
|
|
second_row_id:secondReasoningRow.getAttribute('data-anchor-row-id'),
|
|
second_local_id:secondReasoningRow.getAttribute('data-anchor-local-id'),
|
|
second_before:secondBefore,
|
|
second_after:reasoningText(secondReasoningRow),
|
|
legacy_after:reasoningText(legacyRow),
|
|
live_reasoning_rows:anchorReasoningRows().length,
|
|
fallback_rows:fallbackReasoningRows().length,
|
|
};
|
|
}
|
|
|
|
process.stdout.write(JSON.stringify({
|
|
first_text:firstText,
|
|
first_fallback_text:firstFallbackText,
|
|
second_text:secondText,
|
|
same_node:first===second,
|
|
live_reasoning_rows:anchorRowsAfterRecovery.length,
|
|
fallback_rows_after_recovery:fallbackRowsAfterRecovery.length,
|
|
visible_reasoning_owners:anchorRowsAfterRecovery.length+fallbackRowsAfterRecovery.length,
|
|
render_passes:[passAfterFirst,transparentRenderPasses],
|
|
anchor_render_attempts:anchorRenderAttempts,
|
|
anchor_reasoning_events:anchorReasoningEvents.length,
|
|
anchor_reasoning_text:anchorReasoningEvents.length
|
|
? String(anchorReasoningEvents[anchorReasoningEvents.length-1].payload&&anchorReasoningEvents[anchorReasoningEvents.length-1].payload.text||'')
|
|
: null,
|
|
inflight_reasoning_text:String(INFLIGHT['sid-1']&&INFLIGHT['sid-1'].lastReasoningText||''),
|
|
multi_segment_exact_fallback:multiSegmentExactFallback,
|
|
}));
|
|
"""
|