Skip to content

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

2.3 KB
Raw Blame
// The exact thinking time of a Turn, read from the timed model stream DSH keeps in
// each assistant/message event: for one step, its last reasoning chunk's time minus
// its first one's, summed over the turn. assistant/attempt events are skipped on
// purpose — a failed or retried attempt's thinking never reached the reply.
import { HISTORY_TIMEOUT_MS } from './constants.js'

export function thinkingMs(events, turn) {
  let total = 0
  let timed = false
  for (const event of events) {
    if (event.type !== 'assistant/message' || event.data.turn !== turn) continue
    const span = streamReasoningMs(event.data.stream)
    if (span === undefined) continue
    timed = true
    total += span
  }
  return timed ? total : undefined
}

// One stream's reasoning span. A reasoning-chunks record packs its member times as
// the first time plus the gaps to each next member, so its last member lands at
// time0 + sum(dt).
const streamReasoningMs = (stream) => {
  let first
  let last
  for (const record of stream ?? []) {
    if (record.type !== 'reasoning-chunks' || record.texts.length === 0) continue
    const end = record.dt.reduce((time, gap) => time + gap, record.time0)
    if (first === undefined || record.time0 < first) first = record.time0
    if (last === undefined || end > last) last = end
  }
  return first === undefined ? undefined : last - first
}

export function install(rt) {
  // A closed turn's events do not change; cache its answer once turn/end exists.
  const settled = new Map()
  rt.thinkingOf = async (sessionId, turn) => {
    const key = `${sessionId}:${turn}`
    if (settled.has(key)) return settled.get(key)
    const events = []
    // Newest first; events older than the turn close the read.
    for await (const event of rt.eventsBackwards(sessionId, AbortSignal.timeout(HISTORY_TIMEOUT_MS))) {
      events.push(event)
      if (typeof event.data?.turn === 'number' && event.data.turn < turn) break
    }
    // The read went through every newer turn whole, so each closed one is answered too.
    for (const event of events) {
      if (event.type === 'turn/end' && typeof event.data?.turn === 'number' && event.data.turn >= turn) {
        settled.set(`${sessionId}:${event.data.turn}`, thinkingMs(events, event.data.turn))
      }
    }
    return settled.has(key) ? settled.get(key) : thinkingMs(events, turn)
  }
}