aegis-desktop 0.8.17 → 0.8.19

package/lib/local/engine.js

@@ -240,6 +240,57 @@ function providerKeyFromEnv(provider) {
 const DEEPSEEK_REASONING_MODEL_RE = /^deepseek-(v4(\.\d+)?-(flash|pro)|flash|pro|reasoner)$/;
 const EFFORT_TOKEN_BUDGET = { low: 8192, medium: 16384, high: 32768 };
 
+/**
+ * DeepSeek native reasoning level per config rung.
+ *
+ * The field is `reasoning_effort`, NOT `effort`. Verified live 2026-10-02: a
+ * DeepSeek body carrying `effort` returns HTTP 200 and is ignored, while
+ * `reasoning_effort` binds and rejects an unknown value with a 422 naming its
+ * enum (none|minimal|low|medium|high|xhigh|ultra|max). Behaviourally,
+ * `reasoning_effort:"none"` produced 0 reasoning_content chars and `"max"`
+ * produced 138, whereas `effort:"none"` still produced 112 — thinking stayed
+ * on. So the old field was inert on every turn, and inertness is the worst
+ * failure here: it 200s, nothing surfaces, and the model merely thinks at the
+ * wrong depth.
+ *
+ * Every rung of the knob has a namesake in that enum, so the map is 1:1 rather
+ * than the earlier (low|max, no medium) fold, which rested on the mistaken
+ * belief that DeepSeek had no `medium`. `max_tokens` (EFFORT_TOKEN_BUDGET)
+ * still scales as the output ceiling, since hidden chain-of-thought shares that
+ * budget on DeepSeek.
+ *
+ * Mirrors the upstream engine's src/backend.js DEEPSEEK_EFFORT verbatim;
+ * desktop/renderer/budget.js carries the renderer's copy for the same
+ * no-drift guarantee as DEEPSEEK_REASONING_MODEL_RE above.
+ */
+const DEEPSEEK_EFFORT = { low: 'low', medium: 'medium', high: 'high' };
+
+/**
+ * Per-family effort translation, mirroring the upstream engine's
+ * EFFORT_DIALECTS. The knob is one rung here (low|medium|high) but it is NOT
+ * portable across vendors, and passing it through untranslated is a correctness
+ * bug rather than a no-op: Groq 400s any level outside a model's supported set,
+ * and Gemini 3 fails on `medium` outright while low/high succeed. So each
+ * family states its own wire field and level map, and a family with no such
+ * field gets NOTHING — an unknown body field either 400s or is silently
+ * dropped, and both are worse than stating no opinion.
+ *
+ * xAI's `*-non-reasoning` row is left alone entirely: the model exists to not
+ * reason, and sending it an effort field is precisely the request the user
+ * picked that row to avoid. grok-4.20 and gemini-2.0 stay bare too — no
+ * documented level field exists for them, and guessing on a strict validator
+ * is a 400 rather than an upgrade.
+ */
+const EFFORT_IDENTITY = { low: 'low', medium: 'medium', high: 'high' };
+const EFFORT_INERT_RE = /non-reasoning/i;
+const EFFORT_DIALECTS = [
+  { provider: 'deepseek', re: DEEPSEEK_REASONING_MODEL_RE, field: 'reasoning_effort', map: DEEPSEEK_EFFORT },
+  { provider: 'openai', re: /^(gpt-5|o[0-9])/i, field: 'reasoning_effort', map: EFFORT_IDENTITY },
+  { provider: 'groq', re: /^(openai\/gpt-oss|qwen\/qwen3)/i, field: 'reasoning_effort', map: EFFORT_IDENTITY },
+  { provider: 'xai', re: /^grok-(4\.[5-9]|[5-9])/, field: 'reasoning_effort', map: EFFORT_IDENTITY },
+  { provider: 'google', re: /^gemini-(2\.5|3|[4-9])/, field: 'reasoning_effort', map: { ...EFFORT_IDENTITY, medium: 'high' } },
+];
+
 /**
  * Idle-stream budget for a pooled brain call ("work autonomously"). The
  * generic watchdog in vendor/aegis.js kills a stream that goes 60s without a
@@ -296,6 +347,24 @@ function reasoningBudget(model, maxTokens, effort) {
   return undefined;
 }
 
+/**
+ * The native effort verdict for this provider+model: `{ field, level }`, or
+ * `undefined` when the family has no effort knob. `undefined` means "say
+ * nothing", never "send a default" — inventing a level is how the knob silently
+ * overrides the vendor's own default. Supersedes the DeepSeek-only
+ * deepseekEffort() it replaces: same DeepSeek mapping, now stated for every
+ * family that has one instead of only the one that used to be wired.
+ */
+function nativeEffort(provider, model, effort) {
+  const m = String(model || '');
+  if (EFFORT_INERT_RE.test(m)) return undefined;
+  const eff = effort === 'low' || effort === 'medium' ? effort : 'high';
+  for (const d of EFFORT_DIALECTS) {
+    if (d.provider === provider && d.re.test(m)) return { field: d.field, level: d.map[eff] };
+  }
+  return undefined;
+}
+
 /** Relay model entries arrive as ids or objects; keep only real model ids. */
 function normalizeCatalog(models) {
   if (!Array.isArray(models)) return [];
@@ -307,35 +376,32 @@ function normalizeCatalog(models) {
 /**
  * The Aegis Cloud (pooled) dropdown.
  *
- * It offers NO aegiscloud model. The catalog (`/api/v1/models`) lists
- * per-provider ids (`deepseek`, `anthropic`, `groq`, `openai`, ...) alongside
- * five pooled-brain tier spellings (`{aegis,nexus}-brain[-smart|-neo]`) that all
- * route the same worker pool, and this host must offer neither: "omit the
- * aegiscloud models" is the instruction, and a host that omitted the brain row
- * while leaving `deepseek` on screen would have kept exactly the per-provider
- * pin the Aegis Cloud policy is about. The class stays selectable and its
- * dropdown keeps the "server default (auto)" row, so the pooled lane still runs
- * — it just advertises nothing to pin.
+ * It offers the server's whole catalog (`/api/v1/models`): the pooled brain
+ * first, under its one name (Nexus), then every per-provider id the account can
+ * pin (`deepseek`, `anthropic`, `groq`, `openai`, ...).
+ *
+ * Two narrower shapes were shipped here and both are reverted, because both
+ * produced the same report — a user asking where the models went. First the
+ * class collapsed to a single "Nexus" row (`filterAegisCatalog`), which ended
+ * the two-host disagreement about the brain's five tier spellings by removing
+ * the choice: a funded account had `deepseek` advertised to it and no way to
+ * pin it. Then it offered nothing at all — `omitAegisCloudModels` composed with
+ * that collapse returns `[]`, because the omission removes the only entry the
+ * collapse looks for. The rule both hosts call now is `offerableCatalog`:
+ * everything the server advertises, the tier spellings folded into the one row
+ * they point at.
  *
  * What is NOT changed: the account key, and everything the key is *for* — the
  * pooled turn itself, cloud memory sync, and the BYOK handling fee that is
- * billed to this account (see the byok branch below, which still offers every
- * provider id the server's catalog names). Omitting a model list is not
- * disconnecting the lane.
- *
- * The omission itself is one shared rule (`omitAegisCloudModels`, and the
- * collapse it is composed with) in `client/brain-catalog.js`, shared with the
- * CLI: two copies is how this host and the terminal previously came to offer
- * the same account two different model lists. Resolved the two ways this repo
- * resolves every shared module — repo-relative in a checkout, and this app's
- * staged vendor/ tree.
+ * billed to this account (see the byok branch below).
  *
- * `filterAegisCatalog` is kept in the composition rather than dropped for the
- * shorter `models: []`: a payload with no brain tier at all (a self-hosted or
- * trimmed deployment) must still yield nothing here rather than leaking its
- * per-provider ids, and that is precisely the case the collapse already answers.
+ * The list itself is one shared rule in `client/brain-catalog.js`, shared with
+ * the CLI: two copies is how this host and the terminal previously came to
+ * offer the same account two different model lists. Resolved the two ways this
+ * repo resolves every shared module — repo-relative in a checkout, and this
+ * app's staged vendor/ tree.
  */
-const { filterAegisCatalog, omitAegisCloudModels } = requireSharedBrain();
+const { offerableCatalog } = requireSharedBrain();
 
 /**
  * The BYOK additions, applied to the server's provider catalog below. Same
@@ -744,7 +810,7 @@ function createLocalEngine({
     // direction too: a path wrongly claimed stops being reported as foreign.
     const result = await T.executeTool(name, args, toolCtx);
     if (guard && (name === 'writeFile' || name === 'editFile') && result && result.ok !== false) {
-      recordWrite(guard, args && args.path);
+      recordWrite(guard, args && args.file_path);
     }
     return result;
   }
@@ -793,7 +859,7 @@ function createLocalEngine({
       // unconditionally, making every line below it unreachable — the
       // approved-write path recorded nothing at all.)
       if (res && res.ok !== false && toolCtx && toolCtx.guard) {
-        recordWrite(toolCtx.guard, args && args.path);
+        recordWrite(toolCtx.guard, args && args.file_path);
       }
       return res;
     }
@@ -855,20 +921,16 @@ function createLocalEngine({
       // entry so the class is usable the moment a key lands.
       if (!aegis.apiKey) return { class: cls, models: [], needsKey: true };
       const data = await aegis.listModels();
-      // No aegiscloud model is offered — see the rule above. The class, the
-      // auto row and the pooled turn are untouched; only the pinnable list is
-      // emptied, which is why `needsKey` keeps its meaning and the renderer's
-      // hint for this class is unchanged.
+      // The whole catalog, aliases folded — see the rule above. What the list
+      // contains does not touch `needsKey` or the renderer's per-class hint.
       return {
         class: cls,
-        // Omit FIRST, then collapse: the omission has to see the payload's own
-        // `alias_of` bookkeeping, which the collapse deliberately strips (a
-        // collapsed row IS the selection, so a renderer must not filter it back
-        // out as a hidden alias). Filtering a collapsed row instead would leave
-        // a renamed tier — `nexus-brain-v2`, an alias OF the brain under a
-        // spelling this release has never seen — on screen, which is the one
-        // case the rule exists to catch.
-        models: filterAegisCatalog(omitAegisCloudModels(normalizeCatalog(data && data.models))),
+        // One call, because the folding has to see the payload's own `alias_of`
+        // bookkeeping: a pre-collapsed row IS the selection, so a renderer must
+        // not filter it back out as a hidden alias, and folding what has already
+        // been folded would leave a renamed tier (`nexus-brain-v2`, an alias OF
+        // the brain under a spelling this release has never seen) on screen.
+        models: offerableCatalog(normalizeCatalog(data && data.models)),
       };
     }
     if (cls === 'byok') {
@@ -1153,6 +1215,12 @@ function createLocalEngine({
       // automatically by byokChatCompletion() as X-AEGIS-Key so the account
       // gets billed the handling fee; see client/aegis.js.
       const { provider, model: bareModel } = splitByokModel(opts.model);
+      // Translate the rung for THIS vendor once, and carry the verdict rather
+      // than a bare level: the relay validates strictly upstream and the field
+      // name is not portable (DeepSeek's OpenAI-compatible surface takes
+      // `reasoning_effort`, same spelling as OpenAI's). Undefined for a family
+      // with no dialect, which the transport then omits entirely.
+      const effort = nativeEffort(provider, bareModel, opts.effort);
       try {
         return await aegis.byokChatCompletion({
           provider,
@@ -1162,6 +1230,13 @@ function createLocalEngine({
           system: opts.system,
           messages: opts.messages,
           maxTokens: opts.maxTokens,
+          // Native effort knob, field and level both from the dialect table.
+          // `bareModel` is already provider-less, so it matches the dialect
+          // regexes without further stripping. Only a dialect whose field is
+          // `reasoning_effort` is forwarded: DeepSeek used to ride a separate
+          // `effort` body key, which the API 200s and ignores, so that whole
+          // second channel is gone rather than left as a way to reintroduce it.
+          reasoningEffort: effort && effort.field === 'reasoning_effort' ? effort.level : undefined,
           stream: true,
           onStream: opts.onDelta,
           signal: opts.signal,
@@ -1863,4 +1938,4 @@ function createLocalEngine({
   };
 }
 
-module.exports = { CLASSES, createLocalEngine, extractToolCalls, parseArgs, reasoningBudget };
+module.exports = { CLASSES, createLocalEngine, extractToolCalls, parseArgs, reasoningBudget, nativeEffort };