@getmegabrain/cli 0.1.10 → 0.1.12

package/dist/science/agent/model.js

@@ -4,43 +4,89 @@
  * `ModelClient` so the transport is swappable; in production it's the Gateway
  * (`/api/gateway/v1/messages`) authenticated with the signed-in account token.
  */
+import { DEFAULT_MODEL } from './models.js';
+/** Transient HTTP statuses worth retrying: overload (429/529), gateway/upstream (500/502/503/504),
+ *  and request timeout (408). A 503 "temporarily_unavailable" from the Gateway lands here. */
+const RETRYABLE_STATUSES = new Set([408, 429, 500, 502, 503, 504, 529]);
 export class GatewayModel {
     url;
     apiKey;
     model;
     maxTokens;
+    maxRetries;
+    retryBaseMs;
+    sleep;
     constructor(options) {
         this.url =
             options.url ??
                 process.env.MB_GATEWAY_URL ??
                 `${(process.env.MEGABRAIN_APP_URL ?? 'https://getmegabrain.com').replace(/\/+$/, '')}/api/gateway/v1/messages`;
         this.apiKey = options.apiKey;
-        this.model = options.model ?? process.env.MB_SCIENCE_MODEL ?? 'claude-opus-4-8';
+        this.model = options.model ?? DEFAULT_MODEL;
         this.maxTokens = options.maxTokens ?? 4096;
+        this.maxRetries = options.maxRetries ?? 4;
+        this.retryBaseMs = options.retryBaseMs ?? 800;
+        this.sleep = options.sleep ?? (ms => new Promise(resolve => setTimeout(resolve, ms)));
+    }
+    /** Backoff for a given attempt (0-indexed): exponential + jitter, honoring Retry-After. */
+    backoffMs(attempt, retryAfter) {
+        const headerSeconds = retryAfter ? Number(retryAfter) : NaN;
+        if (Number.isFinite(headerSeconds) && headerSeconds >= 0) {
+            return Math.min(headerSeconds * 1000, 30_000);
+        }
+        const base = this.retryBaseMs * 2 ** attempt;
+        return Math.min(base, 15_000) + Math.floor(Math.random() * 250);
     }
     async complete(request) {
         if (!this.apiKey)
             throw new Error('Sign in to MegaBrain to use the agent.');
-        const response = await fetch(this.url, {
-            method: 'POST',
-            headers: {
-                'content-type': 'application/json',
-                authorization: `Bearer ${this.apiKey}`,
-                'anthropic-version': '2023-06-01',
-            },
-            body: JSON.stringify({
-                model: this.model,
-                max_tokens: this.maxTokens,
-                system: request.system,
-                messages: request.messages,
-                tools: request.tools,
-            }),
+        const body = JSON.stringify({
+            model: this.model,
+            max_tokens: this.maxTokens,
+            system: request.system,
+            messages: request.messages,
+            tools: request.tools,
         });
-        if (!response.ok) {
-            const detail = await response.text();
-            throw new Error(`Gateway request failed (${response.status}): ${detail.slice(0, 500)}`);
+        let lastError = '';
+        for (let attempt = 0; attempt <= this.maxRetries; attempt += 1) {
+            let response;
+            try {
+                response = await fetch(this.url, {
+                    method: 'POST',
+                    headers: {
+                        'content-type': 'application/json',
+                        authorization: `Bearer ${this.apiKey}`,
+                        'anthropic-version': '2023-06-01',
+                    },
+                    body,
+                });
+            }
+            catch (error) {
+                // Network-level failure (DNS, connection reset) — treat as transient.
+                lastError = `network error: ${error instanceof Error ? error.message : String(error)}`;
+                if (attempt < this.maxRetries) {
+                    await this.sleep(this.backoffMs(attempt));
+                    continue;
+                }
+                throw new Error(`Gateway request failed (${lastError}) after ${attempt + 1} attempts`);
+            }
+            if (response.ok) {
+                const data = (await response.json());
+                return { content: data.content ?? [], stopReason: data.stop_reason ?? 'end_turn' };
+            }
+            const detail = (await response.text()).slice(0, 500);
+            if (RETRYABLE_STATUSES.has(response.status)) {
+                lastError = `${response.status}: ${detail}`;
+                if (attempt < this.maxRetries) {
+                    await this.sleep(this.backoffMs(attempt, response.headers.get('retry-after')));
+                    continue;
+                }
+                // Transient, but out of retries.
+                throw new Error(`Gateway request failed (${lastError}) after ${attempt + 1} attempts`);
+            }
+            throw new Error(`Gateway request failed (${response.status}): ${detail}`);
         }
-        const data = (await response.json());
-        return { content: data.content ?? [], stopReason: data.stop_reason ?? 'end_turn' };
+        // Unreachable: the loop always returns or throws. Present for exhaustiveness.
+        throw new Error(`Gateway request failed (${lastError})`);
     }
 }

package/dist/science/agent/models.js

@@ -0,0 +1,88 @@
+/**
+ * Model picker source for MegaBrain Science. The list of selectable models is the owner-mode
+ * picker the Gateway serves from the `megabrain_model_map` table (curated `mb-auto/*` tiers +
+ * the concrete OmniRoute coding models) — fetched live from `/api/gateway/models` with the
+ * signed-in token. If that fetch fails we fall back to a small hardcoded mirror so the picker
+ * is never empty. The old default (`claude-opus-4-8`) is no longer served and returned 503s;
+ * the default is now a live Auto tier.
+ */
+/** Live default: the "frontier" Auto tier — the most capable routing for research work. */
+export const DEFAULT_MODEL = process.env.MB_SCIENCE_MODEL ?? 'mb-auto/frontier';
+// A minimal mirror of the live picker, used only when the Gateway list can't be fetched.
+// The live Auto tiers are frontier + free (consolidated in #299); the concrete OmniRoute
+// coding models stay pickable via megabrain_model_map.
+export const FALLBACK_MODELS = [
+    { id: 'mb-auto/frontier', label: 'Auto · Frontier' },
+    { id: 'mb-auto/free', label: 'Auto · Free' },
+    { id: 'moonshotai/kimi-k2.7-code', label: 'Kimi K2.7 Code' },
+    { id: 'z-ai/glm-5.2', label: 'GLM-5.2' },
+    { id: 'minimax/minimax-m3', label: 'MiniMax M3' },
+];
+function gatewayModelsUrl() {
+    if (process.env.MB_GATEWAY_MODELS_URL)
+        return process.env.MB_GATEWAY_MODELS_URL;
+    const base = (process.env.MEGABRAIN_APP_URL ?? 'https://getmegabrain.com').replace(/\/+$/, '');
+    return `${base}/api/gateway/models`;
+}
+/** Turn a model id into a readable label when the catalogue doesn't provide a name. */
+export function prettyLabel(id) {
+    const autoTier = /^mb-auto\/(.+)$/.exec(id);
+    if (autoTier) {
+        const tier = autoTier[1].replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+        return `Auto · ${tier}`;
+    }
+    const tail = id.includes('/') ? id.slice(id.indexOf('/') + 1) : id;
+    return tail.replace(/[-_]/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+}
+// Auto tiers surface first, most-capable first; unknown ids fall to the end of the Auto block.
+const AUTO_TIER_ORDER = [
+    'mb-auto/frontier',
+    'mb-auto/best-coding',
+    'mb-auto/balanced',
+    'mb-auto/efficient',
+    'mb-auto/small',
+    'mb-auto/free',
+];
+function autoRank(id) {
+    const i = AUTO_TIER_ORDER.indexOf(id);
+    if (i >= 0)
+        return i;
+    return id.startsWith('mb-auto/') ? AUTO_TIER_ORDER.length : Infinity;
+}
+/** Sort so the Auto tiers surface first (most capable first), then the rest alphabetically. */
+function orderModels(models) {
+    return [...models].sort((a, b) => {
+        const ra = autoRank(a.id);
+        const rb = autoRank(b.id);
+        if (ra !== rb)
+            return ra - rb;
+        return a.label.localeCompare(b.label);
+    });
+}
+/**
+ * Fetch the owner-mode picker models from the Gateway. Returns the curated
+ * `megabrain_model_map` set for the signed-in account; falls back to FALLBACK_MODELS
+ * on any error or an empty response.
+ */
+export async function fetchPickerModels(token) {
+    if (!token)
+        return [...FALLBACK_MODELS];
+    try {
+        const response = await fetch(gatewayModelsUrl(), {
+            headers: { authorization: `Bearer ${token}` },
+        });
+        if (!response.ok)
+            return [...FALLBACK_MODELS];
+        const data = (await response.json());
+        const models = (data.data ?? [])
+            .map(m => ({
+            id: String(m.id ?? ''),
+            label: m.name?.trim() || prettyLabel(String(m.id ?? '')),
+        }))
+            .filter(m => m.id);
+        return models.length ? orderModels(models) : [...FALLBACK_MODELS];
+    }
+    catch {
+        return [...FALLBACK_MODELS];
+    }
+}

package/dist/science/pages.js

@@ -316,7 +316,10 @@ export function sessionPage(projectId, sessionId) {
       .composer-inner:focus-within { border-color:var(--accent); }
       textarea#composer { flex:1; border:0; background:transparent; resize:none; color:inherit; font:inherit;
         outline:none; max-height:160px; }
-      .model { font-size:12px; color:var(--muted); align-self:center; white-space:nowrap; }
+      select.model { font-size:12px; color:var(--muted); align-self:center; white-space:nowrap;
+        max-width:180px; border:1px solid var(--border); border-radius:8px; background:var(--panel);
+        padding:5px 8px; font-family:inherit; cursor:pointer; outline:none; }
+      select.model:focus { border-color:var(--accent); }
       #send { border:0; border-radius:10px; background:var(--accent); color:#fff; font:inherit; font-weight:600;
         padding:8px 16px; cursor:pointer; }
       #send:disabled { opacity:.5; cursor:default; }
@@ -336,7 +339,7 @@ export function sessionPage(projectId, sessionId) {
       <div class="composer">
         <div class="composer-inner">
           <textarea id="composer" rows="1" placeholder="Ask anything — the agent runs code locally…"></textarea>
-          <span class="model">Opus 4.8</span>
+          <select class="model" id="model" title="Model"></select>
           <button id="send">Send</button>
         </div>
       </div>

package/dist/science/server.js

@@ -13,6 +13,7 @@ import { ArxivClient, literatureTool, MultiSourceClient } from './agent/literatu
 import { OpenAlexClient } from './agent/openalex.js';
 import { PubMedClient } from './agent/pubmed.js';
 import { GatewayModel } from './agent/model.js';
+import { DEFAULT_MODEL, fetchPickerModels } from './agent/models.js';
 /**
  * The `megabrain science` local daemon's HTTP server. Serves the sign-in hand-off on
  * localhost (docs/megabrain-science/reference/claude-science-flow.md §1.1) and, once signed
@@ -184,6 +185,14 @@ export async function startScienceServer(host = '127.0.0.1') {
             clearCredentials();
             return json(res, { ok: true });
         }
+        // ── Model picker: the live owner-mode models from megabrain_model_map. ──
+        if (path === '/api/models' && method === 'GET') {
+            const creds = readCredentials();
+            if (!creds)
+                return json(res, { error: 'signed-out' }, 401);
+            const models = await fetchPickerModels(creds.token);
+            return json(res, { models, default: DEFAULT_MODEL });
+        }
         // ── Onboarding API (#286). Signed-in only. ──────────────────────────
         if (path === '/api/onboarding') {
             if (!isSignedIn())
@@ -263,11 +272,12 @@ export async function startScienceServer(host = '127.0.0.1') {
                 const prompt = str(b.prompt)?.trim() ?? '';
                 if (!prompt)
                     return json(res, { error: 'prompt-required' }, 400);
+                const model = str(b.model)?.trim() || DEFAULT_MODEL;
                 const session = store.getSession(sid);
                 const project = session ? store.getProject(session.projectId) : null;
                 store.touchSession(sid, session && !session.summary ? { summary: prompt } : undefined);
                 fanout(sid, 'agent', { type: 'user', text: prompt });
-                const agent = new AgentSession(new GatewayModel({ apiKey: creds.token }), [
+                const agent = new AgentSession(new GatewayModel({ apiKey: creds.token, model }), [
                     pythonTool(kernels.get(sid)),
                     literatureTool(new MultiSourceClient([new ArxivClient(), new OpenAlexClient(), new PubMedClient()])),
                 ], evt => fanout(sid, 'agent', evt), project?.agentContext ?? '', store.getMessages(sid));

package/dist/science/session-client.js

@@ -14,7 +14,9 @@
   var composer = $('composer');
   var sendBtn = $('send');
   var kstate = $('kstate');
+  var modelSel = $('model');
   var lastCard = null;
+  var MODEL_KEY = 'mb_sci_model';
 
   function el(tag, cls, text) {
     var e = document.createElement(tag);
@@ -116,6 +118,42 @@
       });
   }
 
+  // ── Model picker: the live owner-mode models (from megabrain_model_map) ──
+  function loadModels() {
+    if (!modelSel) return;
+    fetch('/api/models')
+      .then(function (r) {
+        return r.json();
+      })
+      .then(function (data) {
+        var models = (data && data.models) || [];
+        var saved = null;
+        try {
+          saved = localStorage.getItem(MODEL_KEY);
+        } catch (e) {
+          saved = null;
+        }
+        var want = saved || (data && data.default);
+        modelSel.textContent = '';
+        models.forEach(function (m) {
+          var opt = el('option', null, m.label || m.id);
+          opt.value = m.id;
+          if (m.id === want) opt.selected = true;
+          modelSel.appendChild(opt);
+        });
+        // If the saved/default id wasn't in the list, fall back to the first option.
+        if (models.length && modelSel.selectedIndex < 0) modelSel.selectedIndex = 0;
+        modelSel.addEventListener('change', function () {
+          try {
+            localStorage.setItem(MODEL_KEY, modelSel.value);
+          } catch (e) {
+            /* ignore */
+          }
+        });
+      })
+      .catch(function () {});
+  }
+
   // ── Live event stream ───────────────────────────────────────────────
   function connect() {
     var es = new EventSource('/api/sessions/' + sid + '/events');
@@ -151,7 +189,7 @@
     fetch('/api/sessions/' + sid + '/agent', {
       method: 'POST',
       headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ prompt: text }),
+      body: JSON.stringify({ prompt: text, model: modelSel ? modelSel.value : undefined }),
     }).catch(function () {
       setRunning(false);
     });
@@ -199,6 +237,7 @@
     .catch(function () {})
     .then(function () {
       loadSidebar();
+      loadModels();
       connect();
     });
 })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getmegabrain/cli",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "MegaBrain CLI — sign in once, then code from your terminal via OpenCode wired to the MegaBrain Gateway, or run `megabrain science` for the local research workbench.",
   "license": "MIT",
   "type": "module",