dsh-sansheng-liubu/ds-bot/src/host/local-agents/adapter.js

651 lines
30 KiB
JavaScript

// The LlmAdapter that serves every local-agent route. A DS Bot Bot whose model
// is one of these routes answers through a local agent CLI instead of a model
// API: the loop, Sessions, tools and approvals are the ordinary ones; this
// adapter turns each request into a prompt for the CLI session the Session is
// mapped to, and the CLI's output back into stream chunks.
import { createHash } from 'node:crypto'
import { LlmAdapter, LlmError } from '@deepseek-ai/dsh-llm'
import { textOf } from '../text.js'
import { engineOf, cliMode } from './engines.js'
import { LoopbackMcp } from './mcp.js'
export const DEFAULT_CONTEXT_WINDOW = 200_000
// The replay window when a CLI session is new or its resume failed.
const REPLAY_MESSAGES = 12
const REPLAY_BYTES = 24 * 1024
const IDLE_CLOSE_MS = 10 * 60_000
const APPROVE_TOOL = 'approve_agent_action'
// A title request never reaches the CLI.
function titleChunk(text) {
const title = text.slice(0, 60)
return [
{ type: 'block-start', index: 0, blockType: 'text' },
{ type: 'text-delta', index: 0, text: title },
{ type: 'block-end', index: 0, block: { type: 'text', text: title } },
{ type: 'finish', reason: { kind: 'stop' } },
]
}
// A compaction request neither: a deterministic digest of the messages.
function digestChunks(messages) {
const lines = []
let used = 0
for (const message of messages ?? []) {
const text = textOf(message.content).replace(/\s+/g, ' ').trim()
if (text === '') continue
const line = `${message.role}: ${text.slice(0, 300)}`
if (used + line.length > 8 * 1024) break
lines.push(line)
used += line.length
}
const text = `[Earlier conversation, condensed]\n${lines.join('\n')}`
return [
{ type: 'block-start', index: 0, blockType: 'text' },
{ type: 'text-delta', index: 0, text },
{ type: 'block-end', index: 0, block: { type: 'text', text } },
{ type: 'finish', reason: { kind: 'stop' } },
]
}
// Marks the one retry of a turn whose saved Claude conversation was gone.
const RESUME_RETRIED = Symbol('resume retried')
export class LocalAgentAdapter extends LlmAdapter {
// deps: {rt, findExecutable, spawnEngine(kind,route,engine), record(sessionId),
// saveRecord, dropRecord, presetFor(sessionId), toolsFor(options), signInHint(route),
// usedModels(route)}
constructor(deps) {
super()
this.deps = deps
this.engines = new Map() // route -> engine driver
this.live = new Map() // sessionId -> live session
this.modelCache = new Map()
this.probes = new Map() // route -> the probe under way
this.disposed = false
}
providerInfo(route) {
const engine = engineOf(route, this.deps.customAgents())
return { id: route, name: engine?.name ?? route }
}
providerRetryPolicy() { return undefined }
imageRequestPricing() { return undefined }
engine(route) {
let driver = this.engines.get(route)
if (driver === undefined) {
const spec = engineOf(route, this.deps.customAgents())
if (spec === undefined) throw new LlmError(`Unknown local agent ${route}`, 'NO_ADAPTER')
driver = this.deps.spawnEngine(spec.kind, route, spec)
this.engines.set(route, driver)
}
return driver
}
// What DS Bot knows of a route without starting its CLI: the CLI's default, what a
// probe found, and what a Bot runs on. DSH and the catalog ask this for every route.
async listModels(route) {
if (engineOf(route, this.deps.customAgents()) === undefined) return []
const listed = [{ provider: route, id: 'default', name: 'CLI default' }, ...(this.modelCache.get(route) ?? [])]
const used = (this.deps.usedModels?.(route) ?? []).filter(id => !listed.some(model => model.id === id))
return [...listed, ...used.map(id => ({ provider: route, id, name: id }))]
}
// Asks one CLI what it serves, once. A failure is not kept, so the next look tries
// again. The process it took leaves unless a Session runs on it.
async probeModels(route) {
if (this.modelCache.has(route)) return this.listModels(route)
if (engineOf(route, this.deps.customAgents()) === undefined) return []
let probe = this.probes.get(route)
if (probe === undefined) {
probe = this.askModels(route).finally(() => this.probes.delete(route))
this.probes.set(route, probe)
}
await probe
return this.listModels(route)
}
async askModels(route) {
const engine = this.engine(route)
try {
const models = await engine.listModels({ cwd: this.deps.probeCwd(), mcp: undefined })
this.modelCache.set(route, (models ?? []).filter(model => model.id !== 'default')
.map(model => ({ provider: route, id: model.id, name: model.name ?? model.id, ...(model.reasoning ? { reasoning: model.reasoning } : {}) })))
} catch { /* the menu still has the CLI's default */ }
if (![...this.live.values()].some(other => other.engine === engine && !other.dead)) await engine.close?.().catch(() => {})
}
dropModelCache(route) {
if (route === undefined) this.modelCache.clear()
else this.modelCache.delete(route)
}
async resolveModel(route, model) {
const spec = engineOf(route, this.deps.customAgents())
const listed = (await this.listModels(route).catch(() => [])).find(entry => entry.id === model)
return {
provider: route,
id: model,
name: listed?.name ?? model,
inputModalities: ['text', 'image'],
context: { contextWindow: spec?.contextWindow ?? DEFAULT_CONTEXT_WINDOW },
// The thinking levels the engine advertises for this model, if any.
...(listed?.reasoning ? { reasoning: listed.reasoning } : {}),
}
}
// ---------------------------------------------------------------------------
// The live bridge for one DS Bot Session.
async liveFor(options) {
const sessionId = String(options.sessionId)
let live = this.live.get(sessionId)
const record = this.deps.record(sessionId)
const route = options.provider
if (live !== undefined && !live.dead && live.route === route) {
// An agent CLI can exit between the spawn and its first message (a failed
// sign-in, for one): the cached bridge is dead, so the next call starts a
// new process instead of writing into the one that is gone.
if (live.engineSession?.dead === true) {
this.rollbackUnread(live, sessionId)
live.engineSession = undefined
live.pumpToken = {}
// The queue belongs to the process that is gone: the retry starts clean
// instead of reading its exit as the new turn's failure.
live.events.length = 0
}
// A CLI takes its model when its session opens. Another model reopens the same
// CLI session as soon as no turn runs in it.
if (live.model === options.model || live.state !== 'idle') return live
await this.closeLive(live, { idle: true })
} else if (live !== undefined) await this.closeLive(live)
const spec = engineOf(route, this.deps.customAgents())
if (spec === undefined) throw new LlmError(`Unknown local agent ${route}`, 'LOCAL_AGENT_MISSING')
const engine = this.engine(route)
live = {
sessionId, route, spec, engine, dead: false,
record,
cliSessionId: record?.cliSessionId,
handed: record?.handedId,
promptHash: record?.promptHash,
engineSession: undefined,
mcp: undefined,
events: [],
waiters: [],
pending: new Map(), // dshCallId -> {name, mcpCallId?, reply?}
started: false,
// 'idle': no CLI turn. 'running': a prompt is in flight. 'suspended': the
// turn waits on a bridged tool call or a permission answer.
state: 'idle',
// Prompts queued while a turn runs (ACP speaks one prompt at a time);
// the drain sends the next one when the turn ends.
queue: [],
idle: undefined,
cwd: record?.cwd,
model: options.model,
}
live.push = (event) => {
clearTimeout(live.idle)
live.idle = setTimeout(() => void this.closeLive(live, { idle: true }), IDLE_CLOSE_MS)
live.idle.unref?.()
const waiter = live.waiters.shift()
if (waiter !== undefined) waiter(event)
else live.events.push(event)
}
live.next = () => (live.events.length > 0 ? Promise.resolve(live.events.shift()) : new Promise(resolve => live.waiters.push(resolve)))
this.live.set(sessionId, live)
return live
}
async closeLive(live, { idle = false } = {}) {
if (live.dead) return
live.dead = true
clearTimeout(live.idle)
this.live.delete(live.sessionId)
live.engine.forget?.(live.sessionId)
live.mcp?.close()
if (idle) {
// The CLI session survives on the agent side; the process leaves and the
// next prompt resumes it.
live.engineSession = undefined
live.started = false
}
for (const waiter of live.waiters.splice(0)) waiter({ type: 'done', reason: 'stop' })
const stillUsed = [...this.live.values()].some(other => other.engine === live.engine && !other.dead)
if (!stillUsed) await live.engine.close?.().catch(() => {})
}
// The turn under way ends: the CLI stops, and a call it waits on gets an answer.
stopTurn(live, reason) {
live.state = 'idle'
live.queue.length = 0
if (live.engineSession !== undefined) live.engine.cancel?.(live.engineSession)
live.mcp?.failAll(new Error(reason))
for (const pending of live.pending.values()) pending.resolve({ text: reason, isError: true })
live.pending.clear()
}
// The Session left this CLI: its part moved on. Its process leaves; the CLI session
// and its record stay, so opening that part again resumes it.
async closeSession(sessionId, reason = 'the conversation moved on') {
const live = this.live.get(String(sessionId))
if (live === undefined) return
this.stopTurn(live, reason)
await this.closeLive(live, { idle: true })
}
// A Claude CLI that died before `system/init` never read the prompt it was
// handed: roll the marker back in the live state and in the saved record, so a
// host that restarts before the next call still replays the input. ACP and
// Codex create their session before the prompt, so theirs was read.
// A resume that found its conversation gone also drops the id: the next start
// opens a new conversation and replays the history, instead of failing every
// turn on the same id.
rollbackUnread(live, sessionId) {
if (live.spec.kind !== 'claude') return
const session = live.engineSession
if (session?.dead !== true || session.cliSessionId !== undefined || session.rolledBack === true) return
session.rolledBack = true
if (session.resumeMissing === true) {
live.cliSessionId = undefined
live.handed = undefined
live.resumeLost = true
} else live.handed = live.handedBefore
this.deps.saveRecord(sessionId, { route: live.route, cliSessionId: live.cliSessionId, cwd: live.cwd, handedId: live.handed, promptHash: live.promptHash, model: live.model })
}
// The loopback MCP server for one live session; tools/call lands in its event queue.
// `tools` lists the current turn's tools; the server outlives the turn that
// started it, so tools/list reads the latest one.
async ensureMcp(live, tools) {
live.tools = tools
if (live.mcp !== undefined) return live.mcp
const mcp = new LoopbackMcp(() => live.tools(), ({ name, arguments: args, callId }) => {
const dshCallId = `dsbot-${callId}`
return new Promise((resolve) => {
live.pending.set(dshCallId, { name, mcpCallId: callId, resolve })
live.push({ type: 'call', name, args, dshCallId })
})
})
await mcp.listen()
live.mcp = mcp
return mcp
}
// ---------------------------------------------------------------------------
async *stream(options) {
if (this.disposed) throw new LlmError('the local agents adapter is disposed', 'NO_ADAPTER')
if (options.purpose === 'session-title') {
const first = (options.messages ?? []).find(message => message.role === 'user')
const title = (textOf(first?.content).split('\n').find(line => line.trim() !== '') ?? 'Chat').trim()
yield* titleChunk(title === '' ? 'Chat' : title)
return
}
if (options.purpose === 'compaction') {
yield* digestChunks(options.messages)
return
}
const sessionId = options.sessionId
if (sessionId === undefined) throw new LlmError('a local agent request needs a session', 'INVALID_REQUEST')
const live = await this.liveFor(options)
// What the request carries past the last handed message. When the marker is
// gone the CLI session is stale or new: it gets a replay instead of a delta.
const messages = options.messages ?? []
const at = live.handed === undefined ? -1 : messages.findIndex(message => message.id === live.handed)
const fresh = live.handed === undefined || at === -1
const delta = fresh ? [] : messages.slice(at + 1)
// Results of the calls the last step emitted answer the suspended CLI calls.
// A user message never resolves an approve_agent_action pending: only that
// tool's own result may. User text may answer a pending bridged MCP call
// whose DSH tool concluded the turn (a question-type card).
for (const message of delta) {
if (message.role !== 'tool') continue
const pending = live.pending.get(message.toolCallId)
if (pending === undefined) continue
live.pending.delete(message.toolCallId)
pending.resolve({ text: textOf(message.content) || (message.isError ? 'the call failed' : ''), isError: message.isError === true })
}
// The loop's runtime-context user messages are context, not input: they
// fold into the next prompt or steer, never start a prompt on their own.
const contextText = delta
.filter(message => message.role === 'user' && message.source?.kind === 'runtime-context')
.map(message => textOf(message.content)).filter(text => text !== '').join('\n')
const users = delta.filter(message => message.role === 'user' && message.source?.kind !== 'runtime-context')
// The first open bridged call that is not an approval may take the user's
// next message as its answer; the rest of the input is new.
const openCall = [...live.pending.entries()].find(([, entry]) => entry.name !== APPROVE_TOOL)
const remaining = []
let answered = openCall === undefined
for (const message of users) {
if (!answered && openCall !== undefined) {
const [id, pending] = openCall
live.pending.delete(id)
pending.resolve({ text: textOf(message.content) })
answered = true
} else {
remaining.push(message)
}
}
const system = messages.filter(message => message.role === 'system').map(message => textOf(message.content)).join('\n').trim()
const promptHash = system === '' ? undefined : createHash('sha256').update(system).digest('hex')
const mcp = await this.ensureMcp(live, () => this.deps.toolsFor(options))
const cwd = live.cwd ?? await this.deps.cwdFor(sessionId)
live.cwd = cwd
const preset = this.deps.presetFor(sessionId)
const mode = cliMode(live.spec.kind, preset)
const instructions = system === '' ? undefined : system
const freshCli = live.cliSessionId === undefined
if (live.engineSession === undefined) {
const openArgs = {
cwd,
mcp,
resumeId: live.cliSessionId,
mode,
preset,
model: options.model,
// Codex carries the team instructions as developer config on a new
// thread; Claude gets them appended at spawn; ACP reads them in the
// first prompt below.
instructions: live.spec.kind === 'codex' && freshCli ? instructions : undefined,
system: live.spec.kind === 'claude' ? instructions : undefined,
}
live.engineSession = await live.engine.open(sessionId, openArgs)
.catch(error => { throw toLlmError(error, live) })
// A resumed CLI reports its id only with `system/init`: keep the saved one
// in the meantime, or a resume that fails would erase it.
const reportedId = live.engineSession.acpSessionId ?? live.engineSession.threadId ?? live.engineSession.cliSessionId
if (reportedId !== undefined) live.cliSessionId = reportedId
live.started = true
// The session's events feed this Session's queue: a call from any engine
// kind reaches drain() through live.next().
const session = live.engineSession
const token = live.pumpToken = {}
void (async () => {
while (live.pumpToken === token && !live.dead) {
const event = await session.next()
if (live.pumpToken === token && !live.dead) live.push(event)
}
})()
if (live.spec.kind !== 'acp' && instructions !== undefined) live.promptHash = promptHash
this.deps.saveRecord(sessionId, { route: live.route, cliSessionId: live.cliSessionId, cwd, handedId: live.handed, promptHash: live.promptHash ?? promptHash, model: options.model })
// Claude reports its session id with `system/init`, after start() resolved:
// the record above has no id yet, so persist it when it lands or the next
// host has nothing to resume and the conversation starts over.
const pendingId = session.whenSessionId?.()
if (pendingId !== undefined) {
void pendingId.then((id) => {
if (id === undefined || live.dead) return
live.cliSessionId = id
this.deps.saveRecord(sessionId, { route: live.route, cliSessionId: id, cwd, handedId: live.handed, promptHash: live.promptHash ?? promptHash, model: options.model })
})
}
}
let promptText = fresh ? renderReplay(messages, system)
: [contextText, ...remaining.map(message => textOf(message.content))].filter(text => text !== '').join('\n\n')
let sentInstructions = live.spec.kind !== 'acp' && freshCli && instructions !== undefined
// A new CLI session gets its instructions in the open args or the replay;
// the "updated" line is only for a session that saw older ones.
if (instructions !== undefined && !freshCli && live.promptHash !== promptHash) {
const updated = `Updated team instructions (replace earlier ones):\n\n${instructions}`
if (live.spec.kind === 'codex') {
await live.engine.instruct?.(live.engineSession, updated)
sentInstructions = true
} else if (promptText !== '' || live.spec.kind === 'acp' || live.spec.kind === 'claude') {
promptText = `${updated}\n\n${promptText}`
sentInstructions = true
}
}
if (promptText !== '') {
this.sendInput(live, promptText, options.signal, options.reasoningEffort)
if (sentInstructions) live.promptHash = promptHash
// ACP only counts instructions once they reach the agent with a prompt.
if (live.spec.kind === 'acp' && (freshCli || sentInstructions)) live.promptHash = promptHash
}
if (live.spec.kind === 'acp' && freshCli && promptText === '' && instructions !== undefined) {
this.sendInput(live, `Follow these instructions from the user's team for everything you do here. They sit on top of your own; when they conflict, these win.\n\n${instructions}`, options.signal, options.reasoningEffort)
live.promptHash = promptHash
}
// The last DSH message is handed now; a later call sends only what follows.
// The marker before it is kept: a start that fails before the CLI reads
// anything must not count that message as delivered.
const last = messages.at(-1)
if (last !== undefined) {
live.handedBefore = live.handed
live.handed = last.id
this.deps.saveRecord(sessionId, { route: live.route, cliSessionId: live.cliSessionId, cwd, handedId: live.handed, promptHash: live.promptHash ?? promptHash, model: options.model })
}
try {
yield* this.drain(live, options)
} catch (error) {
// The caller sees the failure now: a start that died before reading its
// prompt must not count as delivered, in case the host restarts next.
this.rollbackUnread(live, sessionId)
// The saved conversation is gone: start over in a new one with the
// history, once, so the user sees the answer instead of this failure.
if (live.resumeLost === true && options[RESUME_RETRIED] !== true) {
live.resumeLost = false
yield* this.stream({ ...options, [RESUME_RETRIED]: true })
return
}
throw error
}
}
// Input for the CLI: a fresh prompt while it is idle; while a turn runs or
// waits on a bridged call, steering for Codex and Claude, or a queued prompt
// for ACP (it speaks one prompt at a time; the drain sends it when the turn
// ends, inside the same stream). The prompt request itself stays open for
// the whole turn (ACP session/prompt ends when the agent's turn does), so it
// is sent but not awaited; a send failure lands in the queue as an error.
sendInput(live, text, signal, effort) {
if (live.state !== 'idle') {
if (live.spec.kind === 'acp') { live.queue.push(text); return }
try {
Promise.resolve(live.engine.steer?.(live.engineSession, text))
.catch(error => live.push({ type: 'error', error }))
} catch (error) {
live.push({ type: 'error', error })
}
return
}
live.state = 'running'
try {
Promise.resolve(live.engine.prompt(live.engineSession, [{ type: 'text', text }], { signal, effort }))
.catch(error => live.push({ type: 'error', error }))
} catch (error) {
live.push({ type: 'error', error })
}
}
// Consume the CLI's events until the turn ends or a bridged call suspends it.
async *drain(live, options) {
let index = 0
let textBuf = ''
let textIndex = -1
let thinkBuf = ''
let thinkIndex = -1
// Open text and reasoning stay open in parallel; each closes when it has to.
const closeBlocks = function* () {
if (textIndex !== -1) { yield { type: 'block-end', index: textIndex, block: { type: 'text', text: textBuf } }; textIndex = -1; textBuf = '' }
if (thinkIndex !== -1) { yield { type: 'block-end', index: thinkIndex, block: { type: 'reasoning', text: thinkBuf } }; thinkIndex = -1; thinkBuf = '' }
}
const emitCalls = (calls) => {
const chunks = []
calls.forEach((call, offset) => {
const at = index + offset
chunks.push(
{ type: 'block-start', index: at, blockType: 'tool-call' },
{ type: 'tool-call-delta', index: at, id: call.dshCallId, name: call.name, argumentsDelta: JSON.stringify(call.args ?? {}) },
{ type: 'block-end', index: at, block: { type: 'tool-call', id: call.dshCallId, name: call.name, arguments: JSON.stringify(call.args ?? {}) } },
)
})
index += calls.length
return chunks
}
// One abort promise for the whole drain: the earlier version added a
// listener per event and never removed it.
let abortReject
const abortPromise = new Promise((_, reject) => { abortReject = reject })
const onAbort = () => abortReject(options.signal?.reason ?? new Error('aborted'))
if (options.signal?.aborted) onAbort()
else options.signal?.addEventListener('abort', onAbort)
try {
for (;;) {
const event = await Promise.race([live.next(), abortPromise]).catch(error => ({ type: 'abort', error }))
if (event.type === 'abort') {
this.stopTurn(live, 'the turn was stopped')
yield { type: 'finish', reason: { kind: 'aborted', failure: { code: 'ABORTED', message: 'the turn was stopped' } } }
return
}
switch (event.type) {
case 'text': {
if (textIndex === -1) {
if (thinkIndex !== -1) { yield { type: 'block-end', index: thinkIndex, block: { type: 'reasoning', text: thinkBuf } }; thinkIndex = -1; thinkBuf = '' }
yield { type: 'block-start', index: index++, blockType: 'text' }
textIndex = index - 1
}
textBuf += event.text
yield { type: 'text-delta', index: textIndex, text: event.text }
break
}
case 'thought':
case 'activity': {
// An activity line stands on its own line of the reasoning, which is
// how the chat tells it from the thought around it.
const text = event.type === 'activity' ? `${thinkBuf === '' || thinkBuf.endsWith('\n') ? '' : '\n'}${event.text}\n` : event.text
if (thinkIndex === -1) {
if (textIndex !== -1) { yield { type: 'block-end', index: textIndex, block: { type: 'text', text: textBuf } }; textIndex = -1; textBuf = '' }
yield { type: 'block-start', index: index++, blockType: 'reasoning' }
thinkIndex = index - 1
}
thinkBuf += text
yield { type: 'reasoning-delta', index: thinkIndex, text }
break
}
case 'usage': yield { type: 'usage', usage: event.usage }; break
case 'call': {
yield* closeBlocks()
live.state = 'suspended'
// A team tool the CLI invoked over the loopback MCP server.
for (const chunk of emitCalls([{ name: event.name, args: event.args, dshCallId: event.dshCallId }])) yield chunk
yield { type: 'finish', reason: { kind: 'tool-calls' } }
return
}
case 'permission': {
// The preset answers what it already decides, also on an agent with no
// matching mode of its own: full access allows, read-only refuses a change.
const answer = presetAnswer(this.deps.presetFor(live.sessionId), event)
if (answer !== undefined) { event.reply(answer); break }
yield* closeBlocks()
live.state = 'suspended'
// The CLI's own permission prompt, bridged as an approval tool call.
const call = { name: APPROVE_TOOL, args: { action: event.action, ...(event.detail ? { detail: event.detail } : {}) }, dshCallId: event.id }
live.pending.set(event.id, { name: APPROVE_TOOL, resolve: (result) => event.reply(pickAllowOption(event.options, result)) })
for (const chunk of emitCalls([call])) yield chunk
yield { type: 'finish', reason: { kind: 'tool-calls' } }
return
}
case 'done': {
yield* closeBlocks()
if (event.usage !== undefined) yield { type: 'usage', usage: event.usage }
live.state = 'idle'
// Input queued while this turn ran goes out as the next prompt
// inside the same drain (ACP takes one prompt at a time).
const next = live.queue.shift()
if (next !== undefined) {
this.sendInput(live, next, options.signal, options.reasoningEffort)
break
}
yield { type: 'finish', reason: { kind: 'stop' } }
return
}
case 'error': {
live.state = 'idle'
throw toLlmError(event.error, live)
}
default: break
}
}
} finally {
options.signal?.removeEventListener('abort', onAbort)
}
}
async dispose() {
this.disposed = true
for (const live of Array.from(this.live.values())) await this.closeLive(live)
for (const engine of Array.from(this.engines.values())) await engine.close?.().catch(() => {})
this.engines.clear()
}
}
// The result DSH gives approve_agent_action decides the agent's option: only
// the structured {"decision":"allow"} the tool returns on approval counts;
// free text, a parse failure, an error or a denial rejects the action.
function pickAllowOption(options, result) {
if (result.isError === true) return null
let decision
try { decision = JSON.parse(result.text ?? '')?.decision } catch { decision = undefined }
if (decision !== 'allow') return null
return optionOf(options, 'allow') ?? null
}
// The agent's one-time option of a kind ('allow' or 'reject'), else any of it.
// A one-time allow leaves the agent's own saved rules as they were.
const optionOf = (options, kind) => ((options ?? []).find(entry => entry.kind === `${kind}_once`)
?? (options ?? []).find(entry => (entry.kind ?? '').startsWith(kind)))?.optionId
// What the preset answers without asking: an option id, null to refuse, or
// undefined to ask the user.
function presetAnswer(preset, event) {
if (preset === 'danger-full-access') return optionOf(event.options, 'allow')
if (preset === 'read-only' && event.changes === true) return optionOf(event.options, 'reject') ?? null
return undefined
}
// The replay a fresh CLI session stands up on: the system prompt, then the
// recent messages rendered as text, newest first, always with the latest input
// and the handoff a new part opens with, both word for word.
function renderReplay(messages, system) {
const picked = []
let used = 0
const body = (messages ?? []).filter(message => message.role !== 'system')
const latest = body.at(-1)
let full = false
for (const message of [...body].reverse()) {
const whole = message === latest || message.source?.handoff === true
const text = textOf(message.content)
const line = `${message.role === 'assistant' ? 'You' : message.role === 'tool' ? `Tool result (${message.toolCallId ?? 'call'})` : 'User'}: ${whole ? text : text.slice(0, 2_000)}`
if (whole) { picked.unshift(line); used += line.length; continue }
full ||= picked.length >= REPLAY_MESSAGES || used + line.length > REPLAY_BYTES
if (full) continue
picked.unshift(line)
used += line.length
}
if (picked.length === 0) return ''
const head = system === '' ? '' : `The team instructions for this conversation:\n${system}\n\n`
return `${head}The conversation so far (oldest first):\n\n${picked.join('\n\n')}`
}
// Process exits, missing CLIs, quota and sign-in failures get typed codes so DS
// Bot's repair card can act on them.
function toLlmError(error, live) {
if (error instanceof LlmError) return error
const text = String(error?.message ?? error)
const code = error?.code === 'NO_ADAPTER' ? 'LOCAL_AGENT_MISSING'
: /not signed in|not logged in|login required|unauthorized|authentication/i.test(text) ? 'LOCAL_AGENT_SIGNIN'
: /quota|rate.?limit|usage limit|exceeded/i.test(text) ? 'LOCAL_AGENT_QUOTA'
: /exited|spawn|ENOENT/i.test(text) ? 'LOCAL_AGENT_EXIT'
: error?.code ?? 'LOCAL_AGENT_ERROR'
const hint = code === 'LOCAL_AGENT_SIGNIN' ? ` Sign in with: ${live?.spec?.signIn ?? `${live?.spec?.command ?? 'the CLI'} login`}.` : ''
return new LlmError(`${text}${hint}`, code, error?.status === undefined ? {} : { status: error.status })
}