@getmegabrain/cli 0.1.11 → 0.1.13

package/dist/science/agent/model.js

@@ -4,6 +4,7 @@
  * `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]);
@@ -21,7 +22,7 @@ export class GatewayModel {
                 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;

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/queue.js

@@ -0,0 +1,23 @@
+/**
+ * A per-key serial task queue. Tasks enqueued under the same key run strictly one after
+ * another (in enqueue order); tasks under different keys run independently.
+ *
+ * The Science daemon uses this to serialize agent turns per session: without it, sending
+ * several messages in quick succession spawns overlapping AgentSessions that share one
+ * kernel and race on the persisted transcript — so turns clobber each other and messages
+ * appear "unseen". Serializing means each turn starts only after the previous finished and
+ * therefore reads the prior turn's saved history.
+ */
+export function createKeyedQueue() {
+    const tails = new Map();
+    return function enqueue(key, task) {
+        const prev = tails.get(key) ?? Promise.resolve();
+        // Run `task` after the previous one settles — on both fulfill and reject, so a failed
+        // turn never blocks the queue.
+        const result = prev.then(task, task);
+        // The tail we chain the *next* task onto must never reject (that would skip the catch
+        // handler on subsequent tasks); swallow it here. Callers still see `result`'s outcome.
+        tails.set(key, result.catch(() => undefined));
+        return result;
+    };
+}

package/dist/science/server.js

@@ -13,6 +13,8 @@ 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';
+import { createKeyedQueue } from './queue.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
@@ -33,6 +35,9 @@ export async function startScienceServer(host = '127.0.0.1') {
     // flow to every browser watching a session, tagged with a `channel`.
     const sseClients = new Map();
     const kernelHooked = new Set();
+    // Serialize agent turns per session so rapid messages are handled in order (each seeing the
+    // previous turn's history) instead of racing on the shared kernel and transcript.
+    const agentQueue = createKeyedQueue();
     const fanout = (sid, channel, payload) => {
         const set = sseClients.get(sid);
         if (!set)
@@ -184,6 +189,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,17 +276,29 @@ 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 session = store.getSession(sid);
-                const project = session ? store.getProject(session.projectId) : null;
-                store.touchSession(sid, session && !session.summary ? { summary: prompt } : undefined);
+                const model = str(b.model)?.trim() || DEFAULT_MODEL;
+                const token = creds.token;
+                // Echo the user's message immediately so it shows up in order, then run the turn on the
+                // per-session queue. The turn reads history *at run time* so it includes any turn that
+                // was still in flight when this message arrived.
                 fanout(sid, 'agent', { type: 'user', text: prompt });
-                const agent = new AgentSession(new GatewayModel({ apiKey: creds.token }), [
-                    pythonTool(kernels.get(sid)),
-                    literatureTool(new MultiSourceClient([new ArxivClient(), new OpenAlexClient(), new PubMedClient()])),
-                ], evt => fanout(sid, 'agent', evt), project?.agentContext ?? '', store.getMessages(sid));
-                // Persist the full history when the turn ends, so the session remembers it and the
-                // transcript survives a refresh.
-                void agent.run(prompt).finally(() => store.setMessages(sid, agent.getMessages()));
+                void agentQueue(sid, async () => {
+                    const session = store.getSession(sid);
+                    const project = session ? store.getProject(session.projectId) : null;
+                    store.touchSession(sid, session && !session.summary ? { summary: prompt } : undefined);
+                    const agent = new AgentSession(new GatewayModel({ apiKey: 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));
+                    try {
+                        await agent.run(prompt);
+                    }
+                    finally {
+                        // Persist the full history so the session remembers it and the transcript survives
+                        // a refresh — and so the next queued turn reads it as its starting point.
+                        store.setMessages(sid, agent.getMessages());
+                    }
+                });
                 return json(res, { ok: true });
             }
         }

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);
@@ -77,9 +79,13 @@
     scroll();
   }
 
+  // Track how many turns are in flight. The send button stays enabled so you can queue
+  // follow-up messages while the agent works — the server runs them in order per session.
+  var pending = 0;
   function setRunning(on) {
-    sendBtn.disabled = on;
-    sendBtn.textContent = on ? 'Running…' : 'Send';
+    pending += on ? 1 : -1;
+    if (pending < 0) pending = 0;
+    sendBtn.textContent = pending > 0 ? 'Working…' : 'Send';
   }
 
   // Replay a persisted conversation (model messages) into the transcript on load.
@@ -116,6 +122,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');
@@ -145,13 +187,13 @@
 
   function send() {
     var text = composer.value.trim();
-    if (!text || sendBtn.disabled) return;
+    if (!text) return;
     composer.value = '';
     setRunning(true);
     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 +241,7 @@
     .catch(function () {})
     .then(function () {
       loadSidebar();
+      loadModels();
       connect();
     });
 })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getmegabrain/cli",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "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",