picocode-core 0.9.190 → 0.9.192
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/package.json +2 -2
- package/src/catalog-snapshot.json +1 -1
- package/src/catalog.js +2 -1
- package/src/codex-models.js +3 -3
- package/src/controller.js +245 -35
- package/src/derive.js +81 -4
- package/src/export.js +3 -0
- package/src/keys.js +1 -0
- package/src/models.js +2 -1
- package/src/openrouter-models.js +82 -0
- package/src/peers.js +289 -0
- package/src/session.js +15 -7
- package/src/tools/index.js +20 -1
package/src/catalog.js
CHANGED
|
@@ -36,7 +36,8 @@ export async function refreshCatalog({ fetcher = fetch } = {}) {
|
|
|
36
36
|
return providers
|
|
37
37
|
}
|
|
38
38
|
|
|
39
|
-
export async function loadCatalog({ fetcher = fetch } = {}) {
|
|
39
|
+
export async function loadCatalog({ fetcher = fetch, force = false } = {}) {
|
|
40
|
+
if (force) return refreshCatalog({ fetcher })
|
|
40
41
|
const cached = await readCache()
|
|
41
42
|
if (cached && Date.now() - cached.at < TTL) return cached.providers
|
|
42
43
|
refreshCatalog({ fetcher }).catch(() => {})
|
package/src/codex-models.js
CHANGED
|
@@ -22,16 +22,16 @@ export function mapCodexModels(entries) {
|
|
|
22
22
|
}))
|
|
23
23
|
}
|
|
24
24
|
|
|
25
|
-
export async function loadCodexModels(credentials) {
|
|
25
|
+
export async function loadCodexModels(credentials, { force = false, fetcher = fetch } = {}) {
|
|
26
26
|
let cached = null
|
|
27
27
|
try {
|
|
28
28
|
cached = JSON.parse(await readFile(cacheFile(), 'utf-8'))
|
|
29
29
|
} catch {}
|
|
30
|
-
if (cached && Date.now() - cached.at < TTL) return mapCodexModels(cached.models)
|
|
30
|
+
if (!force && cached && Date.now() - cached.at < TTL) return mapCodexModels(cached.models)
|
|
31
31
|
if (!credentials) return mapCodexModels(cached?.models || [])
|
|
32
32
|
|
|
33
33
|
try {
|
|
34
|
-
const response = await
|
|
34
|
+
const response = await fetcher(MODELS_URL, {
|
|
35
35
|
headers: {
|
|
36
36
|
Authorization: `Bearer ${credentials.apiKey}`,
|
|
37
37
|
...credentials.headers,
|
package/src/controller.js
CHANGED
|
@@ -10,6 +10,7 @@ import { deriveState, userEntries, rewindStats } from './derive.js'
|
|
|
10
10
|
import { appendPrompt } from './history.js'
|
|
11
11
|
import { runTurn, summarizeText, compactHistory, compactProgress } from './agent.js'
|
|
12
12
|
import { createAgentManager } from './agents.js'
|
|
13
|
+
import { createPeers } from './peers.js'
|
|
13
14
|
import { runDeliberation, validateDeliberation } from './deliberation.js'
|
|
14
15
|
import { deliberationsFromEvents } from './deliberation-history.js'
|
|
15
16
|
import { compactionPrompt, formatCompactSummary, summarySections, compactionKeepFrom } from './compaction.js'
|
|
@@ -24,7 +25,7 @@ import { revertEdits, reapplyEdits } from './rewind.js'
|
|
|
24
25
|
import { buildSystemPrompt } from './system-prompt.js'
|
|
25
26
|
import { memoryIndex } from './memory.js'
|
|
26
27
|
import { transcriptToMarkdown } from './export.js'
|
|
27
|
-
import { findModel,
|
|
28
|
+
import { findModel, usageCost } from './models.js'
|
|
28
29
|
import { adhocModel } from './catalog.js'
|
|
29
30
|
import { writeConfig } from './config.js'
|
|
30
31
|
import { connectOpenAI, openaiCredentials, disconnectOpenAI } from './openai-auth.js'
|
|
@@ -99,7 +100,7 @@ function errorText(err, limit) {
|
|
|
99
100
|
return String(err?.message || err).slice(0, limit)
|
|
100
101
|
}
|
|
101
102
|
|
|
102
|
-
export function createController({ boot }) {
|
|
103
|
+
export function createController({ boot, run = runTurn, peerDirectory } = {}) {
|
|
103
104
|
if (!Object.hasOwn(boot, 'participantAModel')) boot.participantAModel = boot.proposerModel ?? null
|
|
104
105
|
if (!Object.hasOwn(boot, 'participantBModel')) boot.participantBModel = boot.reviewerModel ?? null
|
|
105
106
|
const { on, emit } = createEmitter()
|
|
@@ -132,6 +133,9 @@ export function createController({ boot }) {
|
|
|
132
133
|
imageCount: 0,
|
|
133
134
|
activityVersion: 0,
|
|
134
135
|
held: false,
|
|
136
|
+
peerPaused: false,
|
|
137
|
+
peerConnection: null,
|
|
138
|
+
peerError: null,
|
|
135
139
|
}
|
|
136
140
|
|
|
137
141
|
let abort = null
|
|
@@ -140,9 +144,130 @@ export function createController({ boot }) {
|
|
|
140
144
|
let pendingSystemNotes = []
|
|
141
145
|
const warnedTools = new Set()
|
|
142
146
|
|
|
143
|
-
const changed = () =>
|
|
147
|
+
const changed = () => {
|
|
148
|
+
peers.setStatus(state.held || state.peerPaused ? 'paused' : state.busy ? 'busy' : 'idle')
|
|
149
|
+
emit('change', state)
|
|
150
|
+
}
|
|
144
151
|
const flash = (message) => emit('flash', message)
|
|
145
152
|
|
|
153
|
+
let preparingTurn = false
|
|
154
|
+
let preparation = Promise.resolve()
|
|
155
|
+
let peerTransition = false
|
|
156
|
+
let peerOperations = Promise.resolve()
|
|
157
|
+
let shuttingDown = false
|
|
158
|
+
let peerWakeScheduled = false
|
|
159
|
+
const peerWrites = new Set()
|
|
160
|
+
const incomingPeers = new Map()
|
|
161
|
+
const peers = createPeers({
|
|
162
|
+
directory: peerDirectory,
|
|
163
|
+
onMessage: async (message) => {
|
|
164
|
+
const session = state.session
|
|
165
|
+
if (shuttingDown || peerTransition || !session || session.id !== message.to.id || peers.identity?.id !== session.id) throw new Error('recipient session is disconnected')
|
|
166
|
+
if (boot.ephemeral) throw new Error('peer delivery requires a saved session')
|
|
167
|
+
const duplicate = state.events.find((event) => event.type === 'peer_message' && event.data.id === message.id)
|
|
168
|
+
if (duplicate) {
|
|
169
|
+
if (duplicate.data.from.id !== message.from.id || duplicate.data.message !== message.message) throw new Error('message ID reused with different content')
|
|
170
|
+
return
|
|
171
|
+
}
|
|
172
|
+
const incoming = incomingPeers.get(message.id)
|
|
173
|
+
if (incoming) {
|
|
174
|
+
if (incoming.from.id !== message.from.id || incoming.message !== message.message) throw new Error('message ID reused with different content')
|
|
175
|
+
return incoming.write
|
|
176
|
+
}
|
|
177
|
+
if (pendingPeers().length + peerWrites.size >= 100) throw new Error('recipient inbox is full')
|
|
178
|
+
const write = appendPeer(message, 'incoming', 'delivered')
|
|
179
|
+
incomingPeers.set(message.id, { ...message, write })
|
|
180
|
+
try { await write } finally { incomingPeers.delete(message.id) }
|
|
181
|
+
schedulePeerWake()
|
|
182
|
+
},
|
|
183
|
+
onSend: async (message) => {
|
|
184
|
+
if (peerTransition || state.session?.id !== message.from.id) throw new Error('sender session changed')
|
|
185
|
+
await appendPeer(message, 'outgoing', 'sending')
|
|
186
|
+
},
|
|
187
|
+
onDelivery: async (delivery) => {
|
|
188
|
+
const event = makeEvent('peer_delivery', delivery)
|
|
189
|
+
await state.session.append(event, { strict: true })
|
|
190
|
+
state.events.push(event)
|
|
191
|
+
state.persisted = state.events.length
|
|
192
|
+
state.overlay = state.overlay.map((item) => item.kind === 'peer' && item.messageId === delivery.id ? { ...item, ...delivery } : item)
|
|
193
|
+
reDerive()
|
|
194
|
+
await state.session?.flush()
|
|
195
|
+
},
|
|
196
|
+
})
|
|
197
|
+
|
|
198
|
+
async function appendPeer(message, direction, status) {
|
|
199
|
+
const session = state.session
|
|
200
|
+
const event = makeEvent('peer_message', { ...message, direction, status })
|
|
201
|
+
const write = (async () => {
|
|
202
|
+
await session.append(event, { strict: true })
|
|
203
|
+
if (state.session !== session) return
|
|
204
|
+
state.events.push(event)
|
|
205
|
+
state.persisted = state.events.length
|
|
206
|
+
reDerive()
|
|
207
|
+
if (state.busy && !state.compacting) {
|
|
208
|
+
const items = [...state.overlay]
|
|
209
|
+
flushStream(items)
|
|
210
|
+
items.push(state.derived.transcript.findLast((item) => item.kind === 'peer' && item.messageId === message.id))
|
|
211
|
+
set({ overlay: items })
|
|
212
|
+
}
|
|
213
|
+
})()
|
|
214
|
+
peerWrites.add(write)
|
|
215
|
+
try { await write } finally { peerWrites.delete(write) }
|
|
216
|
+
}
|
|
217
|
+
|
|
218
|
+
function pendingPeers() {
|
|
219
|
+
return state.derived.pendingPeerMessages.filter((message) => message.to.id === state.session?.id)
|
|
220
|
+
}
|
|
221
|
+
|
|
222
|
+
function schedulePeerWake() {
|
|
223
|
+
if (peerWakeScheduled || shuttingDown) return
|
|
224
|
+
peerWakeScheduled = true
|
|
225
|
+
setImmediate(() => {
|
|
226
|
+
peerWakeScheduled = false
|
|
227
|
+
if (shuttingDown || peerTransition || peerWrites.size || preparingTurn || state.busy || state.held || state.peerPaused || !peers.identity || !pendingPeers().length) return
|
|
228
|
+
runAgentTurn().catch((error) => { abort = null; set({ busy: false, turnPhase: 'idle', peerPaused: true }); flash(`peer response failed: ${errorText(error, 120)}`) })
|
|
229
|
+
})
|
|
230
|
+
}
|
|
231
|
+
|
|
232
|
+
function transitionPeerSession(action) {
|
|
233
|
+
return (...args) => {
|
|
234
|
+
const result = peerOperations.then(async () => {
|
|
235
|
+
if (preparingTurn) {
|
|
236
|
+
if (action !== shutdown) return flash('finish or interrupt the current turn first')
|
|
237
|
+
shuttingDown = true
|
|
238
|
+
await preparation
|
|
239
|
+
}
|
|
240
|
+
peerTransition = true
|
|
241
|
+
try {
|
|
242
|
+
await Promise.allSettled(peerWrites)
|
|
243
|
+
return await action(...args)
|
|
244
|
+
} finally {
|
|
245
|
+
peerTransition = false
|
|
246
|
+
flushSystemNotes()
|
|
247
|
+
}
|
|
248
|
+
})
|
|
249
|
+
peerOperations = result.catch(() => {})
|
|
250
|
+
return result
|
|
251
|
+
}
|
|
252
|
+
}
|
|
253
|
+
|
|
254
|
+
async function disconnectPeers() {
|
|
255
|
+
await Promise.allSettled(peerWrites)
|
|
256
|
+
await peers.disconnect()
|
|
257
|
+
set({ peerConnection: null, peerError: null })
|
|
258
|
+
}
|
|
259
|
+
|
|
260
|
+
async function reconnectPeers() {
|
|
261
|
+
if (!state.derived.title || !state.session) return
|
|
262
|
+
try {
|
|
263
|
+
const identity = await peers.connect({ id: state.session.id, name: state.derived.title, cwd: boot.cwd })
|
|
264
|
+
set({ peerConnection: identity, peerError: null })
|
|
265
|
+
} catch (error) {
|
|
266
|
+
set({ peerConnection: null, peerError: error.message })
|
|
267
|
+
flash(`peer disconnected: ${error.message}`)
|
|
268
|
+
}
|
|
269
|
+
}
|
|
270
|
+
|
|
146
271
|
function set(patch) {
|
|
147
272
|
Object.assign(state, patch)
|
|
148
273
|
changed()
|
|
@@ -381,7 +506,8 @@ export function createController({ boot }) {
|
|
|
381
506
|
}
|
|
382
507
|
|
|
383
508
|
function flushSystemNotes() {
|
|
384
|
-
|
|
509
|
+
schedulePeerWake()
|
|
510
|
+
if (!pendingSystemNotes.length || state.busy || state.held || peerTransition || shuttingDown || !state.session) return
|
|
385
511
|
pendingSystemNotes = pendingSystemNotes.filter((note) => !note.agentId || !agents.get(note.agentId)?.collectedAt)
|
|
386
512
|
const currentSessionId = state.session.id
|
|
387
513
|
const current = pendingSystemNotes.filter((note) => !note.sessionId || note.sessionId === currentSessionId)
|
|
@@ -400,6 +526,7 @@ export function createController({ boot }) {
|
|
|
400
526
|
function hold(held) {
|
|
401
527
|
set({ held })
|
|
402
528
|
if (!held) flushSystemNotes()
|
|
529
|
+
schedulePeerWake()
|
|
403
530
|
}
|
|
404
531
|
|
|
405
532
|
function flushStream(items) {
|
|
@@ -417,10 +544,28 @@ export function createController({ boot }) {
|
|
|
417
544
|
}
|
|
418
545
|
|
|
419
546
|
async function executeTurn(text, { views = [] } = {}) {
|
|
420
|
-
|
|
421
|
-
|
|
422
|
-
|
|
423
|
-
|
|
547
|
+
preparingTurn = true
|
|
548
|
+
let prepared
|
|
549
|
+
preparation = new Promise(resolve => { prepared = resolve })
|
|
550
|
+
const session = state.session
|
|
551
|
+
try {
|
|
552
|
+
for (const view of views) await persistUserMessage(view, { viewed: true })
|
|
553
|
+
if (text) await persistUserMessage(text)
|
|
554
|
+
reDerive()
|
|
555
|
+
preparingTurn = false
|
|
556
|
+
prepared()
|
|
557
|
+
await runAgentTurn()
|
|
558
|
+
} catch (error) {
|
|
559
|
+
if (!session || session === state.session) {
|
|
560
|
+
abort = null
|
|
561
|
+
set({ busy: false, turnPhase: 'idle', peerPaused: true })
|
|
562
|
+
flash(`error: ${errorText(error, 120)}`)
|
|
563
|
+
}
|
|
564
|
+
} finally {
|
|
565
|
+
preparingTurn = false
|
|
566
|
+
prepared()
|
|
567
|
+
schedulePeerWake()
|
|
568
|
+
}
|
|
424
569
|
}
|
|
425
570
|
|
|
426
571
|
function takePending() {
|
|
@@ -430,7 +575,7 @@ export function createController({ boot }) {
|
|
|
430
575
|
}
|
|
431
576
|
|
|
432
577
|
async function compact(instructions = '') {
|
|
433
|
-
if (state.busy || state.compacting) return flash('finish or interrupt the current turn first')
|
|
578
|
+
if (state.busy || state.compacting || peerTransition) return flash('finish or interrupt the current turn first')
|
|
434
579
|
const current = state.derived
|
|
435
580
|
if (current.providerHistory.length < 4) return flash('nothing to compact yet')
|
|
436
581
|
|
|
@@ -603,20 +748,29 @@ export function createController({ boot }) {
|
|
|
603
748
|
}
|
|
604
749
|
|
|
605
750
|
async function runAgentTurn() {
|
|
751
|
+
try { await performAgentTurn() } catch (error) {
|
|
752
|
+
abort = null
|
|
753
|
+
set({ busy: false, turnPhase: 'idle', peerPaused: true })
|
|
754
|
+
flash(`error: ${errorText(error, 120)}`)
|
|
755
|
+
}
|
|
756
|
+
}
|
|
757
|
+
|
|
758
|
+
async function performAgentTurn() {
|
|
759
|
+
if (state.busy || peerTransition || shuttingDown) return
|
|
606
760
|
const researchAgentLimit = nextResearchAgentLimit || null
|
|
607
761
|
nextResearchAgentLimit = null
|
|
762
|
+
const controller = new AbortController()
|
|
763
|
+
abort = controller
|
|
608
764
|
emit('turn', 'start')
|
|
609
765
|
set({ busy: true, turnPhase: 'responding', startedAt: Date.now(), liveUsage: null })
|
|
610
766
|
|
|
611
767
|
const { auth, ok } = await codexAuth()
|
|
612
768
|
if (!ok) {
|
|
613
|
-
set({ turnPhase: 'idle', busy: false })
|
|
769
|
+
set({ turnPhase: 'idle', busy: false, peerPaused: true })
|
|
614
770
|
flushSystemNotes()
|
|
615
771
|
return
|
|
616
772
|
}
|
|
617
773
|
|
|
618
|
-
const controller = new AbortController()
|
|
619
|
-
abort = controller
|
|
620
774
|
const { tracker } = boot
|
|
621
775
|
const loadedBefore = new Set(tracker.loaded)
|
|
622
776
|
const userToolScan = await refreshProjectIndexes()
|
|
@@ -627,6 +781,7 @@ export function createController({ boot }) {
|
|
|
627
781
|
sessionId: state.session?.id,
|
|
628
782
|
sessionFile: state.session?.file,
|
|
629
783
|
wakeups: boot.wakeups,
|
|
784
|
+
peers: peers.identity ? peers : null,
|
|
630
785
|
agents: boot.researchModel ? agents : null,
|
|
631
786
|
deliberations: boot.deliberationModel || (boot.participantAModel && boot.participantBModel) ? deliberations : null,
|
|
632
787
|
onAgentsCollected: discardCollectedAgentNotes,
|
|
@@ -639,10 +794,24 @@ export function createController({ boot }) {
|
|
|
639
794
|
viewer: state.model.vision === false ? null : { deliver: deliverImage },
|
|
640
795
|
})
|
|
641
796
|
|
|
797
|
+
await Promise.allSettled(peerWrites)
|
|
798
|
+
if (controller.signal.aborted || shuttingDown) {
|
|
799
|
+
abort = null
|
|
800
|
+
set({ busy: false, turnPhase: 'idle', peerPaused: true })
|
|
801
|
+
return
|
|
802
|
+
}
|
|
803
|
+
const pendingPeerIds = state.peerPaused ? [] : pendingPeers().map((message) => message.id)
|
|
804
|
+
if (pendingPeerIds.length) {
|
|
805
|
+
const event = makeEvent('peer_consumed', { ids: pendingPeerIds })
|
|
806
|
+
await state.session.append(event, { strict: true })
|
|
807
|
+
state.events.push(event)
|
|
808
|
+
state.persisted = state.events.length
|
|
809
|
+
reDerive()
|
|
810
|
+
}
|
|
642
811
|
sendAfterToolTriggered = false
|
|
643
812
|
let result
|
|
644
813
|
try {
|
|
645
|
-
result = await
|
|
814
|
+
result = await run({
|
|
646
815
|
history: state.derived.providerHistory,
|
|
647
816
|
tools,
|
|
648
817
|
recorder,
|
|
@@ -656,6 +825,7 @@ export function createController({ boot }) {
|
|
|
656
825
|
} catch (err) {
|
|
657
826
|
abort = null
|
|
658
827
|
set({ overlay: [], streaming: null, liveUsage: null, turnPhase: 'idle', busy: false })
|
|
828
|
+
set({ peerPaused: true })
|
|
659
829
|
flash(`error: ${errorText(err, 120)}`)
|
|
660
830
|
return
|
|
661
831
|
}
|
|
@@ -676,6 +846,7 @@ export function createController({ boot }) {
|
|
|
676
846
|
state.streaming = null
|
|
677
847
|
state.turnPhase = 'idle'
|
|
678
848
|
state.busy = false
|
|
849
|
+
if ((result.interrupted && !sendAfterToolTriggered) || result.stalled || result.error) state.peerPaused = true
|
|
679
850
|
reDerive()
|
|
680
851
|
set({ liveUsage: null })
|
|
681
852
|
boot.git.refresh()
|
|
@@ -710,11 +881,13 @@ export function createController({ boot }) {
|
|
|
710
881
|
}
|
|
711
882
|
|
|
712
883
|
function send(text) {
|
|
884
|
+
if (peerTransition || shuttingDown) return flash('session is switching')
|
|
713
885
|
const value = text.trim()
|
|
714
886
|
if (!value) return
|
|
887
|
+
state.peerPaused = false
|
|
715
888
|
state.sent = [...state.sent, { text: value, at: Date.now() }]
|
|
716
889
|
appendPrompt(boot.root, value).catch(() => {})
|
|
717
|
-
if (state.busy) {
|
|
890
|
+
if (state.busy || preparingTurn) {
|
|
718
891
|
set({ queued: [...state.queued, value] })
|
|
719
892
|
return
|
|
720
893
|
}
|
|
@@ -723,6 +896,7 @@ export function createController({ boot }) {
|
|
|
723
896
|
}
|
|
724
897
|
|
|
725
898
|
function interrupt() {
|
|
899
|
+
set({ peerPaused: true })
|
|
726
900
|
if (!state.busy) return
|
|
727
901
|
sendAfterToolTriggered = false
|
|
728
902
|
cancelQuestion()
|
|
@@ -766,12 +940,14 @@ export function createController({ boot }) {
|
|
|
766
940
|
state.expedited = []
|
|
767
941
|
state.views = []
|
|
768
942
|
state.sent = []
|
|
943
|
+
state.peerPaused = false
|
|
769
944
|
state.model = model ?? state.defaultModel
|
|
770
945
|
state.effort = effort === undefined ? state.defaultEffort : effort
|
|
771
946
|
}
|
|
772
947
|
|
|
773
|
-
function newSession() {
|
|
948
|
+
async function newSession() {
|
|
774
949
|
if (state.busy) return flash('finish or interrupt the current turn first')
|
|
950
|
+
await disconnectPeers()
|
|
775
951
|
resetConversation()
|
|
776
952
|
agents.clear()
|
|
777
953
|
reDerive()
|
|
@@ -793,6 +969,7 @@ export function createController({ boot }) {
|
|
|
793
969
|
flash(`delete failed: ${errorText(err, 80)}`)
|
|
794
970
|
return false
|
|
795
971
|
}
|
|
972
|
+
await disconnectPeers()
|
|
796
973
|
resetConversation()
|
|
797
974
|
reDerive()
|
|
798
975
|
emit('session', state.session)
|
|
@@ -800,13 +977,15 @@ export function createController({ boot }) {
|
|
|
800
977
|
return true
|
|
801
978
|
}
|
|
802
979
|
|
|
803
|
-
async function fork(
|
|
804
|
-
if (
|
|
980
|
+
async function fork(args = '') {
|
|
981
|
+
if (args.trim()) return flash('usage: /fork')
|
|
805
982
|
if (state.busy) return flash('finish or interrupt the current turn first')
|
|
806
983
|
ensureSession()
|
|
807
|
-
const forked = await forkSession({ source: state.session, cwd: boot.cwd, root: boot.root, events: state.events
|
|
984
|
+
const forked = await forkSession({ source: state.session, cwd: boot.cwd, root: boot.root, events: state.events })
|
|
985
|
+
await disconnectPeers()
|
|
808
986
|
state.session = forked.session
|
|
809
987
|
state.events = forked.events
|
|
988
|
+
state.peerPaused = false
|
|
810
989
|
state.persisted = forked.events.length
|
|
811
990
|
state.rewindUndo = null
|
|
812
991
|
state.queued = []
|
|
@@ -816,17 +995,38 @@ export function createController({ boot }) {
|
|
|
816
995
|
agents.restore(forked.events)
|
|
817
996
|
reDerive()
|
|
818
997
|
emit('session', state.session)
|
|
819
|
-
flash(
|
|
998
|
+
flash('session forked')
|
|
820
999
|
}
|
|
821
1000
|
|
|
822
|
-
function rename(text) {
|
|
823
|
-
const
|
|
824
|
-
|
|
1001
|
+
async function rename(text = '') {
|
|
1002
|
+
const name = text.trim()
|
|
1003
|
+
if (boot.ephemeral && name) return flash('peer messaging requires a saved session')
|
|
825
1004
|
ensureSession()
|
|
826
|
-
|
|
827
|
-
|
|
828
|
-
|
|
829
|
-
|
|
1005
|
+
const previous = peers.identity
|
|
1006
|
+
try {
|
|
1007
|
+
await state.session.flush()
|
|
1008
|
+
if (name) await peers.connect({ id: state.session.id, name, cwd: boot.cwd })
|
|
1009
|
+
const event = makeEvent('title', { text: name || null })
|
|
1010
|
+
await state.session.append(event, { strict: true })
|
|
1011
|
+
state.events.push(event)
|
|
1012
|
+
state.persisted = state.events.length
|
|
1013
|
+
if (!name) await disconnectPeers()
|
|
1014
|
+
set({ peerConnection: peers.identity, peerError: null })
|
|
1015
|
+
reDerive()
|
|
1016
|
+
flash(name ? `session renamed to "${name}"` : 'session name reset')
|
|
1017
|
+
return true
|
|
1018
|
+
} catch (error) {
|
|
1019
|
+
try {
|
|
1020
|
+
if (previous) await peers.connect(previous)
|
|
1021
|
+
else await disconnectPeers()
|
|
1022
|
+
set({ peerConnection: peers.identity })
|
|
1023
|
+
} catch (rollbackError) {
|
|
1024
|
+
await disconnectPeers().catch(() => {})
|
|
1025
|
+
set({ peerConnection: null, peerError: rollbackError.message })
|
|
1026
|
+
}
|
|
1027
|
+
flash(`rename failed: ${error.message}`)
|
|
1028
|
+
return false
|
|
1029
|
+
}
|
|
830
1030
|
}
|
|
831
1031
|
|
|
832
1032
|
function setColor(input = '') {
|
|
@@ -965,10 +1165,14 @@ export function createController({ boot }) {
|
|
|
965
1165
|
if (meta.header.root !== boot.root) return switchProject(meta)
|
|
966
1166
|
try {
|
|
967
1167
|
const { header, events } = await loadSession(meta.file)
|
|
1168
|
+
await disconnectPeers()
|
|
968
1169
|
state.session = openSession({ file: meta.file, header })
|
|
969
1170
|
state.events = [...events]
|
|
970
1171
|
state.persisted = events.length
|
|
971
1172
|
state.rewindUndo = null
|
|
1173
|
+
state.peerPaused = false
|
|
1174
|
+
const unfinished = deriveState(events).transcript.filter((item) => item.kind === 'peer' && item.direction === 'outgoing' && item.status === 'sending')
|
|
1175
|
+
for (const item of unfinished) persist(makeEvent('peer_delivery', { id: item.messageId, status: 'unknown' }))
|
|
972
1176
|
agents.restore(events)
|
|
973
1177
|
reDerive()
|
|
974
1178
|
restoreModelFromSession()
|
|
@@ -976,6 +1180,7 @@ export function createController({ boot }) {
|
|
|
976
1180
|
state.sent = userEntries(state.derived).map((e) => ({ text: recallText(e), at: header.createdAt }))
|
|
977
1181
|
changed()
|
|
978
1182
|
emit('session', state.session)
|
|
1183
|
+
await reconnectPeers()
|
|
979
1184
|
emit('resumed', meta)
|
|
980
1185
|
} catch (err) {
|
|
981
1186
|
flash(`resume failed: ${errorText(err, 80)}`)
|
|
@@ -1051,6 +1256,7 @@ export function createController({ boot }) {
|
|
|
1051
1256
|
boot.git.retarget(next.root)
|
|
1052
1257
|
next.mcp.connectAll()
|
|
1053
1258
|
emit('mcp', next.mcp.list())
|
|
1259
|
+
await disconnectPeers()
|
|
1054
1260
|
resetConversation()
|
|
1055
1261
|
agents.clear()
|
|
1056
1262
|
reDerive()
|
|
@@ -1290,7 +1496,7 @@ export function createController({ boot }) {
|
|
|
1290
1496
|
const entries = Object.entries(current.usageByModel)
|
|
1291
1497
|
if (entries.length === 0) return null
|
|
1292
1498
|
const costOf = (byModel) =>
|
|
1293
|
-
Object.entries(byModel).reduce((sum, [name, usage]) => sum +
|
|
1499
|
+
Object.entries(byModel).reduce((sum, [name, usage]) => sum + usageCost(findModel(boot.models, name), usage), 0)
|
|
1294
1500
|
return {
|
|
1295
1501
|
spent: costOf(current.usageByModel),
|
|
1296
1502
|
active: costOf(current.usageActiveByModel),
|
|
@@ -1314,6 +1520,7 @@ export function createController({ boot }) {
|
|
|
1314
1520
|
skills: boot.skills,
|
|
1315
1521
|
shells: boot.shells,
|
|
1316
1522
|
wakeups: boot.wakeups,
|
|
1523
|
+
peers: peers.identity ? peers : null,
|
|
1317
1524
|
memory: boot.memory,
|
|
1318
1525
|
...extra,
|
|
1319
1526
|
})
|
|
@@ -1451,6 +1658,9 @@ export function createController({ boot }) {
|
|
|
1451
1658
|
}
|
|
1452
1659
|
|
|
1453
1660
|
async function shutdown() {
|
|
1661
|
+
shuttingDown = true
|
|
1662
|
+
abort?.abort()
|
|
1663
|
+
await disconnectPeers()
|
|
1454
1664
|
await state.session?.flush()
|
|
1455
1665
|
boot.shells.killAll()
|
|
1456
1666
|
boot.mcp.terminateAll()
|
|
@@ -1473,19 +1683,19 @@ export function createController({ boot }) {
|
|
|
1473
1683
|
holdExpedited,
|
|
1474
1684
|
hold,
|
|
1475
1685
|
noteSystem,
|
|
1476
|
-
newSession,
|
|
1477
|
-
deleteCurrentSession,
|
|
1478
|
-
fork,
|
|
1479
|
-
rename,
|
|
1686
|
+
newSession: transitionPeerSession(newSession),
|
|
1687
|
+
deleteCurrentSession: transitionPeerSession(deleteCurrentSession),
|
|
1688
|
+
fork: transitionPeerSession(fork),
|
|
1689
|
+
rename: transitionPeerSession(rename),
|
|
1480
1690
|
setColor,
|
|
1481
1691
|
clear,
|
|
1482
|
-
resume,
|
|
1692
|
+
resume: transitionPeerSession(resume),
|
|
1483
1693
|
listResumeSessions,
|
|
1484
1694
|
listProjects,
|
|
1485
1695
|
addWorktree,
|
|
1486
1696
|
deleteWorktree,
|
|
1487
|
-
switchToWorktree,
|
|
1488
|
-
switchProject,
|
|
1697
|
+
switchToWorktree: transitionPeerSession(switchToWorktree),
|
|
1698
|
+
switchProject: transitionPeerSession(switchProject),
|
|
1489
1699
|
resolveModel,
|
|
1490
1700
|
switchModel,
|
|
1491
1701
|
switchModelByName,
|
|
@@ -1530,6 +1740,6 @@ export function createController({ boot }) {
|
|
|
1530
1740
|
dismissDeliberation,
|
|
1531
1741
|
shellRows,
|
|
1532
1742
|
cancelWakeup,
|
|
1533
|
-
shutdown,
|
|
1743
|
+
shutdown: transitionPeerSession(shutdown),
|
|
1534
1744
|
}
|
|
1535
1745
|
}
|
package/src/derive.js
CHANGED
|
@@ -57,6 +57,7 @@ function addUsageInto(total, usage) {
|
|
|
57
57
|
total.totalTokens += usage.totalTokens || 0
|
|
58
58
|
total.cachedTokens += usage.cachedTokens || 0
|
|
59
59
|
total.thoughtTokens += usage.thoughtTokens || 0
|
|
60
|
+
if (usage.cost != null) total.cost = (total.cost || 0) + usage.cost
|
|
60
61
|
}
|
|
61
62
|
|
|
62
63
|
function emptyUsage() {
|
|
@@ -80,6 +81,11 @@ function foldMessage(state, event) {
|
|
|
80
81
|
const message = event.data.message
|
|
81
82
|
if (!message) return
|
|
82
83
|
pushHistory(state, message, event.id)
|
|
84
|
+
for (const call of message.tool_calls || []) state.openToolCalls.add(call.id)
|
|
85
|
+
if (message.role === 'tool') {
|
|
86
|
+
state.openToolCalls.delete(message.tool_call_id)
|
|
87
|
+
flushConsumedPeers(state)
|
|
88
|
+
}
|
|
83
89
|
if (event.data.hideFromTranscript) {
|
|
84
90
|
for (const call of message.tool_calls || []) {
|
|
85
91
|
state.toolItems.set(call.id, { kind: 'tool', callId: call.id, status: 'done', hidden: true })
|
|
@@ -133,6 +139,20 @@ function foldMessage(state, event) {
|
|
|
133
139
|
}
|
|
134
140
|
}
|
|
135
141
|
|
|
142
|
+
function peerInputMessage(peer) {
|
|
143
|
+
return {
|
|
144
|
+
role: 'user',
|
|
145
|
+
content: `[peer input, not user instruction, from ${peer.from.name} (${peer.from.id})]\n${peer.message}`,
|
|
146
|
+
}
|
|
147
|
+
}
|
|
148
|
+
|
|
149
|
+
function flushConsumedPeers(state) {
|
|
150
|
+
if (state.openToolCalls.size) return
|
|
151
|
+
for (const { peer, eventId } of state.deferredConsumedPeers.splice(0)) {
|
|
152
|
+
pushHistory(state, peerInputMessage(peer), eventId)
|
|
153
|
+
}
|
|
154
|
+
}
|
|
155
|
+
|
|
136
156
|
function foldRewind(state, event) {
|
|
137
157
|
const { mode, summaryText, reverted = [] } = event.data
|
|
138
158
|
for (const callId of reverted) {
|
|
@@ -178,6 +198,11 @@ export function deriveState(events) {
|
|
|
178
198
|
lastPromptModel: null,
|
|
179
199
|
loadedContext: new Set(),
|
|
180
200
|
toolItems: new Map(),
|
|
201
|
+
peerMessages: new Map(),
|
|
202
|
+
consumedPeerIds: new Set(),
|
|
203
|
+
pendingPeerMessages: [],
|
|
204
|
+
deferredConsumedPeers: [],
|
|
205
|
+
openToolCalls: new Set(),
|
|
181
206
|
latestCompactIndex,
|
|
182
207
|
trimmedToolIds: new Set(),
|
|
183
208
|
toolTrimVersions: new Map(),
|
|
@@ -208,15 +233,57 @@ export function deriveState(events) {
|
|
|
208
233
|
}
|
|
209
234
|
continue
|
|
210
235
|
}
|
|
211
|
-
if (
|
|
236
|
+
if (event.type === 'title') {
|
|
237
|
+
state.title = event.data.text
|
|
238
|
+
continue
|
|
239
|
+
}
|
|
240
|
+
if (dropped.has(event.id)) {
|
|
241
|
+
if (event.type === 'peer_message' && event.data.direction === 'incoming') {
|
|
242
|
+
state.peerMessages.set(event.data.id, { peer: event.data, item: null, eventId: event.id })
|
|
243
|
+
}
|
|
244
|
+
continue
|
|
245
|
+
}
|
|
212
246
|
|
|
213
247
|
switch (event.type) {
|
|
214
248
|
case 'message':
|
|
215
249
|
foldMessage(state, event)
|
|
216
250
|
break
|
|
251
|
+
case 'peer_message': {
|
|
252
|
+
const peer = event.data
|
|
253
|
+
const item = {
|
|
254
|
+
kind: 'peer', direction: peer.direction, from: peer.from, to: peer.to,
|
|
255
|
+
text: peer.message, status: peer.status || 'unknown', messageId: peer.id,
|
|
256
|
+
eventId: event.id, at: event.at ?? null,
|
|
257
|
+
}
|
|
258
|
+
state.transcript.push(item)
|
|
259
|
+
state.peerMessages.set(peer.id, { peer, item, eventId: event.id })
|
|
260
|
+
break
|
|
261
|
+
}
|
|
262
|
+
case 'peer_delivery': {
|
|
263
|
+
const entry = state.peerMessages.get(event.data.id)
|
|
264
|
+
if (entry?.item) Object.assign(entry.item, { status: event.data.status, ...(event.data.error !== undefined ? { error: event.data.error } : {}) })
|
|
265
|
+
break
|
|
266
|
+
}
|
|
267
|
+
case 'peer_consumed':
|
|
268
|
+
for (const id of event.data.ids || []) {
|
|
269
|
+
if (state.consumedPeerIds.has(id)) continue
|
|
270
|
+
state.consumedPeerIds.add(id)
|
|
271
|
+
const entry = state.peerMessages.get(id)
|
|
272
|
+
if (entry?.peer.direction === 'incoming') state.deferredConsumedPeers.push(entry)
|
|
273
|
+
}
|
|
274
|
+
flushConsumedPeers(state)
|
|
275
|
+
break
|
|
217
276
|
case 'turn_transcript':
|
|
218
277
|
for (const item of event.data.items || []) {
|
|
219
278
|
const restored = { ...item, eventId: event.id, at: item.at ?? event.at ?? null }
|
|
279
|
+
if (restored.kind === 'peer') {
|
|
280
|
+
const entry = state.peerMessages.get(restored.messageId)
|
|
281
|
+
if (entry?.item) {
|
|
282
|
+
state.transcript = state.transcript.filter((candidate) => candidate !== entry.item)
|
|
283
|
+
Object.assign(restored, { status: entry.item.status, error: entry.item.error })
|
|
284
|
+
entry.item = restored
|
|
285
|
+
}
|
|
286
|
+
}
|
|
220
287
|
state.transcript.push(restored)
|
|
221
288
|
if (restored.kind === 'tool' && restored.callId) state.toolItems.set(restored.callId, restored)
|
|
222
289
|
}
|
|
@@ -238,9 +305,6 @@ export function deriveState(events) {
|
|
|
238
305
|
case 'effort':
|
|
239
306
|
state.effort = event.data.to
|
|
240
307
|
break
|
|
241
|
-
case 'title':
|
|
242
|
-
state.title = event.data.text
|
|
243
|
-
break
|
|
244
308
|
case 'color':
|
|
245
309
|
state.color = event.data.value
|
|
246
310
|
break
|
|
@@ -267,6 +331,12 @@ export function deriveState(events) {
|
|
|
267
331
|
]
|
|
268
332
|
state.historyEventIds = [null, null]
|
|
269
333
|
}
|
|
334
|
+
state.openToolCalls.clear()
|
|
335
|
+
for (const message of state.providerHistory) {
|
|
336
|
+
for (const call of message.tool_calls || []) state.openToolCalls.add(call.id)
|
|
337
|
+
if (message.role === 'tool') state.openToolCalls.delete(message.tool_call_id)
|
|
338
|
+
}
|
|
339
|
+
flushConsumedPeers(state)
|
|
270
340
|
state.transcript.push({ kind: 'summary', source: 'compact', text: summary })
|
|
271
341
|
state.lastPromptTokens = 0
|
|
272
342
|
break
|
|
@@ -290,6 +360,8 @@ export function deriveState(events) {
|
|
|
290
360
|
state.transcript = []
|
|
291
361
|
state.providerHistory = []
|
|
292
362
|
state.historyEventIds = []
|
|
363
|
+
state.openToolCalls.clear()
|
|
364
|
+
flushConsumedPeers(state)
|
|
293
365
|
state.toolItems = new Map()
|
|
294
366
|
state.trimmedToolIds = new Set()
|
|
295
367
|
state.toolTrimVersions = new Map()
|
|
@@ -319,6 +391,11 @@ export function deriveState(events) {
|
|
|
319
391
|
}
|
|
320
392
|
}
|
|
321
393
|
|
|
394
|
+
flushConsumedPeers(state)
|
|
395
|
+
const consumedPeerIds = new Set(events.filter((event) => event.type === 'peer_consumed').flatMap((event) => event.data.ids || []))
|
|
396
|
+
state.pendingPeerMessages = [...state.peerMessages.values()]
|
|
397
|
+
.filter(({ peer }) => peer.direction === 'incoming' && !consumedPeerIds.has(peer.id))
|
|
398
|
+
.map(({ peer }) => peer)
|
|
322
399
|
state.estimatedPromptTokens = contextEdited && measuredBaseline
|
|
323
400
|
? Math.max(0, measuredBaseline.tokens + historyTokens() - measuredBaseline.history)
|
|
324
401
|
: null
|