aegiscode 6.8.29 → 6.8.31

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.
@@ -186,10 +186,146 @@ function updateNotice({
186
186
  return { latest, behind: !!(latest && isNewer(latest, current)) };
187
187
  }
188
188
 
189
- /** One line for the welcome box, or null when there is nothing to say. */
189
+ /**
190
+ * "What happens next", from a check result — the ONE verdict every applier
191
+ * consumes (AEGISONE, decision D7).
192
+ *
193
+ * There are two *mechanics* — `npm i -g` for the CLI's channel and
194
+ * `electron-updater` for the window's — and that is deliberate: they install
195
+ * different things. What must not be duplicated is the *decision*: whether
196
+ * there is anything to do, which version it is, which applier owns it and what
197
+ * the user is told to run. Both hosts ask this function, so the sentence a
198
+ * user reads in the terminal and the sentence the window shows cannot drift.
199
+ *
200
+ * Pure: no fetch, no clock, no cache. Feed it a result from `checkPublished`
201
+ * (or from the cached `updateNotice`) and it names the next action.
202
+ *
203
+ * @param {{current: string, latest: ?string, behind: boolean, channel?: 'npm'|'desktop', pkg?: string}} input
204
+ */
205
+ function updatePlan({ current, latest, behind, channel = 'npm', pkg = PKG } = {}) {
206
+ const currentText = String(current == null ? '' : current);
207
+ const latestText = latest ? String(latest) : null;
208
+ const pending = Boolean(behind) && Boolean(latestText);
209
+ if (!pending) {
210
+ return {
211
+ channel,
212
+ current: currentText,
213
+ latest: latestText,
214
+ behind: false,
215
+ action: 'none',
216
+ applier: 'none',
217
+ instruction: null,
218
+ };
219
+ }
220
+ if (channel === 'desktop') {
221
+ // The window installs its own build: there is nothing for the user to type,
222
+ // and offering `npm i -g aegis-desktop` here would install a *second* copy
223
+ // beside the running app. The applier is the app's own updater.
224
+ return {
225
+ channel,
226
+ current: currentText,
227
+ latest: latestText,
228
+ behind: true,
229
+ action: 'desktop-update',
230
+ applier: 'electron-updater',
231
+ instruction: 'Aegis Desktop → Check for Updates…',
232
+ };
233
+ }
234
+ return {
235
+ channel,
236
+ current: currentText,
237
+ latest: latestText,
238
+ behind: true,
239
+ action: 'npm-update',
240
+ applier: 'npm',
241
+ instruction: `npm i -g ${pkg}@latest`,
242
+ };
243
+ }
244
+
245
+ /**
246
+ * The same once-a-day check as `updateNotice`, but *awaited* and detailed.
247
+ *
248
+ * Why both exist: `updateNotice` answers immediately from cache and lets the
249
+ * refresh land later, which is right for a CLI that must never block a launch.
250
+ * A host that is *showing the user a banner about it* — the window, or
251
+ * `aegis doctor` — needs the full result (`.ok`, `.reason`, `.status`) and is
252
+ * willing to wait for it. So this is not a second check: it is the same probe
253
+ * (`fetchLatestDetailed`, same `TIMEOUT_MS`, same `REASONS` taxonomy) and the
254
+ * same `CHECK_INTERVAL_MS` cache rule, extracted so that the desktop applier
255
+ * stops carrying its own copy of the fetching logic (D7: the desktop keeps its
256
+ * applier and loses its version fetch).
257
+ *
258
+ * Never throws: a failure is a result with `ok: false` and a reason.
259
+ *
260
+ * @returns {Promise<{ok: boolean, latest: ?string, behind: boolean, reason: ?string,
261
+ * status: ?number, cached: boolean, checkedAt: ?number}>}
262
+ */
263
+ async function checkPublished({
264
+ current,
265
+ cache,
266
+ save,
267
+ now = Date.now(),
268
+ fetchImpl = fetchLatestDetailed,
269
+ intervalMs = CHECK_INTERVAL_MS,
270
+ timeoutMs = TIMEOUT_MS,
271
+ pkg = PKG,
272
+ } = {}) {
273
+ const c = cache || null;
274
+ const fresh = Boolean(c) && typeof c.checkedAt === 'number' && now - c.checkedAt < intervalMs;
275
+ if (fresh) {
276
+ const latest = c.latest || null;
277
+ return {
278
+ ok: Boolean(latest),
279
+ latest,
280
+ behind: !!(latest && isNewer(latest, current)),
281
+ reason: latest ? null : c.reason || null,
282
+ status: latest ? 200 : c.status == null ? null : c.status,
283
+ cached: true,
284
+ checkedAt: c.checkedAt,
285
+ };
286
+ }
287
+
288
+ let res;
289
+ try {
290
+ res = await fetchImpl({ pkg, timeoutMs });
291
+ } catch (err) {
292
+ res = { ok: false, latest: null, reason: REASONS.NETWORK, status: null, error: String((err && err.message) || err) };
293
+ }
294
+ const record = {
295
+ checkedAt: now,
296
+ latest: res && res.latest ? res.latest : null,
297
+ reason: (res && res.reason) || null,
298
+ status: res && res.status != null ? res.status : null,
299
+ };
300
+ if (typeof save === 'function') {
301
+ try {
302
+ save(record);
303
+ } catch {
304
+ /* failing to persist a notice is never worth failing the call */
305
+ }
306
+ }
307
+ return {
308
+ ok: Boolean(res && res.ok && res.latest),
309
+ latest: record.latest,
310
+ behind: !!(record.latest && isNewer(record.latest, current)),
311
+ reason: record.reason,
312
+ status: record.status,
313
+ cached: false,
314
+ checkedAt: now,
315
+ };
316
+ }
317
+
318
+ /**
319
+ * One line for the welcome box, or null when there is nothing to say.
320
+ *
321
+ * Rendered from `updatePlan`, not from a second copy of the sentence: the
322
+ * command the terminal tells the user to run and the command the window's
323
+ * banner offers are the same string produced by the same verdict.
324
+ */
190
325
  function updateLine({ current, latest, behind, pkg = PKG }) {
191
- if (!behind) return null;
192
- return `Update available: ${current} → ${latest} run: npm i -g ${pkg}@latest`;
326
+ const plan = updatePlan({ current, latest, behind, channel: 'npm', pkg });
327
+ if (plan.action !== 'npm-update') return null;
328
+ return `Update available: ${plan.current} → ${plan.latest} run: ${plan.instruction}`;
193
329
  }
194
330
 
195
331
  module.exports = {
@@ -198,6 +334,8 @@ module.exports = {
198
334
  fetchLatestDetailed,
199
335
  isTransientReason,
200
336
  updateNotice,
337
+ checkPublished,
338
+ updatePlan,
201
339
  updateLine,
202
340
  PKG,
203
341
  CHECK_INTERVAL_MS,
@@ -0,0 +1,92 @@
1
+ 'use strict';
2
+
3
+ /**
4
+ * context.js — token-budget trimmer for very large inputs (plan P1 §5.1 /
5
+ * P2 §6.4).
6
+ *
7
+ * Pure Node, no Electron imports. Estimates tokens with a ~4 chars/token
8
+ * heuristic, keeps the system message plus the newest turns, and drops the
9
+ * oldest turns that exceed the budget. The full transcript always stays in
10
+ * the local session record — this only trims what is sent to the wire.
11
+ */
12
+
13
+ const CHARS_PER_TOKEN = 4;
14
+ const MESSAGE_OVERHEAD = 4; // per-message framing + role overhead
15
+
16
+ /** Rough token count for a string (no tokenizer in a zero-dep shell). */
17
+ function estimateTokens(text) {
18
+ if (text == null) return 0;
19
+ const s = typeof text === 'string' ? text : String(text);
20
+ return Math.max(0, Math.ceil(s.length / CHARS_PER_TOKEN));
21
+ }
22
+
23
+ /** Rough token cost of one { role, content } message. */
24
+ function messageTokens(message) {
25
+ if (!message) return 0;
26
+ const content =
27
+ message.content != null
28
+ ? message.content
29
+ : message.text != null
30
+ ? message.text
31
+ : '';
32
+ return MESSAGE_OVERHEAD + estimateTokens(content);
33
+ }
34
+
35
+ /**
36
+ * Trim a message list to fit a token budget, keeping the newest turns.
37
+ *
38
+ * @param {object} opts
39
+ * @param {Array<{role:string,content:string}>} [opts.messages=[]]
40
+ * @param {string} [opts.system='']
41
+ * @param {number} [opts.budgetTokens=8192] total tokens allowed on the wire
42
+ * @param {number} [opts.reserveTokens=0] tokens reserved for the reply
43
+ * @param {number} [opts.fixedTokens=0] wire cost that is NOT a message and
44
+ * cannot be dropped (the tool schemas), counted before any turn is kept
45
+ * @returns {{messages:Array, system:string, dropped:number, estimatedTokens:number, fixedTokens:number}}
46
+ */
47
+ function trimContext({
48
+ messages = [],
49
+ system = '',
50
+ budgetTokens = 8192,
51
+ reserveTokens = 0,
52
+ fixedTokens = 0,
53
+ } = {}) {
54
+ const limit = Math.max(0, budgetTokens - reserveTokens);
55
+ const kept = [];
56
+ // Tool schemas go on the wire every round and cannot be trimmed away, so they
57
+ // are charged against the budget FIRST. Without this the trimmer believed a
58
+ // 4096-token window had 4096 tokens for history when the schemas had already
59
+ // spent ~1971 of them (measured: 10 schemas, 7882 chars) — and the daemon,
60
+ // run with `--context-shift`, discarded the SYSTEM row to make room instead
61
+ // of erroring. Counting them here is what keeps the system row alive.
62
+ const fixed = Math.max(0, Number(fixedTokens) || 0);
63
+ let used = fixed;
64
+
65
+ if (system) used += MESSAGE_OVERHEAD + estimateTokens(system);
66
+
67
+ // Walk newest -> oldest; keep a turn if it fits, else stop (older turns are
68
+ // even less relevant). Always keep at least the newest turn so a single
69
+ // oversized message is still sent rather than silently emptied.
70
+ for (let i = messages.length - 1; i >= 0; i--) {
71
+ const cost = messageTokens(messages[i]);
72
+ if (used + cost > limit && kept.length > 0) break;
73
+ kept.unshift(messages[i]);
74
+ used += cost;
75
+ }
76
+
77
+ return {
78
+ messages: kept,
79
+ system,
80
+ dropped: messages.length - kept.length,
81
+ estimatedTokens: used,
82
+ fixedTokens: fixed,
83
+ };
84
+ }
85
+
86
+ module.exports = {
87
+ CHARS_PER_TOKEN,
88
+ MESSAGE_OVERHEAD,
89
+ estimateTokens,
90
+ messageTokens,
91
+ trimContext,
92
+ };
@@ -1392,6 +1392,17 @@ function createLocalEngine({
1392
1392
  system: opts.system,
1393
1393
  messages: opts.messages,
1394
1394
  maxTokens: opts.maxTokens,
1395
+ // aegis1's byok_chat_completions has read and forwarded `tools`/
1396
+ // `tool_choice` since 926069b (2026-09-10) — this call simply never
1397
+ // sent them, so every BYOK turn (DeepSeek, Anthropic, OpenAI alike)
1398
+ // ran with no write/exec/editFile schema at all. A model told in its
1399
+ // system prompt that it "writes and edits files" but never given the
1400
+ // JSON shape to do so improvises a DeepSeek-native DSML call from
1401
+ // prose alone when it's confident, and falls back to prose ADVICE
1402
+ // (a shell script to run by hand) when it isn't — which is exactly
1403
+ // the bug this line closes.
1404
+ tools: opts.tools,
1405
+ toolChoice: opts.toolChoice,
1395
1406
  // Native effort knob, field and level both from the dialect table.
1396
1407
  // `bareModel` is already provider-less, so it matches the dialect
1397
1408
  // regexes without further stripping. Only a dialect whose field is
@@ -1530,12 +1541,19 @@ function createLocalEngine({
1530
1541
  const signal = controller.signal;
1531
1542
 
1532
1543
  // A caller can opt out of the agent loop entirely (`tools: false`) and get
1533
- // the old single-shot turn back. byok is ALWAYS single-shot: the
1534
- // stateless relay (aegis.byokChatCompletion, /api/v1/byok/chat/completions)
1535
- // has no tools/tool_choice parameter at all, so sending schemas here would
1536
- // build a prompt promising tool access the transport silently drops —
1537
- // the model would reason about exec/readFile and never see a result.
1538
- const toolsEnabled = cls !== 'byok' && !(payload && payload.tools === false);
1544
+ // the old single-shot turn back. byok used to be forced into that same
1545
+ // single-shot shape unconditionally: aegis1's byok relay had no
1546
+ // tools/tool_choice parameter at all, so sending schemas would build a
1547
+ // prompt promising tool access the transport silently dropped — the model
1548
+ // would reason about exec/readFile and never see a result. That stopped
1549
+ // being true at aegis1 926069b (2026-09-10, byok_chat_completions reads
1550
+ // and forwards both), but this carve-out was never revisited, so every
1551
+ // BYOK turn since kept running with no tool schema at all regardless —
1552
+ // the model told in its own system prompt that it writes and edits files,
1553
+ // and never given the JSON shape to do so. Reported live: asked to save a
1554
+ // file to the Desktop, DeepSeek had no write tool to call and answered
1555
+ // with a PowerShell script for the user to run by hand instead.
1556
+ const toolsEnabled = !(payload && payload.tools === false);
1539
1557
  const toolSchemas = toolsEnabled ? T.toolsFor({ includeSubagent: depth < MAX_SUBAGENT_DEPTH }) : [];
1540
1558
  const toolChoice = (payload && payload.toolChoice) || null;
1541
1559
 
@@ -2096,6 +2114,18 @@ function createLocalEngine({
2096
2114
  return { ok: Boolean(controller) };
2097
2115
  }
2098
2116
 
2117
+ /**
2118
+ * Unload every local model this engine warmed, across every daemon it
2119
+ * talked to (local.js `unloadAll`). The desktop host calls this on its quit
2120
+ * path so closing the app also closes the model — the local lane bills
2121
+ * nothing precisely because it is YOUR hardware, and hardware left running
2122
+ * a model nobody is using anymore after the app exits is the one cost that
2123
+ * lane was supposed to never have.
2124
+ */
2125
+ function unloadLocalModels() {
2126
+ return localT.unloadAll();
2127
+ }
2128
+
2099
2129
  return {
2100
2130
  CLASSES,
2101
2131
  listClasses,
@@ -2105,6 +2135,7 @@ function createLocalEngine({
2105
2135
  respondApproval,
2106
2136
  clearSessionApprovals,
2107
2137
  settings,
2138
+ unloadLocalModels,
2108
2139
  };
2109
2140
  }
2110
2141