@flame0510/project-aether 1.5.2 → 1.6.1

package/app/api/gateway/provider/route.ts

@@ -11,6 +11,8 @@ import { readProviderKeys, writeProviderKeys } from './keys';
 import { dockerUnreachableReason, syncAllAgents, type SyncOutcome } from '../sync';
 import { detectProviderGatewayUrl } from '@/lib/docker-utils';
 import { getPricing } from '@/lib/model-pricing';
+import { getModelParams } from '@/lib/model-details';
+import { PROVIDER_LABELS } from '@/lib/provider-labels';
 import { loadModelsConfig, toggleModelOverride, type ModelConfigEntry } from '@/lib/model-catalogue';
 import { getLivePricing } from '@/lib/openrouter-pricing';
 import { requireAuthJWT } from '@/lib/rev4a-auth';
@@ -33,70 +35,70 @@ interface ProviderEnvConfig {
 const PROVIDER_CONFIGS: Record<string, ProviderEnvConfig> = {
   google: {
     envKey: 'PROVIDER_GOOGLE_API_KEY',
-    label: 'Google Gemini',
+    label: PROVIDER_LABELS.google,
     baseUrl: 'https://generativelanguage.googleapis.com/v1beta/openai',
     authHeader: 'x-goog-api-key',
     docsUrl: 'https://aistudio.google.com/app/apikey',
   },
   deepseek: {
     envKey: 'PROVIDER_DEEPSEEK_API_KEY',
-    label: 'DeepSeek',
+    label: PROVIDER_LABELS.deepseek,
     baseUrl: 'https://api.deepseek.com',
     authHeader: 'Authorization',
     docsUrl: 'https://platform.deepseek.com/api_keys',
   },
   openrouter: {
     envKey: 'PROVIDER_OPENROUTER_API_KEY',
-    label: 'OpenRouter',
+    label: PROVIDER_LABELS.openrouter,
     baseUrl: 'https://openrouter.ai/api',
     authHeader: 'Authorization',
     docsUrl: 'https://openrouter.ai/keys',
   },
   openai: {
     envKey: 'PROVIDER_OPENAI_API_KEY',
-    label: 'OpenAI',
+    label: PROVIDER_LABELS.openai,
     baseUrl: 'https://api.openai.com',
     authHeader: 'Authorization',
     docsUrl: 'https://platform.openai.com/api-keys',
   },
   anthropic: {
     envKey: 'PROVIDER_ANTHROPIC_API_KEY',
-    label: 'Anthropic',
+    label: PROVIDER_LABELS.anthropic,
     baseUrl: 'https://api.anthropic.com',
     authHeader: 'x-api-key',
     docsUrl: 'https://console.anthropic.com/settings/keys',
   },
   groq: {
     envKey: 'PROVIDER_GROQ_API_KEY',
-    label: 'Groq',
+    label: PROVIDER_LABELS.groq,
     baseUrl: 'https://api.groq.com/openai',
     authHeader: 'Authorization',
     docsUrl: 'https://console.groq.com/keys',
   },
   kimi: {
     envKey: 'PROVIDER_KIMI_API_KEY',
-    label: 'Kimi',
+    label: PROVIDER_LABELS.kimi,
     baseUrl: 'https://api.moonshot.cn',
     authHeader: 'Authorization',
     docsUrl: 'https://platform.kimi.com/console/api-keys',
   },
   glm: {
     envKey: 'PROVIDER_GLM_API_KEY',
-    label: 'GLM (Z.AI)',
+    label: PROVIDER_LABELS.glm,
     baseUrl: 'https://api.z.ai',
     authHeader: 'Authorization',
     docsUrl: 'https://z.ai/manage-apikey/apikey-list',
   },
   qwen: {
     envKey: 'PROVIDER_QWEN_API_KEY',
-    label: 'Qwen',
+    label: PROVIDER_LABELS.qwen,
     baseUrl: 'https://dashscope.aliyuncs.com',
     authHeader: 'Authorization',
     docsUrl: 'https://bailian.console.aliyun.com/cn-beijing?tab=model#/api-key',
   },
   rev4a: {
     envKey: 'REV4A_API_KEY',
-    label: 'REV4A API KEY',
+    label: PROVIDER_LABELS.rev4a,
     baseUrl: detectProviderGatewayUrl(),
     authHeader: 'Authorization',
     docsUrl: '',
@@ -167,6 +169,9 @@ export async function GET(request: NextRequest) {
   // containers from it, so taking a different one upstream would advertise
   // inputs the agent was never configured to accept.
   const livePricing = await getLivePricing(allModels.map((m) => m.id));
+  // Sizes for the row's "next to the price" hint: open-weight models only (see
+  // docs/dev/GATEWAY.md), absent for a model whose vendor does not publish one.
+  const paramsByModel = getModelParams();
 
   const providers = Object.entries(PROVIDER_CONFIGS).map(([key, cfg]) => {
     const providerModels = allModels.filter((m) => m.provider === key);
@@ -184,6 +189,7 @@ export async function GET(request: NextRequest) {
           if (staticPrice) entry.pricing = staticPrice;
         }
         if (m.modality) entry.modality = m.modality;
+        if (paramsByModel[m.id]) entry.params = paramsByModel[m.id];
         return entry;
       }),
       ...(providerKeys[key] ? { apiKey: providerKeys[key] } : {}),

package/app/api/models/details/route.ts

@@ -0,0 +1,30 @@
+/**
+ * GET /api/models/details?id=<model id>
+ *
+ * Everything the details modal shows for one model: the curated catalogue entry, the
+ * price (and where it is from) and the generated specs, description and benchmarks
+ * (`model-details.json`). Fetched when the modal opens rather than inlined in
+ * `/api/models`, which pages poll: descriptions are long and only one model is looked at
+ * at a time.
+ *
+ * Absent fields are simply absent — the modal hides those blocks instead of printing
+ * "n/a" — and a model the catalogue does not carry is a plain 404.
+ */
+import { NextResponse, type NextRequest } from 'next/server';
+import { requireAuthJWT } from '@/lib/rev4a-auth';
+import { getModelDetails } from '@/lib/model-details';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(request: NextRequest): Promise<NextResponse> {
+  const denied = await requireAuthJWT(request);
+  if (denied) return denied;
+
+  const id = request.nextUrl.searchParams.get('id');
+  if (!id) return NextResponse.json({ error: 'id query param required' }, { status: 400 });
+
+  const details = getModelDetails(id);
+  if (!details) return NextResponse.json({ error: `No model '${id}' in the catalogue` }, { status: 404 });
+
+  return NextResponse.json(details, { headers: { 'Cache-Control': 'no-store' } });
+}

package/app/api/system-health/route.ts

@@ -106,7 +106,7 @@ export async function GET(request: NextRequest): Promise<NextResponse> {
         ? 'Heartbeat metrics unavailable in this DB'
         : latestMetricAgeSeconds === null
           ? 'No heartbeat metrics detected'
-          : `ultimo heartbeat metrics ${latestMetricAgeSeconds}s fa`,
+          : `last heartbeat metrics ${latestMetricAgeSeconds}s ago`,
       source: 'runtime',
     });
 
@@ -157,7 +157,7 @@ export async function GET(request: NextRequest): Promise<NextResponse> {
         severity: 'warning',
         source: 'runtime',
         title: 'Review recent errors',
-        details: `${eventErrorCount} error events nelle ultime 24h.`,
+        details: `${eventErrorCount} error events in the last 24h.`,
         actionHref: '/lineage',
         dismissible: true,
         createdAt,
@@ -181,7 +181,7 @@ export async function GET(request: NextRequest): Promise<NextResponse> {
       label: 'Usage-based cost today',
       health: billing.usageBasedCost > 10 ? 'warning' : 'ok',
       value: `$${billing.usageBasedCost.toFixed(2)}`,
-      details: `DB estimate $${billing.dbEstimatedCost.toFixed(2)}; fixed ${billing.buckets.fixed.sessions} sessioni; credits ${billing.buckets.credits.sessions} sessioni`,
+      details: `DB estimate $${billing.dbEstimatedCost.toFixed(2)}; fixed ${billing.buckets.fixed.sessions} sessions; credits ${billing.buckets.credits.sessions} sessions`,
       source: 'cost',
     });
     if (billing.usageBasedCost > 10) {

package/app/api/update-check/route.ts

@@ -8,15 +8,26 @@ import { requireAuthJWT } from '@/lib/rev4a-auth';
 // package name is the single source of truth, so never hardcode it elsewhere.
 const FALLBACK_PKG_NAME = '@flame0510/project-aether';
 
-function getPackageInfo() {
-  try {
-    // Resolve relative to the project root (two levels above .next)
-    const pkgPath = join(process.cwd(), 'package.json');
-    const raw = readFileSync(pkgPath, 'utf-8');
-    return JSON.parse(raw);
-  } catch {
-    return { version: '0.0.0', name: FALLBACK_PKG_NAME };
+/**
+ * The installed package's name and version. `version` is **null when it cannot be read**
+ * — never a placeholder like `0.0.0`: during `rev4a update` npm rewrites this very file,
+ * and a transient read failure must not look like a version that changed.
+ */
+function getPackageInfo(): { version: string | null; name: string } {
+  // cwd first (systemd sets WorkingDirectory), then relative to this module: a global
+  // install started from elsewhere still finds its own package.json.
+  const candidates = [join(process.cwd(), 'package.json'), join(__dirname, '..', '..', '..', 'package.json')];
+  for (const pkgPath of candidates) {
+    try {
+      const parsed = JSON.parse(readFileSync(pkgPath, 'utf-8')) as { version?: unknown; name?: unknown };
+      const version = typeof parsed.version === 'string' && parsed.version ? parsed.version : null;
+      const name = typeof parsed.name === 'string' && parsed.name ? parsed.name : FALLBACK_PKG_NAME;
+      if (version) return { version, name };
+    } catch {
+      // try the next candidate
+    }
   }
+  return { version: null, name: FALLBACK_PKG_NAME };
 }
 
 interface CachedResult {
@@ -38,15 +49,20 @@ export async function GET(request: Request): Promise<NextResponse> {
   const check = url.searchParams.get('check') === '1';
 
   const pkg = getPackageInfo();
-  const installed = pkg.version || '0.0.0';
+  const installed = pkg.version;
   let latest: string | null = null;
   let updateAvailable = false;
 
-  if (check) {
+  // Nothing to compare when the installed version is unknown: answer that, rather than
+  // offering an update against a placeholder.
+  if (check && installed) {
     const now = Date.now();
     if (cache && now - cache.checkedAt < CACHE_TTL_MS) {
       latest = cache.latest;
-      updateAvailable = cache.updateAvailable;
+      // Recomputed against the version reading us now: `installed` is not cached, and
+      // reusing the cached flag made the banner offer an update that had just been
+      // installed, for up to the cache's fifteen minutes (seen right after an update).
+      updateAvailable = !!latest && latest !== installed;
     } else {
       try {
         const pkgName = pkg.name || FALLBACK_PKG_NAME;

package/app/components/SessionDrawer.tsx

@@ -146,7 +146,7 @@ export default function SessionDrawer({ sessionId, onClose }: SessionDrawerProps
       <button
         type="button"
         onClick={onClose}
-        aria-label="Chiudi"
+        aria-label="Close"
         style={{
           position: 'absolute',
           top: isMobile ? 16 : 14,
@@ -185,9 +185,9 @@ export default function SessionDrawer({ sessionId, onClose }: SessionDrawerProps
                 {session.status ?? 'idle'}
               </Row>
               <Row label="TIPO">
-                {session.session_id.includes(':cron:') ? 'cron' : 'sessione'}
+                {session.session_id.includes(':cron:') ? 'cron' : 'session'}
               </Row>
-              <Row label="MODELLO">{session.model ?? '-'}</Row>
+              <Row label="MODEL">{session.model ?? '-'}</Row>
               <Row label="COSTO">{formatUsdOrDash(session.cost_usd)}</Row>
               <Row label="TOKEN">
                 in: {formatTokens(session.tokens_in)} out: {formatTokens(session.tokens_out)}
@@ -215,7 +215,7 @@ export default function SessionDrawer({ sessionId, onClose }: SessionDrawerProps
             ))}
           </Section>
 
-          <Section title="SESSIONI FIGLIE">
+          <Section title="CHILD SESSIONS">
             {children.length === 0 && <Muted>No child sessions</Muted>}
             {children.map((child) => (
               <div key={child.session_id} style={{ fontSize: 12 }}>

package/app/components/VersionBanner.tsx

@@ -4,46 +4,92 @@
  * "Update available" banner for Rev4a itself.
  *
  * The update is spawned by `POST /api/update-check` and restarts the server, so this
- * component cannot be told the outcome by the response. It records what it asked for,
- * waits for the server to answer again, and on the next mount compares: if the
- * installed version moved it was updated, and if the same update is still offered it
- * did not complete (the log file says why).
+ * component cannot be told the outcome by the response. It records what it asked for and
+ * follows the restart from the browser.
+ *
+ * Three rules learned from the 1.6.0 update (2026-09-23):
+ *  - a **success** is only a version that is *readable* and different. During the update
+ *    npm rewrites `package.json`, and a read that failed used to answer `0.0.0`, which read
+ *    as "the version moved" — the banner said "Updated to v0.0.0" and reloaded mid-install.
+ *  - while the restart is in flight the banner shows an **updating** state, never the
+ *    "Update now" button again: nobody should think the update failed and start it twice.
+ *    A page loaded in that window resumes the wait by itself and reloads when the new
+ *    version answers.
+ *  - the banner never reloads **blindly**: if the version has not moved by the deadline it
+ *    says the update has not finished (it may still be running, or it failed), points at
+ *    `update.log` and offers Retry and Reload.
  */
-import { useEffect, useState } from 'react';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { Button } from '../components/ui';
 
 interface VersionInfo {
-  installed: string;
+  installed: string | null;
   latest: string | null;
   updateAvailable: boolean;
   log?: string;
 }
 
 const DISMISS_KEY = 'rev4a-update-dismissed';
-/** What we asked for and from which version, so the next mount can judge the outcome. */
+/** What we asked for and from which version, so a reload can resume the wait. */
 const PENDING_KEY = 'rev4a-update-pending';
 
-/** How long to poll for the restart before reloading anyway. */
-const WAIT_MS = 120_000;
+/** How long to wait for the restart before saying the update has not finished. */
+const WAIT_MS = 150_000;
+/** How long a recorded request stays believable across reloads. */
+const PENDING_TTL_MS = 15 * 60 * 1000;
 
-interface Pending { target: string; from: string }
+interface Pending { target: string; from: string; at: number }
 
 function readPending(): Pending | null {
   try {
     const raw = sessionStorage.getItem(PENDING_KEY);
     if (!raw) return null;
     const parsed = JSON.parse(raw) as Pending;
-    return parsed && typeof parsed.target === 'string' && typeof parsed.from === 'string' ? parsed : null;
+    if (!parsed || typeof parsed.target !== 'string' || typeof parsed.from !== 'string') return null;
+    return parsed;
   } catch {
     return null;
   }
 }
 
+/** A version we can believe: present and not a placeholder. */
+function usableVersion(v: string | null | undefined): v is string {
+  return typeof v === 'string' && v.length > 0 && v !== '0.0.0';
+}
+
 export default function VersionBanner() {
   const [info, setInfo] = useState<VersionInfo | null>(null);
   const [dismissed, setDismissed] = useState(true);
   const [updating, setUpdating] = useState(false);
   const [updateError, setUpdateError] = useState<string | null>(null);
   const [updateOk, setUpdateOk] = useState<string | null>(null);
+  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  /**
+   * Follow the restart until the server answers with a different, readable version, then
+   * reload. `from` is the version we started from, so a resumed wait knows what to expect.
+   */
+  const followRestart = useCallback((from: string) => {
+    const deadline = Date.now() + WAIT_MS;
+    const poll = async () => {
+      try {
+        const res = await fetch('/api/update-check', { cache: 'no-store' });
+        const d = (await res.json()) as VersionInfo;
+        if (usableVersion(d.installed) && d.installed !== from) {
+          sessionStorage.removeItem(PENDING_KEY);
+          window.location.reload();
+          return;
+        }
+      } catch { /* the server is down for the restart: expected */ }
+      if (Date.now() > deadline) {
+        setUpdating(false);
+        setUpdateError('The update has not finished after a couple of minutes. It may still be running — see update.log, then reload.');
+        return;
+      }
+      timerRef.current = setTimeout(poll, 3000);
+    };
+    timerRef.current = setTimeout(poll, 3000);
+  }, []);
 
   useEffect(() => {
     let active = true;
@@ -52,11 +98,20 @@ export default function VersionBanner() {
       .then((d: VersionInfo) => {
         if (!active) return;
         const pending = readPending();
-        // Back from an update: did the installed version actually move?
-        if (pending && d.installed !== pending.from) {
+        // Back from an update: did a *readable* version actually replace the old one?
+        if (pending && usableVersion(d.installed) && d.installed !== pending.from) {
           sessionStorage.removeItem(PENDING_KEY);
           setUpdateOk(`Updated to v${d.installed}`);
-          setTimeout(() => { if (active) window.location.reload(); }, 2000);
+          setTimeout(() => { if (active) window.location.reload(); }, 2500);
+          return;
+        }
+        if (pending && Date.now() - (pending.at ?? 0) < PENDING_TTL_MS) {
+          // The restart is probably in flight (a page loaded inside that window, or a
+          // reload before the new version answered): resume the wait, show no action.
+          setInfo(d);
+          setDismissed(false);
+          setUpdating(true);
+          followRestart(pending.from);
           return;
         }
         if (pending) {
@@ -64,30 +119,30 @@ export default function VersionBanner() {
           setInfo(d);
           setDismissed(false);
           setUpdateError(
-            `The update to v${pending.target} did not complete: Rev4a is still on v${d.installed}.`
-            + ` See ${d.log ?? 'update.log'} in the Rev4a data directory.`,
+            `The update to v${pending.target} has not finished: ${usableVersion(d.installed) ? `Rev4a is still on v${d.installed}` : 'Rev4a is not answering with a version'}.`
+            + ` See ${d.log ?? 'update.log'} in the Rev4a data directory, then reload.`,
           );
           return;
         }
-        if (d.updateAvailable) {
+        if (d.updateAvailable && usableVersion(d.latest)) {
           setInfo(d);
-          const saved = localStorage.getItem(DISMISS_KEY);
-          setDismissed(saved === d.latest);
+          setDismissed(localStorage.getItem(DISMISS_KEY) === d.latest);
         }
       })
       .catch(() => {});
     return () => { active = false; };
-  }, []);
+  }, [followRestart]);
+
+  // Clear a timer the component no longer owns (unmount or a full reload).
+  useEffect(() => () => { if (timerRef.current) clearTimeout(timerRef.current); }, []);
 
   function handleDismiss() {
-    if (info?.latest) {
-      localStorage.setItem(DISMISS_KEY, info.latest);
-    }
+    if (info?.latest) localStorage.setItem(DISMISS_KEY, info.latest);
     setDismissed(true);
   }
 
   async function handleUpdate() {
-    if (!info) return;
+    if (!info || !usableVersion(info.installed)) return;
     setUpdating(true);
     setUpdateError(null);
     setUpdateOk(null);
@@ -103,31 +158,16 @@ export default function VersionBanner() {
         setUpdating(false);
         return;
       }
-      sessionStorage.setItem(PENDING_KEY, JSON.stringify({ target: info.latest ?? '', from: info.installed }));
+      sessionStorage.setItem(PENDING_KEY, JSON.stringify({ target: info.latest ?? '', from: info.installed, at: Date.now() }));
       localStorage.removeItem(DISMISS_KEY);
-      setUpdateOk('Update started. Rev4a is restarting…');
-      // The server goes down and comes back on the new version: wait for its answer,
-      // then reload. A timeout reloads too — the next mount reports the outcome.
-      const deadline = Date.now() + WAIT_MS;
-      const poll = async () => {
-        if (Date.now() > deadline) { window.location.reload(); return; }
-        try {
-          const r = await fetch('/api/update-check', { cache: 'no-store' });
-          const d = (await r.json()) as VersionInfo;
-          if (d.installed !== info.installed) { window.location.reload(); return; }
-        } catch { /* the server is down for the update: expected */ }
-        setTimeout(poll, 3000);
-      };
-      setTimeout(poll, 3000);
+      followRestart(info.installed);
     } catch (err) {
       setUpdateError(err instanceof Error ? err.message : 'Network error');
       setUpdating(false);
     }
   }
 
-  // The result states stand on their own (there may be no `info` when the update just
-  // succeeded); the "available" state needs the version info and no dismissal.
-  const show = Boolean(updateOk) || Boolean(updateError) || Boolean(info?.updateAvailable && !dismissed);
+  const show = Boolean(updateOk) || Boolean(updateError) || Boolean(updating) || Boolean(info?.updateAvailable && !dismissed);
   if (!show) return null;
 
   return (
@@ -138,30 +178,35 @@ export default function VersionBanner() {
             <span className="update-banner__ok">{updateOk}</span>
           ) : updateError ? (
             <span className="update-banner__err">{updateError}</span>
-          ) : info ? (
+          ) : updating ? (
+            <span className="update-banner__ok">Update started. Rev4a is restarting — this page reloads on its own when the new version answers.</span>
+          ) : (
             <>
               <span className="update-banner__label">Update available</span>
               <span className="update-banner__sep">&mdash;</span>
-              <span className="update-banner__version">v{info.latest}</span>
-              <span className="update-banner__sep">(installed: v{info.installed})</span>
+              <span className="update-banner__version">v{info?.latest}</span>
+              <span className="update-banner__sep">(installed: v{info?.installed})</span>
             </>
-          ) : null}
+          )}
         </span>
 
         {!updateOk && (
           <div className="update-banner__actions">
-            {updateError ? (
-              <button className="ui-btn ui-btn--primary ui-btn--sm" onClick={handleUpdate} disabled={updating}>
-                {updating ? 'Updating…' : 'Retry'}
-              </button>
+            {updating ? (
+              // No action while the restart runs: the only honest one is to wait.
+              <Button variant="ghost" size="sm" onClick={() => window.location.reload()}>Reload</Button>
+            ) : updateError ? (
+              <>
+                <Button variant="primary" size="sm" onClick={handleUpdate}>Retry</Button>
+                <Button variant="secondary" size="sm" onClick={() => window.location.reload()}>Reload</Button>
+                <Button variant="ghost" size="sm" onClick={handleDismiss}>Dismiss</Button>
+              </>
             ) : (
-              <button className="ui-btn ui-btn--primary ui-btn--sm" onClick={handleUpdate} disabled={updating}>
-                {updating ? 'Updating…' : 'Update now'}
-              </button>
+              <>
+                <Button variant="primary" size="sm" onClick={handleUpdate}>Update now</Button>
+                <Button variant="ghost" size="sm" onClick={handleDismiss}>Dismiss</Button>
+              </>
             )}
-            <button className="ui-btn ui-btn--ghost ui-btn--sm" onClick={handleDismiss}>
-              Dismiss
-            </button>
           </div>
         )}
       </div>

package/app/components/ui/Metric.tsx

@@ -9,11 +9,16 @@ interface MetricProps {
   subtitle?: ReactNode;
   tone?: Tone;
   loading?: boolean;
+  /**
+   * `sm` is the compact form for grids inside a dialog or a dense panel: same anatomy,
+   * smaller value and tighter spacing, so four of them fit on one line.
+   */
+  size?: 'md' | 'sm';
 }
 
-export function Metric({ title, value, subtitle, tone = 'neutral', loading = false }: MetricProps) {
+export function Metric({ title, value, subtitle, tone = 'neutral', loading = false, size = 'md' }: MetricProps) {
   return (
-    <Surface as="article" tone={tone}>
+    <Surface as="article" tone={tone} className={size === 'sm' ? 'ui-metric--sm' : undefined}>
       <div className="ui-kicker">{title}</div>
       <div className="ui-metric-value">{loading ? <SkeletonMetric /> : value}</div>
       {subtitle !== undefined && <div className="ui-muted ui-metric-subtitle">{loading ? <SkeletonLines count={1} /> : subtitle}</div>}