aegiscode 7.0.11 → 7.0.12

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.
@@ -158,6 +158,198 @@ function fetchLatest(opts = {}) {
158
158
  return fetchLatestDetailed(opts).then((r) => (r.ok ? r.latest : null));
159
159
  }
160
160
 
161
+ //: Where the AEGIS server answers "am I still allowed to talk to you".
162
+ const DEFAULT_API_BASE = 'https://aegiscloud.org';
163
+ /** /api/v1/version is a tiny JSON document; anything bigger is a proxy page. */
164
+ const VERSION_BODY_CAP = 64 * 1024;
165
+
166
+ /**
167
+ * Ask the SERVER whether this client is still serviceable.
168
+ *
169
+ * Why this exists next to the npm check: they answer different questions.
170
+ * The registry says what was *published*; the server says what it will
171
+ * *accept*. aegis1 refuses every request from a client below
172
+ * `MIN_CLIENT_VERSION` with a 426, so a client that only asks npm learns it is
173
+ * unservicable by being refused mid-task — an outage, not a notice. Asking
174
+ * `/api/v1/version` first turns the same fact into a sentence the user reads
175
+ * before they hit the wall.
176
+ *
177
+ * `/api/v1/version` is informational: it never refuses anyone, and it echoes
178
+ * the verdict for the version header we send (`upgrade_required`).
179
+ *
180
+ * Resolves `{ ok, minClient, latestCli, latestDesktop, upgradeRequired,
181
+ * downloadUrl, reason, status }` and never rejects — same contract as
182
+ * `fetchLatestDetailed`, so a host can render "registry unreachable" and
183
+ * "server unreachable" differently instead of inventing a third story.
184
+ */
185
+ function fetchServerVersionDetailed({
186
+ base = DEFAULT_API_BASE,
187
+ clientVersion = null,
188
+ timeoutMs = TIMEOUT_MS,
189
+ getImpl = null,
190
+ } = {}) {
191
+ return new Promise((resolve) => {
192
+ let settled = false;
193
+ const done = (v) => {
194
+ if (!settled) {
195
+ settled = true;
196
+ resolve(v);
197
+ }
198
+ };
199
+ const fail = (reason, status = null) =>
200
+ done({
201
+ ok: false, minClient: null, latestCli: null, latestDesktop: null,
202
+ upgradeRequired: null, downloadUrl: '', reason, status,
203
+ });
204
+ const succeed = (body, status) => {
205
+ const minClient = body && typeof body.min_client === 'string' ? body.min_client : null;
206
+ // A 200 without `min_client` is malformed, not a slow network: do not
207
+ // invite a retry ladder for a document that will parse the same way.
208
+ if (!minClient) return fail(REASONS.MALFORMED, status);
209
+ done({
210
+ ok: true,
211
+ minClient,
212
+ latestCli: typeof body.latest_cli === 'string' ? body.latest_cli : '',
213
+ latestDesktop: typeof body.latest_desktop === 'string' ? body.latest_desktop : '',
214
+ // Trust the header echo only when we actually sent a version: without
215
+ // one the server answers for `require_header=False` and the answer is
216
+ // about nothing in particular. `null` here means "the server did not
217
+ // say", which is different from "the server said no" — the caller must
218
+ // be able to fall back without overriding an answer it was given.
219
+ upgradeRequired:
220
+ clientVersion && typeof body.upgrade_required === 'boolean'
221
+ ? body.upgrade_required
222
+ : null,
223
+ downloadUrl: typeof body.download_url === 'string' ? body.download_url : '',
224
+ reason: null,
225
+ status,
226
+ });
227
+ };
228
+
229
+ try {
230
+ const url = `${String(base || DEFAULT_API_BASE).replace(/\/+$/, '')}/api/v1/version`;
231
+ const headers = { accept: 'application/json' };
232
+ if (clientVersion) headers['X-AEGIS-Version'] = String(clientVersion);
233
+
234
+ const onResponse = (res) => {
235
+ const status = res.statusCode;
236
+ if (status !== 200) {
237
+ res.resume();
238
+ if (status === 404) return fail(REASONS.NOT_FOUND, status);
239
+ if (status === 401 || status === 403) return fail(REASONS.FORBIDDEN, status);
240
+ // 426 here would mean the endpoint itself were gated; treat it as a
241
+ // real answer rather than a transport failure if it ever happens.
242
+ if (status === 426) return fail(REASONS.HTTP, status);
243
+ return fail(REASONS.HTTP, status);
244
+ }
245
+ let body = '';
246
+ res.setEncoding('utf8');
247
+ res.on('data', (c) => {
248
+ body += c;
249
+ if (body.length > VERSION_BODY_CAP) {
250
+ res.destroy();
251
+ fail(REASONS.TOO_LARGE, status);
252
+ }
253
+ });
254
+ res.on('end', () => {
255
+ if (settled) return;
256
+ try {
257
+ succeed(JSON.parse(body), status);
258
+ } catch {
259
+ fail(REASONS.MALFORMED, status);
260
+ }
261
+ });
262
+ };
263
+
264
+ if (typeof getImpl === 'function') {
265
+ // Injected transport for tests and hosts that already own a fetch:
266
+ // `getImpl({url, headers, timeoutMs})` resolves `{status, text}`.
267
+ Promise.resolve(getImpl({ url, headers, timeoutMs }))
268
+ .then((r) => {
269
+ const status = r && r.status != null ? r.status : 0;
270
+ if (!status) return fail(REASONS.NETWORK);
271
+ if (status !== 200) {
272
+ if (status === 404) return fail(REASONS.NOT_FOUND, status);
273
+ if (status === 401 || status === 403) return fail(REASONS.FORBIDDEN, status);
274
+ return fail(REASONS.HTTP, status);
275
+ }
276
+ const text = r && typeof r.text === 'string' ? r.text : '';
277
+ if (text.length > VERSION_BODY_CAP) return fail(REASONS.TOO_LARGE, status);
278
+ try {
279
+ succeed(JSON.parse(text), status);
280
+ } catch {
281
+ fail(REASONS.MALFORMED, status);
282
+ }
283
+ })
284
+ .catch(() => fail(REASONS.NETWORK));
285
+ return;
286
+ }
287
+
288
+ const req = require(/^http:\/\//i.test(url) ? 'node:http' : 'node:https')
289
+ .get(url, { headers, timeout: timeoutMs }, onResponse);
290
+ req.on('timeout', () => {
291
+ req.destroy();
292
+ fail(REASONS.TIMEOUT);
293
+ });
294
+ req.on('error', () => fail(REASONS.NETWORK));
295
+ } catch {
296
+ fail(REASONS.NETWORK);
297
+ }
298
+ });
299
+ }
300
+
301
+ /** The server's minimum client version, or null. */
302
+ function fetchServerVersion(opts = {}) {
303
+ return fetchServerVersionDetailed(opts).then((r) => (r.ok ? r.minClient : null));
304
+ }
305
+
306
+ /**
307
+ * The server's verdict, expressed in the shape the notice/plan code already
308
+ * speaks: `{ behind, latest, required, downloadUrl, ok, reason, status }`.
309
+ *
310
+ * `behind` is true when the SERVER says this client is below its minimum —
311
+ * regardless of whether npm happens to have something newer. That ordering is
312
+ * deliberate: being refused is actionable now, being merely superseded is not.
313
+ */
314
+ async function serverUpdateVerdict({
315
+ current,
316
+ base = DEFAULT_API_BASE,
317
+ timeoutMs = TIMEOUT_MS,
318
+ getImpl = null,
319
+ } = {}) {
320
+ const res = await fetchServerVersionDetailed({ base, clientVersion: current, timeoutMs, getImpl });
321
+ if (!res.ok) {
322
+ return { ok: false, behind: false, latest: null, required: null, downloadUrl: '', reason: res.reason, status: res.status };
323
+ }
324
+ const required = res.minClient || null;
325
+ // The server's echo decides. Falling back to local arithmetic only when it
326
+ // said nothing (`null`) — OR'ing the two would let our own comparison
327
+ // override the very authority we asked, which is the bug this line exists to
328
+ // not have.
329
+ const behind =
330
+ res.upgradeRequired === true
331
+ ? true
332
+ : res.upgradeRequired === false
333
+ ? false
334
+ : required
335
+ ? isNewer(required, current)
336
+ : false;
337
+ return {
338
+ ok: true,
339
+ behind,
340
+ // The server's own minimum is the target when it is the thing refusing us;
341
+ // a published version is preferred when it names one, because that is what
342
+ // the user should actually install.
343
+ latest: (behind && (res.latestCli || res.latestDesktop)) || required,
344
+ latestCli: res.latestCli,
345
+ latestDesktop: res.latestDesktop,
346
+ required,
347
+ downloadUrl: res.downloadUrl,
348
+ reason: null,
349
+ status: res.status,
350
+ };
351
+ }
352
+
161
353
  /**
162
354
  * The notice to show, from cache. Never waits on the network.
163
355
  *
@@ -333,10 +525,83 @@ function updateLine({ current, latest, behind, pkg = PKG }) {
333
525
  return `Update available: ${plan.current} → ${plan.latest} run: ${plan.instruction}`;
334
526
  }
335
527
 
528
+ /**
529
+ * The server's verdict, from cache. Never waits on the network.
530
+ *
531
+ * Same contract and the same once-a-day rule as `updateNotice`, for the same
532
+ * reason: the welcome box draws from what the last run learned, and the
533
+ * refresh lands for the next one. A first run shows nothing, which is right —
534
+ * it has no verdict yet.
535
+ *
536
+ * Returns `{ behind, latest, required, downloadUrl }`. `behind` is the server's
537
+ * answer, not a comparison this module invented, so the box says "update" only
538
+ * when the server would actually refuse this client.
539
+ */
540
+ function serverNotice({
541
+ current,
542
+ cache,
543
+ save,
544
+ now = Date.now(),
545
+ verdictImpl = serverUpdateVerdict,
546
+ intervalMs = CHECK_INTERVAL_MS,
547
+ } = {}) {
548
+ const c = cache || {};
549
+ const fresh = typeof c.checkedAt === 'number' && now - c.checkedAt < intervalMs;
550
+
551
+ if (!fresh) {
552
+ Promise.resolve()
553
+ .then(() => verdictImpl({ current }))
554
+ .then((v) => {
555
+ if (!v || typeof save !== 'function') return;
556
+ // Persist the verdict even when it is "not behind": that is what tells
557
+ // the next run it already asked today, and stops a check per launch.
558
+ save({
559
+ checkedAt: now,
560
+ behind: Boolean(v.behind),
561
+ required: v.required || null,
562
+ latest: v.latest || null,
563
+ downloadUrl: v.downloadUrl || '',
564
+ reason: v.reason || null,
565
+ });
566
+ })
567
+ .catch(() => {});
568
+ }
569
+
570
+ return {
571
+ behind: Boolean(c.behind),
572
+ latest: c.latest || null,
573
+ required: c.required || null,
574
+ downloadUrl: c.downloadUrl || '',
575
+ };
576
+ }
577
+
578
+ /**
579
+ * The line for the welcome box when the SERVER says this build is too old.
580
+ *
581
+ * Distinct from `updateLine` on purpose: "a newer release exists" and "the
582
+ * server will refuse you" are different urgency, and only the second one means
583
+ * the app is about to stop working. Says where to get it, because a user who
584
+ * is being cut off needs a destination, not a version number.
585
+ */
586
+ function serverUpdateLine({ behind, latest, required, downloadUrl } = {}) {
587
+ if (!behind) return null;
588
+ const target = latest || required || '';
589
+ const head = target
590
+ ? `This build is no longer served — update to v${target}.`
591
+ : 'This build is no longer served — update to the latest release.';
592
+ const where = downloadUrl ? ` ${downloadUrl}` : '';
593
+ return `${head}${where}`;
594
+ }
595
+
336
596
  module.exports = {
337
597
  isNewer,
338
598
  fetchLatest,
339
599
  fetchLatestDetailed,
600
+ fetchServerVersion,
601
+ fetchServerVersionDetailed,
602
+ serverUpdateVerdict,
603
+ serverNotice,
604
+ serverUpdateLine,
340
605
  isTransientReason,
341
606
  updateNotice,
342
607
  checkPublished,
@@ -345,4 +610,5 @@ module.exports = {
345
610
  PKG,
346
611
  CHECK_INTERVAL_MS,
347
612
  REASONS,
613
+ DEFAULT_API_BASE,
348
614
  };
@@ -116,6 +116,23 @@ function claudeOAuthToken(env) {
116
116
  */
117
117
  const SHADOWING_ENV_VARS = Object.freeze(['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN']);
118
118
 
119
+ /**
120
+ * Whether `value` is shaped like an Anthropic console API key.
121
+ *
122
+ * Deliberately a SHAPE test, not a validity test. This process cannot know
123
+ * whether a key is live without spending it, so it does not try: it answers
124
+ * only "could this possibly be the console credential that is allowed to
125
+ * outrank a subscription". Anthropic console keys are `sk-ant-`-prefixed. The
126
+ * check is case-sensitive and anchored, because that is the literal the vendor
127
+ * uses — a case-insensitive match would accept `SK-ANT-` junk.
128
+ *
129
+ * @param {string} value
130
+ * @returns {boolean}
131
+ */
132
+ function isAnthropicConsoleKey(value) {
133
+ return typeof value === 'string' && /^sk-ant-[A-Za-z0-9_-]{8,}$/.test(value.trim());
134
+ }
135
+
119
136
  /**
120
137
  * The env for one `claude` child, with a shadowing value that cannot be a
121
138
  * credential removed.
@@ -151,28 +168,69 @@ const SHADOWING_ENV_VARS = Object.freeze(['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_T
151
168
  * value that provably cannot be a key is dropped, and the drop is REPORTED
152
169
  * rather than silent (see `envDroppedLine`).
153
170
  *
171
+ * ── the second rule: a length floor is not a shape (measured, 2026-10-21) ───
172
+ *
173
+ * The floor above answers "is this too short to be anything?" and nothing more.
174
+ * A 35-character value that is NOT an Anthropic console key clears it, still
175
+ * wins the CLI's precedence, and still takes the plan down — so the floor alone
176
+ * reproduced the original bug one paste later. Measured state that produced it:
177
+ *
178
+ * ~/.aegiscode/.env held ANTHROPIC_API_KEY=<35 chars, not sk-ant-*>
179
+ * ~/.claude/.credentials.json held a valid `claudeAiOauth` for plan `pro`
180
+ * `aegiscode -p "say hi" --json`
181
+ * → {"text":"Invalid API key · Fix external API key","model":"sonnet",
182
+ * "tokens":0,"balance_eur":1.54} exit 0, in 2.3 s
183
+ *
184
+ * and the child was spawned with the stale value present (`ANTHROPIC_LEN=35`,
185
+ * observed by a fake `claude` on PATH). Unsetting the variable in the SHELL did
186
+ * not help either: this host loads `~/.aegiscode/.env` into `process.env`
187
+ * itself, so the file is an input no caller can undo.
188
+ *
189
+ * So when a subscription IS present, only a value shaped like an Anthropic
190
+ * console key may shadow it. That is the narrowest rule that keeps the promise
191
+ * the old comment made — "a user who set one deliberately is asking for the
192
+ * pay-per-token path" — while refusing a value that provably is not one. With
193
+ * no subscription there is nothing to shadow and no opinion is taken: any value
194
+ * clearing the floor passes, exactly as before.
195
+ *
154
196
  * @param {object} [baseEnv] the caller's env bag
155
197
  * @param {string} [token] a `CLAUDE_CODE_OAUTH_TOKEN` to hand the child
156
- * @returns {{env: object, dropped: Array<{name: string, length: number}>}}
198
+ * @param {{hasSubscription?: boolean}} [opts] whether a subscription is present
199
+ * (see the second rule above); absent means "assume not", which keeps every
200
+ * pre-existing caller and test on the old behaviour.
201
+ * @returns {{env: object, dropped: Array<{name: string, length: number, reason: string}>}}
157
202
  */
158
- function childEnvPlan(baseEnv, token) {
203
+ function childEnvPlan(baseEnv, token, opts) {
159
204
  const env = { ...(baseEnv || {}) };
160
205
  const dropped = [];
161
206
  const usable = envFileLib && typeof envFileLib.credentialLooksUsable === 'function'
162
207
  ? envFileLib.credentialLooksUsable
163
208
  : null;
209
+ // Only a present subscription can be shadowed, so it is the only case that
210
+ // earns the stricter shape rule (see the docstring's second section).
211
+ const hasSubscription = !!(opts && opts.hasSubscription);
164
212
  // A host whose env module predates the floor keeps today's behaviour (the
165
213
  // variable passes through): a second copy of the floor here is the drift
166
214
  // client/env-file.js exists to prevent.
167
215
  if (usable) {
168
216
  for (const name of SHADOWING_ENV_VARS) {
169
217
  const value = env[name];
170
- if (typeof value !== 'string' || usable(value)) continue;
218
+ if (typeof value !== 'string') continue;
219
+ // Two independent reasons to refuse, and they are reported apart because
220
+ // they mean different things to the user: too short is junk, while a
221
+ // well-formed value that is not a console key is a key for something
222
+ // else that would silently outrank the plan they are paying for.
223
+ let reason = null;
224
+ if (!usable(value)) reason = 'too-short';
225
+ else if (hasSubscription && name === 'ANTHROPIC_API_KEY' && !isAnthropicConsoleKey(value)) {
226
+ reason = 'not-a-console-key';
227
+ }
228
+ if (!reason) continue;
171
229
  delete env[name];
172
230
  // A variable set to '' shadows nothing worth reporting — it is removed
173
231
  // (harmless) but the user is not told about a value they never gave.
174
232
  const length = value.trim().length;
175
- if (length > 0) dropped.push({ name, length });
233
+ if (length > 0) dropped.push({ name, length, reason });
176
234
  }
177
235
  }
178
236
  if (token) env.CLAUDE_CODE_OAUTH_TOKEN = token;
@@ -183,20 +241,51 @@ function childEnvPlan(baseEnv, token) {
183
241
  function envDroppedLine(dropped) {
184
242
  const list = Array.isArray(dropped) ? dropped : [];
185
243
  if (!list.length) return null;
186
- const names = list.map((d) => `${d.name} (${d.length} character${d.length === 1 ? '' : 's'})`).join(', ');
187
- return `aegis: not passed to the claude child — ${names}: too short to be a credential, and the CLI would have spent it instead of your subscription`;
244
+ const shaped = list.filter((d) => d && d.reason === 'not-a-console-key');
245
+ const short = list.filter((d) => !d || d.reason !== 'not-a-console-key');
246
+ const parts = [];
247
+ if (short.length) {
248
+ const names = short.map((d) => `${d.name} (${d.length} character${d.length === 1 ? '' : 's'})`).join(', ');
249
+ parts.push(`${names}: too short to be a credential, and the CLI would have spent it instead of your subscription`);
250
+ }
251
+ if (shaped.length) {
252
+ const names = shaped.map((d) => `${d.name} (${d.length} characters)`).join(', ');
253
+ parts.push(
254
+ `${names}: not an Anthropic console key (\`sk-ant-\`), and the CLI would have spent it instead of your subscription`
255
+ );
256
+ }
257
+ return `aegis: not passed to the claude child — ${parts.join('; ')}`;
188
258
  }
189
259
 
190
- /** The shadowing value in `env` that cannot be a credential, if any (see above). */
191
- function shadowingValue(env) {
260
+ /**
261
+ * The shadowing value in `env` that cannot be spent as the credential the CLI
262
+ * would take it for, if any (see the two rules in `childEnvPlan`).
263
+ *
264
+ * This must agree with `childEnvPlan` exactly: a status surface that says "no
265
+ * shadowing value" while the child is in fact being handed one is worse than no
266
+ * report at all. Both reasons are therefore reported, and each carries the same
267
+ * `reason` tag the drop report uses so the two lines cannot drift apart.
268
+ *
269
+ * @param {object} env
270
+ * @param {{hasSubscription?: boolean}} [opts]
271
+ * @returns {{name: string, length: number, reason: string}|null}
272
+ */
273
+ function shadowingValue(env, opts) {
192
274
  const bag = env || {};
193
275
  const usable = envFileLib && typeof envFileLib.credentialLooksUsable === 'function'
194
276
  ? envFileLib.credentialLooksUsable
195
277
  : null;
196
278
  if (!usable) return null;
279
+ const hasSubscription = !!(opts && opts.hasSubscription);
197
280
  for (const name of SHADOWING_ENV_VARS) {
198
281
  const value = bag[name];
199
- if (typeof value === 'string' && !usable(value)) return { name, length: value.trim().length };
282
+ if (typeof value !== 'string') continue;
283
+ let reason = null;
284
+ if (!usable(value)) reason = 'too-short';
285
+ else if (hasSubscription && name === 'ANTHROPIC_API_KEY' && !isAnthropicConsoleKey(value)) {
286
+ reason = 'not-a-console-key';
287
+ }
288
+ if (reason) return { name, length: value.trim().length, reason };
200
289
  }
201
290
  return null;
202
291
  }
@@ -264,7 +353,30 @@ function claudeProStatus(opts) {
264
353
  // child is fixed regardless (childEnvPlan); this reports it so a status
265
354
  // surface can say why, rather than leaving `apiKeySource: ANTHROPIC_API_KEY`
266
355
  // to be discovered from `claude auth status` by hand.
267
- out.shadowed = shadowingValue(env);
356
+ // A SUBSCRIPTION — the thing a stray `ANTHROPIC_API_KEY` would outrank — is an
357
+ // `oauth` plan or a `CLAUDE_CODE_OAUTH_TOKEN` handed to the child. A
358
+ // `credentials.json` holding a plain API key is not: there is no plan there to
359
+ // shadow, so the strict shape rule must not fire and drop the user's own key.
360
+ // This is computed once and published, so the report and the child env read
361
+ // ONE answer instead of each deciding for itself.
362
+ out.subscriptionPresent = out.loggedIn && out.kind !== 'apikey';
363
+ // The stricter rule only applies when a subscription is present, so the
364
+ // subscription this function just resolved is the same input the child env
365
+ // gets. Passing it here is what keeps `shadowed` and the drop report agreeing.
366
+ out.shadowed = shadowingValue(env, { hasSubscription: out.subscriptionPresent });
367
+ // "Can this host serve a `pro` turn at all?" is NOT the same question as
368
+ // "is there a subscription to shadow?" (above). A pin is phantom only when
369
+ // nothing usable survives to the child, and a bare API key in
370
+ // `credentials.json` (`kind: 'apikey'`) is a route with no plan behind it —
371
+ // so `subscriptionPresent` excludes it deliberately, while callability must
372
+ // count it. Answered by running the SAME planner the child env comes from, so
373
+ // this cannot disagree with what `claude` is actually handed: a variable the
374
+ // planner drops is not a credential, whatever it looks like in `env`.
375
+ const plan = childEnvPlan(env, null, { hasSubscription: out.subscriptionPresent });
376
+ out.credentialPresent = out.loggedIn
377
+ || typeof plan.env.ANTHROPIC_API_KEY === 'string'
378
+ || typeof plan.env.ANTHROPIC_AUTH_TOKEN === 'string'
379
+ || typeof plan.env.CLAUDE_CODE_OAUTH_TOKEN === 'string';
268
380
  return out;
269
381
  }
270
382
 
@@ -633,7 +745,18 @@ function runClaudePro(opts, deps) {
633
745
  // "API key: he" and the subscription is unreachable — see childEnvPlan.
634
746
  const baseEnv = o.env || process.env;
635
747
  const token = claudeOAuthToken(baseEnv);
636
- const plan = childEnvPlan(baseEnv, token);
748
+ // Whether a subscription is present decides whether a non-console
749
+ // `ANTHROPIC_API_KEY` may shadow it (childEnvPlan's second rule). It is read
750
+ // from the same credential file `claudeProStatus` reports on, and a failure
751
+ // to read it must NOT weaken the child's env: an unreadable file means "no
752
+ // subscription proven", which is the old behaviour, not a crash mid-turn.
753
+ let hasSubscription = false;
754
+ try {
755
+ hasSubscription = !!claudeProStatus({ env: baseEnv }).subscriptionPresent;
756
+ } catch {
757
+ /* unprovable subscription → the floor-only rule, exactly as before */
758
+ }
759
+ const plan = childEnvPlan(baseEnv, token, { hasSubscription });
637
760
  const childEnv = plan.env;
638
761
  const droppedLine = envDroppedLine(plan.dropped);
639
762
  if (droppedLine && o.onDelta) {
@@ -524,27 +524,43 @@ const EFFORT_TOKEN_BUDGET = { low: 8192, medium: 16384, high: 32768 };
524
524
  /**
525
525
  * DeepSeek native reasoning level per config rung.
526
526
  *
527
- * The field is `reasoning_effort`, NOT `effort`. Verified live 2026-10-02: a
528
- * DeepSeek body carrying `effort` returns HTTP 200 and is ignored, while
529
- * `reasoning_effort` binds and rejects an unknown value with a 422 naming its
530
- * enum (none|minimal|low|medium|high|xhigh|ultra|max). Behaviourally,
531
- * `reasoning_effort:"none"` produced 0 reasoning_content chars and `"max"`
532
- * produced 138, whereas `effort:"none"` still produced 112 — thinking stayed
533
- * on. So the old field was inert on every turn, and inertness is the worst
534
- * failure here: it 200s, nothing surfaces, and the model merely thinks at the
535
- * wrong depth.
527
+ * The field is `effort`, NOT `reasoning_effort`. Verified live 2026-10-21
528
+ * against the surface this client actually reaches — the relay's
529
+ * `https://api.deepseek.com/anthropic` transport — by measuring output tokens
530
+ * over interleaved paired samples (n=12) against an absent-field baseline:
536
531
  *
537
- * Every rung of the knob has a namesake in that enum, so the map is 1:1 rather
538
- * than the earlier (low|max, no medium) fold, which rested on the mistaken
539
- * belief that DeepSeek had no `medium`. `max_tokens` (EFFORT_TOKEN_BUDGET)
540
- * still scales as the output ceiling, since hidden chain-of-thought shares that
541
- * budget on DeepSeek.
532
+ * absent 818 · low 772 · medium 836 · high 818 · max 1494
542
533
  *
543
- * Mirrors the upstream engine's src/backend.js DEEPSEEK_EFFORT verbatim;
544
- * desktop/renderer/budget.js carries the renderer's copy for the same
545
- * no-drift guarantee as DEEPSEEK_REASONING_MODEL_RE above.
534
+ * Only `max` separates from sending nothing. `GET /models` reports
535
+ * `supported_levels: ["low","high","max"]`, default `high`, on both live ids
536
+ * (`deepseek-flash`, `deepseek-v4-pro`) — so `medium` is not a level these
537
+ * models have. It passes the deserializer (unknown values *do* 422 with the
538
+ * enum, so validation is real) and is then absorbed into the default, which is
539
+ * this codebase's worst failure mode: a 200, nothing surfaced, and the model
540
+ * thinking at a depth nobody chose.
541
+ *
542
+ * What the earlier version of this comment asserted — that `reasoning_effort`
543
+ * binds and `effort` is ignored — was measured on the vendor's OpenAI-shaped
544
+ * `/chat/completions`, a surface this client never reaches, and it led to the
545
+ * knob being dead end-to-end: aegis1 forwards `reasoning_effort` only for
546
+ * BYOK_REASONING_EFFORT_PROVIDERS (openai/groq/gemini/grok — deepseek is
547
+ * absent), so the field was dropped at the relay. The `effort` channel is the
548
+ * one aegis1 gates on `provider_id == "deepseek"` (app.py) and that the
549
+ * Anthropic adapter nests as `output_config.effort`; it is the only channel
550
+ * that reaches the vendor, and the only one that measurably binds.
551
+ *
552
+ * The map folds `medium` upward for the same reason the Gemini row does: the
553
+ * vendor has no such level, and a rung that 200s while doing nothing is worse
554
+ * than one that says what it does. `max` is deliberately NOT reachable — it is
555
+ * not a rung of this knob, and mapping the default rung onto it would silently
556
+ * multiply reasoning spend on every turn nobody asked to deepen.
557
+ * `max_tokens` (EFFORT_TOKEN_BUDGET) still scales as the output ceiling, since
558
+ * hidden chain-of-thought shares that budget on DeepSeek.
559
+ *
560
+ * desktop/renderer/budget.js carries the renderer's copy; test/budget.test.mjs
561
+ * compares the two tables, so the mirror cannot drift silently.
546
562
  */
547
- const DEEPSEEK_EFFORT = { low: 'low', medium: 'medium', high: 'high' };
563
+ const DEEPSEEK_EFFORT = { low: 'low', medium: 'high', high: 'high' };
548
564
 
549
565
  /**
550
566
  * Per-family effort translation, mirroring the upstream engine's
@@ -565,7 +581,7 @@ const DEEPSEEK_EFFORT = { low: 'low', medium: 'medium', high: 'high' };
565
581
  const EFFORT_IDENTITY = { low: 'low', medium: 'medium', high: 'high' };
566
582
  const EFFORT_INERT_RE = /non-reasoning/i;
567
583
  const EFFORT_DIALECTS = [
568
- { provider: 'deepseek', re: DEEPSEEK_REASONING_MODEL_RE, field: 'reasoning_effort', map: DEEPSEEK_EFFORT },
584
+ { provider: 'deepseek', re: DEEPSEEK_REASONING_MODEL_RE, field: 'effort', map: DEEPSEEK_EFFORT },
569
585
  { provider: 'openai', re: /^(gpt-5|o[0-9])/i, field: 'reasoning_effort', map: EFFORT_IDENTITY },
570
586
  { provider: 'groq', re: /^(openai\/gpt-oss|qwen\/qwen3)/i, field: 'reasoning_effort', map: EFFORT_IDENTITY },
571
587
  { provider: 'xai', re: /^grok-(4\.[5-9]|[5-9])/, field: 'reasoning_effort', map: EFFORT_IDENTITY },
@@ -1967,8 +1983,8 @@ function createLocalEngine({
1967
1983
  const { provider, model: bareModel } = splitByokModel(opts.model);
1968
1984
  // Translate the rung for THIS vendor once, and carry the verdict rather
1969
1985
  // than a bare level: the relay validates strictly upstream and the field
1970
- // name is not portable (DeepSeek's OpenAI-compatible surface takes
1971
- // `reasoning_effort`, same spelling as OpenAI's). Undefined for a family
1986
+ // name is not portable (DeepSeek's `/anthropic` transport takes `effort`,
1987
+ // OpenAI-shaped vendors take `reasoning_effort`). Undefined for a family
1972
1988
  // with no dialect, which the transport then omits entirely.
1973
1989
  const effort = nativeEffort(provider, bareModel, opts.effort);
1974
1990
  try {
@@ -1999,10 +2015,16 @@ function createLocalEngine({
1999
2015
  toolChoice: opts.toolChoice,
2000
2016
  // Native effort knob, field and level both from the dialect table.
2001
2017
  // `bareModel` is already provider-less, so it matches the dialect
2002
- // regexes without further stripping. Only a dialect whose field is
2003
- // `reasoning_effort` is forwarded: DeepSeek used to ride a separate
2004
- // `effort` body key, which the API 200s and ignores, so that whole
2005
- // second channel is gone rather than left as a way to reintroduce it.
2018
+ // regexes without further stripping. Both wire channels are live, and
2019
+ // which one is used is the dialect's decision, not this call site's:
2020
+ // DeepSeek's `/anthropic` transport takes `effort` (aegis1 gates it on
2021
+ // provider_id == "deepseek" and the adapter nests it as
2022
+ // `output_config.effort`), while the OpenAI-shaped vendors take
2023
+ // `reasoning_effort`. Routing on the field name is what keeps a
2024
+ // dialect from being silently dropped here — the previous form
2025
+ // forwarded only `reasoning_effort`, so turning DeepSeek's dialect
2026
+ // over to `effort` would have died at this line.
2027
+ effort: effort && effort.field === 'effort' ? effort.level : undefined,
2006
2028
  reasoningEffort: effort && effort.field === 'reasoning_effort' ? effort.level : undefined,
2007
2029
  stream: true,
2008
2030
  onStream: opts.onDelta,