A team of long-lived bots for DeepSeek Harness, with main bots, bot-to-bot messages and group chats.
import assert from 'node:assert/strict'
import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
import { hostname, tmpdir } from 'node:os'
import { join } from 'node:path'
import { test } from 'node:test'
import { createRuntime } from '../index.js'
import { trimToolBoundary } from '../src/host/btw.js'
import { fakeContext } from './fake-ctx.js'
const user = text => ({ role: 'user', content: [{ type: 'text', text }] })
const assistant = (...blocks) => ({ role: 'assistant', content: blocks })
const call = (id, name = 'read') => ({ type: 'tool-call', id, name, arguments: '{}' })
const result = (id, text = 'ok') => ({ role: 'tool', toolCallId: id, content: [{ type: 'text', text }] })
const team = (extra = {}) => ({
version: 1,
mainBotIds: ['b1'],
whaleStored: true,
revision: 3,
bots: {
b1: {
id: 'b1', sessionId: 's-now', name: 'Chief', capabilities: [], color: 'deepseek', createdAt: 1,
segments: [{ sessionId: 's-old', endedAt: 1 }],
},
},
rooms: {
r1: {
id: 'r1', named: true, name: 'Launch', members: ['b1'], admin: 'b1', mode: 'everyone', notice: '',
sessions: { b1: 'g-now' }, segments: { b1: [{ sessionId: 'g-old', endedAt: 1 }] },
},
},
agents: {},
capabilities: { items: {} },
exchanges: [],
exchangeTurns: {},
works: {},
questions: {},
views: {},
prefs: {},
...extra,
})
function makeSession(id, { messages, header, seq = 4, toolHistory, events }) {
// The anchor fold reads this log. `eventAt` is closed to new callers.
const history = events ?? []
const session = {
id,
seq,
events: events ?? [{ seq: 1, type: 'user/message' }],
writes: 0,
derived: 0,
messages,
header,
history: toolHistory,
inheritedEventCount: 0,
deriveMessages() {
session.derived += 1
return session.messages.map(message => ({
...message,
content: Array.isArray(message.content) ? message.content.map(block => ({ ...block })) : message.content,
}))
},
toolHistory() { return session.history },
requestHeader() { return session.header },
snapshotEvents() { return history },
eventAt() { throw new Error('eventAt is closed to new callers') },
append() { session.writes += 1; session.events.push({ type: 'append' }) },
followup() { session.writes += 1; session.events.push({ type: 'followup' }) },
}
return session
}
// The same register / stateOf face as ctx.sessionProjections: fold the unit
// the host registers over snapshotEvents().
function projectionRegistry(ctx) {
const units = new Map()
return {
register(definition) {
ctx.effect(() => {
units.set(definition.key, definition)
return () => { units.delete(definition.key) }
}, 'sessionProjections.register()')
},
stateOf(session, key) {
const definition = units.get(key)
if (definition === undefined) return undefined
let state = definition.init(session.header, session.inheritedEventCount)
for (const event of session.snapshotEvents()) state = definition.apply(state, event)
return state
},
}
}
// The ask path is gone; saved cards stay readable until deleted. `btw` seeds
// card files: { botId: { partId: [cards] } }.
async function setup({ state = team(), messages, seq = 4, events, foreignLock = false, btw = {} } = {}) {
const home = mkdtempSync(join(tmpdir(), 'dsb-btw-'))
writeFileSync(join(home, 'state.json'), JSON.stringify(state))
for (const [botId, parts] of Object.entries(btw)) {
for (const [partId, list] of Object.entries(parts)) {
mkdirSync(join(home, 'btw', botId), { recursive: true })
writeFileSync(join(home, 'btw', botId, `${partId}.json`), JSON.stringify(list))
}
}
if (foreignLock) writeFileSync(join(home, 'state.lock'), JSON.stringify({ pid: process.ppid, host: hostname(), token: 'other' }))
const header = {
config: { provider: 'deepseek', model: 'aside-model', reasoningEffort: 'high', maxTokens: 8000, temperature: 0.2, stop: ['END'] },
tools: [{ name: 'read' }, { name: 'pwsh' }],
}
const toolHistory = [{ name: 'read' }]
const session = makeSession('s-now', { messages: messages ?? [user('Look at the file')], header, seq, toolHistory, events })
const sessions = new Map([[session.id, session]])
const requests = []
const services = {}
const ctx = fakeContext({ services })
services.sessionProjections = projectionRegistry(ctx)
ctx.llm = {
listProviders: () => [],
listModels: async () => [],
resolveModelInfo: async () => ({ reasoning: { efforts: [] } }),
async* stream(options) {
requests.push(options)
yield { type: 'text-delta', index: 0, text: 'Because of the snapshot.' }
yield { type: 'finish', reason: { kind: 'stop' } }
},
}
ctx.sessionController = {
resolveAgent: async (sessionId) => {
const found = sessions.get(sessionId)
if (found === undefined) throw new Error(`no session ${sessionId}`)
return { agent: { id: sessionId, session: found } }
},
list: async () => ({ items: [] }),
projections: async () => null,
page: async () => ({ records: [], hasMore: false }),
selectModel: async () => {},
prompt: async () => {},
}
ctx.sessions = { flush: async () => {}, messageProjections: [] }
ctx.workspaceRegistry = { archiveSession: async () => {} }
ctx.sessionTitle = { rename: async () => {} }
let route
const register = ctx.connection.fetch.register
ctx.connection.fetch.register = (options) => { route = options; return register(options) }
const rt = createRuntime(ctx, { home, github: false, diagnosticsFile: false })
let notices = 0
const saved = rt.stateSaved
rt.stateSaved = () => { notices += 1; saved?.() }
await rt.load()
const callEndpoint = async (endpoint, payload) => {
const response = await route.fetch(new Request('http://localhost/api/bot', { method: 'POST', body: JSON.stringify({ endpoint, payload }) }))
return response.json()
}
const stopRuntime = async () => {
await ctx.dispose()
rmSync(home, { recursive: true, force: true, maxRetries: 5 })
}
return { home, ctx, rt, session, sessions, header, toolHistory, requests, call: callEndpoint, notices: () => notices, stop: stopRuntime }
}
const cardsOf = rt => rt.btwView?.().b1 ?? []
const cardsFile = (home, botId = 'b1', partId = 's-now') => JSON.parse(readFileSync(join(home, 'btw', botId, `${partId}.json`), 'utf8'))
test('a snapshot drops an unfinished tool batch and keeps a finished one', () => {
const pending = [user('Look'), assistant({ type: 'text', text: 'Reading.' }, call('c1'))]
assert.deepEqual(trimToolBoundary(pending), [pending[0]])
const partial = [user('Look'), assistant(call('a'), call('b')), result('a', 'half')]
assert.deepEqual(trimToolBoundary(partial), [partial[0]])
const balanced = [user('Look'), assistant(call('a'), call('b')), result('a'), result('b')]
assert.equal(trimToolBoundary(balanced), balanced)
const plain = [user('Look'), assistant({ type: 'text', text: 'Done.' })]
assert.equal(trimToolBoundary(plain), plain)
const followed = [user('Look'), assistant(call('c1')), user('And now?')]
assert.equal(trimToolBoundary(followed), followed)
assert.deepEqual(trimToolBoundary([]), [])
})
test('a saved card rides the current part\'s view, whole and read-only', async (t) => {
const question = `${'q'.repeat(2000)}END-OF-QUESTION`
const answer = `${'a'.repeat(2000)}END-OF-ANSWER`
const env = await setup({
btw: {
b1: {
's-now': [
{ id: 'first', botId: 'b1', partId: 's-now', atSeq: 3, anchorSeq: null, turn: null, question, answer, status: 'done', createdAt: 10, finishedAt: 11 },
{ id: 'second', botId: 'b1', partId: 's-now', atSeq: 2, anchorSeq: null, turn: null, question: 'Earlier?', answer: 'Yes.', status: 'done', createdAt: 9, finishedAt: 10 },
],
},
},
})
t.after(() => env.stop())
const cards = cardsOf(env.rt)
assert.equal(cards.length, 2)
assert.equal(cards[0].id, 'first')
assert.equal(cards[0].question, question)
assert.equal(cards[0].answer, answer)
const file = cardsFile(env.home)
assert.equal(file.length, 2)
const saved = JSON.parse(readFileSync(join(env.home, 'state.json'), 'utf8'))
assert.equal('btwCards' in saved, false)
const view = await env.call('state', {})
assert.equal(view.ok, true, view.error?.message)
assert.equal(view.value.btwCards.b1.length, 2)
assert.equal(view.value.btwCards.b1[0].id, 'first')
// Read-only: no model call, no Session write, no state revision.
assert.equal(env.requests.length, 0)
assert.equal(env.session.writes, 0)
assert.equal(saved.revision, 3)
})
test('a user deletes saved cards from current and earlier parts', async (t) => {
const env = await setup({
btw: {
b1: {
's-now': [
{ id: 'first', botId: 'b1', partId: 's-now', atSeq: 3, question: 'Now?', answer: 'Yes.', status: 'done', createdAt: 10, finishedAt: 11 },
{ id: 'second', botId: 'b1', partId: 's-now', atSeq: 2, question: 'Earlier?', answer: 'Yes.', status: 'done', createdAt: 9, finishedAt: 10 },
],
's-old': [{ id: 'old', botId: 'b1', partId: 's-old', atSeq: 1, question: 'Before?', answer: 'Yes.', status: 'done', createdAt: 5, finishedAt: 6 }],
},
},
})
t.after(() => env.stop())
const revision = env.rt.state.revision
const deleted = await env.call('btw-delete', { sessionId: 's-now', cardId: 'first' })
assert.deepEqual(deleted, { ok: true, value: { deleted: true } })
assert.deepEqual(cardsOf(env.rt).map(card => card.id), ['second'])
assert.deepEqual(cardsFile(env.home).map(card => card.id), ['second'])
assert.equal(env.rt.state.revision, revision + 1)
const view = await env.call('state', { since: revision })
assert.equal(view.ok, true)
assert.equal(view.value.unchanged, undefined)
assert.deepEqual(view.value.btwCards.b1.map(card => card.id), ['second'])
const wrongPart = await env.call('btw-delete', { sessionId: 's-old', cardId: 'second' })
assert.deepEqual(wrongPart, { ok: true, value: { deleted: false } })
assert.deepEqual(cardsFile(env.home).map(card => card.id), ['second'])
assert.equal(env.rt.state.revision, revision + 1)
const old = await env.call('btw-delete', { sessionId: 's-old', cardId: 'old' })
assert.deepEqual(old, { ok: true, value: { deleted: true } })
assert.deepEqual(cardsFile(env.home, 'b1', 's-old'), [])
assert.deepEqual(cardsOf(env.rt).map(card => card.id), ['second'])
assert.equal(env.rt.state.revision, revision + 2)
const again = await env.call('btw-delete', { sessionId: 's-now', cardId: 'first' })
assert.deepEqual(again, { ok: true, value: { deleted: false } })
assert.equal(env.rt.state.revision, revision + 2)
const invalid = await env.call('btw-delete', { sessionId: 's-now' })
assert.equal(invalid.ok, false)
assert.equal(invalid.error.code, 'bot/invalid')
assert.equal(env.requests.length, 0)
assert.equal(env.session.writes, 0)
})
test('concurrent deletes in one part keep both removals', async (t) => {
const card = (id, at) => ({ id, botId: 'b1', partId: 's-now', atSeq: at, question: `${id}?`, answer: 'Yes.', status: 'done', createdAt: at, finishedAt: at + 1 })
const env = await setup({ btw: { b1: { 's-now': [card('a', 1), card('b', 2), card('c', 3)] } } })
t.after(() => env.stop())
const [a, b] = await Promise.all([
env.call('btw-delete', { sessionId: 's-now', cardId: 'a' }),
env.call('btw-delete', { sessionId: 's-now', cardId: 'b' }),
])
assert.deepEqual(a, { ok: true, value: { deleted: true } })
assert.deepEqual(b, { ok: true, value: { deleted: true } })
assert.deepEqual(cardsOf(env.rt).map(item => item.id), ['c'])
assert.deepEqual(cardsFile(env.home).map(item => item.id), ['c'])
})
test('a restart marks an aside that was still answering as failed', async (t) => {
const env = await setup({
btw: {
b1: {
's-now': [
{ id: 'live', botId: 'b1', partId: 's-now', atSeq: 2, question: 'Still going?', answer: '', status: 'answering', createdAt: 10 },
{ id: 'old', botId: 'b1', partId: 's-now', atSeq: 1, question: 'Earlier?', answer: 'Yes.', status: 'done', createdAt: 9, finishedAt: 11 },
],
},
},
})
t.after(() => env.stop())
const [live, old] = cardsOf(env.rt)
assert.equal(live.status, 'failed')
assert.equal(live.error, 'DS Bot restarted before this answer finished.')
assert.equal(typeof live.finishedAt, 'number')
assert.equal(live.question, 'Still going?')
assert.equal(old.status, 'done')
assert.equal(old.answer, 'Yes.')
assert.equal(old.finishedAt, 11)
const file = cardsFile(env.home)
assert.equal(file[0].status, 'failed')
assert.equal(file[0].error, 'DS Bot restarted before this answer finished.')
assert.equal(file[1].status, 'done')
const saved = JSON.parse(readFileSync(join(env.home, 'state.json'), 'utf8'))
assert.equal('btwCards' in saved, false)
assert.equal(saved.revision, 3)
})
test('a second host does not fail an aside the writer is still answering', async (t) => {
const env = await setup({
foreignLock: true,
btw: {
b1: {
's-now': [
{ id: 'live', botId: 'b1', partId: 's-now', atSeq: 2, question: 'Still going?', answer: '', status: 'answering', createdAt: 10 },
{ id: 'old', botId: 'b1', partId: 's-now', atSeq: 1, question: 'Earlier?', answer: 'Yes.', status: 'done', createdAt: 9, finishedAt: 11 },
],
},
},
})
t.after(() => env.stop())
assert.equal(typeof env.rt.readOnly(), 'string')
const [live, old] = cardsOf(env.rt)
assert.equal(live.status, 'answering')
assert.equal(live.error, undefined)
assert.equal(live.finishedAt, undefined)
assert.equal(old.status, 'done')
assert.equal(old.answer, 'Yes.')
const file = cardsFile(env.home)
assert.equal(file[0].status, 'answering')
assert.equal(file[1].status, 'done')
const saved = JSON.parse(readFileSync(join(env.home, 'state.json'), 'utf8'))
assert.equal('btwCards' in saved, false)
assert.equal(saved.revision, 3)
assert.equal(env.rt.state.revision, 3)
assert.equal(env.notices(), 0)
const deleted = await env.call('btw-delete', { sessionId: 's-now', cardId: 'old' })
assert.equal(deleted.ok, false)
assert.equal(deleted.error.code, 'bot/read-only')
assert.equal(cardsFile(env.home).length, 2)
})
test('deleting a Bot removes its card files', async (t) => {
const state = team()
state.bots.b2 = { id: 'b2', sessionId: 's-b2', name: 'Side', capabilities: [], color: 'deepseek', createdAt: 2 }
const env = await setup({
state,
btw: {
b2: {
's-b2': [{ id: 'gone', botId: 'b2', partId: 's-b2', atSeq: 1, question: 'Old?', answer: 'Yes.', status: 'done', createdAt: 5, finishedAt: 6 }],
},
},
})
t.after(() => env.stop())
assert.equal(existsSync(join(env.home, 'btw', 'b2')), true)
await env.rt.deleteBot('b2')
assert.equal(env.rt.botOf('b2'), undefined)
assert.equal(env.rt.btwView().b2, undefined)
assert.equal(existsSync(join(env.home, 'btw', 'b2')), false)
const saved = JSON.parse(readFileSync(join(env.home, 'state.json'), 'utf8'))
assert.equal(saved.bots.b2, undefined)
assert.equal('btwCards' in saved, false)
assert.equal(saved.bots.b1.id, 'b1')
})
test('the team view carries only the current part\'s cards', async (t) => {
const env = await setup({
btw: {
b1: {
's-now': [{ id: 'here', botId: 'b1', partId: 's-now', atSeq: 2, question: 'In the new part?', answer: 'New.', status: 'done', createdAt: 7, finishedAt: 8 }],
's-old': [{ id: 'gone', botId: 'b1', partId: 's-old', atSeq: 1, question: 'From the old part?', answer: 'Old.', status: 'done', createdAt: 5, finishedAt: 6 }],
},
},
})
t.after(() => env.stop())
const cards = cardsOf(env.rt)
assert.equal(cards.length, 1)
assert.equal(cards[0].partId, 's-now')
const view = await env.call('state', {})
assert.equal(view.ok, true, view.error?.message)
assert.equal(view.value.btwCards.b1.length, 1)
assert.equal(view.value.btwCards.b1[0].partId, 's-now')
assert.equal(view.value.btwCards.b1.some(card => card.id === 'gone'), false)
})
test('an earlier part page carries that part\'s cards, read from its file', async (t) => {
const old = [
{ id: 'there', botId: 'b1', partId: 's-old', atSeq: 1, question: 'From the old part?', answer: 'Old.', status: 'done', createdAt: 5, finishedAt: 6 },
{ id: 'left', botId: 'b1', partId: 's-old', atSeq: 2, question: 'Never done?', answer: '', status: 'answering', createdAt: 7 },
]
const env = await setup({ btw: { b1: { 's-old': old } } })
t.after(() => env.stop())
env.sessions.set('s-old', makeSession('s-old', { messages: [user('Old work')], header: env.header, seq: 2, toolHistory: [] }))
const view = await env.call('state', {})
assert.equal(view.value.btwCards.b1, undefined)
const page = await env.call('earlier', { sessionId: 's-now' })
assert.equal(page.ok, true, page.error?.message)
assert.equal(page.value.btw.length, 2)
assert.equal(page.value.btw[0].id, 'there')
// The owning host's lazy read still records the restart this file kept.
assert.equal(page.value.btw[1].status, 'failed')
assert.equal(page.value.btw[1].error, 'DS Bot restarted before this answer finished.')
const file = cardsFile(env.home, 'b1', 's-old')
assert.equal(file[1].status, 'failed')
})