Skip to content

A team of long-lived bots for DeepSeek Harness, with main bots, bot-to-bot messages and group chats.

Preserve turn identity across long archived conversation pages

Fei24116991ad557a26
diff --cc ds-bot/src/host/parts.js
index 759124f0,5ec7222c..ead81969
--- a/ds-bot/src/host/parts.js
+++ b/ds-bot/src/host/parts.js
@@@ -1284,38 -1283,15 +1284,39 @@@ export function install(rt)
async function partPage(parts, index, cursor) {
const part = parts[index]
- const agent = await rt.resolveAgent(part.sessionId)
++ const signal = AbortSignal.timeout(HISTORY_TIMEOUT_MS)
+ // An archived earlier part may have no live agent left; its stored events
+ // still page fine, so resolve failure only drops the live-session cap.
+ const agent = await rt.resolveAgent(part.sessionId).catch(() => undefined)
const page = await ctx.sessionController.page({
address: { kind: 'session', sessionId: part.sessionId },
- throughSeq: Number(agent.session.seq) - 1,
+ ...(agent ? { throughSeq: Number(agent.session.seq) - 1 } : {}),
...(Number.isInteger(cursor?.beforeSeq) ? { beforeSeq: cursor.beforeSeq } : {}),
maxMessages: EARLIER_PAGE,
-- }, AbortSignal.timeout(HISTORY_TIMEOUT_MS))
++ }, signal)
const events = page.records.map(record => record.event)
- const items = displayItems(part.sessionId, events, agent.session)
+ let seedTurn
+ if (agent === undefined) {
+ // Without the live session's projection, rows on a page that does not
+ // hold its own turn/start would lose their turn; walk back for it.
+ let before = events[0]?.seq
- for (let depth = 0; Number.isInteger(before) && depth < 5 && seedTurn === undefined; depth += 1) {
++ while (Number.isInteger(before) && seedTurn === undefined) {
+ const back = await ctx.sessionController.page({
+ address: { kind: 'session', sessionId: part.sessionId },
+ beforeSeq: before,
+ maxMessages: EARLIER_PAGE,
- }, AbortSignal.timeout(HISTORY_TIMEOUT_MS))
++ }, signal)
+ const starts = back.records.map(record => record.event).filter(event => event.type === 'turn/start')
+ if (starts.length > 0) {
+ const last = starts.at(-1).data?.turn
+ if (Number.isInteger(last)) seedTurn = last
+ break
+ }
+ if (!back.hasMore) break
+ before = back.records[0]?.event?.seq
+ }
+ }
+ const items = displayItems(part.sessionId, events, agent?.session, seedTurn)
const more = page.hasMore && events.length > 0
// The line above a part's first message marks where it began.
if (!more && index > 0) items.unshift({ kind: 'divider', time: part.startedAt })
diff --cc ds-bot/test/bot-messages.test.js
index 9f77111e,d6ba13fd..717f0342
--- a/ds-bot/test/bot-messages.test.js
+++ b/ds-bot/test/bot-messages.test.js
@@@ -707,38 -736,6 +736,38 @@@ test('an earlier part keeps the reques
assert.equal(items[0].botId, 'a')
})
+// #537: an archived earlier part may have no live agent to resolve; the page
+// still loads from the stored events.
+test('an earlier part loads when its agent is gone', async () => {
+ const rt = earlierParts([
+ { type: 'user/message', seq: 1, time: 10, data: { content: [{ type: 'text', text: 'still here' }], source: { kind: 'user' } } },
+ ])
+ rt.resolveAgent = async () => { throw Object.assign(new Error('Session unavailable'), { code: 'session/gone' }) }
+ const { items } = await rt.earlierPage('b2')
+ assert.deepEqual(items.map(item => [item.kind, item.text]), [['user', 'still here']])
+})
+
+// #537: a turn that spans a page boundary keeps its number on the newer page
+// even when the part's agent is gone (no live projection to seed it).
+test('an agentless part keeps the turn that opened on an older page', async () => {
+ const events = [{ seq: 1, type: 'turn/start', time: 1, data: { turn: 6 } }]
- for (let seq = 2; seq <= 70; seq += 1) {
++ for (let seq = 2; seq <= 430; seq += 1) {
+ events.push({ seq, type: 'user/message', time: seq, data: { content: [{ type: 'text', text: `m${seq}` }], source: { kind: 'user' } } })
+ }
+ const rt = earlierParts([])
+ rt.ctx.sessionController.page = async ({ beforeSeq, maxMessages }) => {
+ let list = events.filter(event => !Number.isInteger(beforeSeq) || event.seq < beforeSeq)
+ const hasMore = list.length > maxMessages
+ if (hasMore) list = list.slice(-maxMessages)
+ return { records: list.map(event => ({ event })), hasMore }
+ }
+ rt.resolveAgent = async () => { throw Object.assign(new Error('Session unavailable'), { code: 'session/gone' }) }
+ const { items } = await rt.earlierPage('b2')
+ const first = items.find(item => item.kind !== 'divider')
+ assert.equal(first?.kind, 'user')
+ assert.equal(first?.turn, 6)
+})
+
test('each text block of a Bot message is an entry of its own, as each is a bubble of its own', async () => {
const rt = earlierParts([
{ type: 'assistant/message', seq: 1, time: 11, data: { turn: 1, message: { content: [{ type: 'text', text: 'First.' }, { type: 'tool-call', id: 'c1' }, { type: 'text', text: ' ' }, { type: 'text', text: 'Second.' }] } } },