mindvest-atlas 0.52.0 → 0.53.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindvest-atlas",
-  "version": "0.52.0",
+  "version": "0.53.0",
   "description": "Atlas CLI \u2014 OAuth login, tool calls, and live alert/flow streaming for the Atlas trading API",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -10,6 +10,7 @@ import { loginCommand } from './commands/login.js';
 import { logoutCommand } from './commands/logout.js';
 import { whoamiCommand } from './commands/whoami.js';
 import { toolsCommand } from './commands/tools.js';
+import { modelsCommand, askCommand } from './commands/models.js';
 import { alertsCommand } from './commands/alerts.js';
 import { flowCommand } from './commands/flow.js';
 import { remoteControlCommand } from './commands/remote-control.js';
@@ -82,6 +83,10 @@ export async function main(rawArgs) {
       case 'logout': return await logoutCommand(withoutCommand(args));
       case 'whoami': return await whoamiCommand(withoutCommand(args));
       case 'tools': return await toolsCommand(withoutCommand(args));
+      // WHICH MODELS ARE HERE, and handing one piece of work to one of them —
+      // together, the whole mechanism behind orchestration.
+      case 'models': return await modelsCommand(withoutCommand(args));
+      case 'ask': return await askCommand(withoutCommand(args));
       case 'alerts': return await alertsCommand(withoutCommand(args));
       case 'flow': return await flowCommand(withoutCommand(args));
       // Long-lived: hold the job stream and run this computer's jobs.

package/src/commands/models.js

@@ -0,0 +1,81 @@
+// Which models this computer can reach, and handing work to one of them.
+//
+// TWO COMMANDS, AND THE SECOND IS THE POINT. `atlas models` is the catalogue:
+// every model, who runs it, whether it is actually reachable, and the effort
+// levels it takes — because anything CHOOSING a model needs to know what is
+// there, and a guessed id is a session that fails a minute later for a reason
+// nobody can see.
+//
+// `atlas ask --model X "..."` hands one piece of work to one named model. The
+// helper has been able to do that from inside a script for a long time; it was
+// never reachable from a SHELL, which is where an agent lives. That one gap is
+// what stood between this and a model that can delegate: an orchestrator is not
+// a new mechanism, it is a model with this command and a roster.
+import { color, println, eprintln } from '../util/ui.js';
+import { askModel, listModels } from '../remote-control.js';
+
+export async function modelsCommand(args) {
+  const flags = args.flags || {};
+  const catalog = await listModels();
+  const rows = catalog.models || [];
+  if (flags.json) {
+    println(JSON.stringify(catalog, null, 2));
+    return 0;
+  }
+  if (!rows.length) {
+    eprintln(color.red('No model is connected on this computer yet.'));
+    eprintln(color.dim('  Open Atlas Studio > Model Settings and sign in to one.'));
+    return 1;
+  }
+  const width = Math.max(...rows.map((r) => String(r.id || '').length));
+  println(color.bold('Models on this computer'));
+  for (const r of rows) {
+    // READY FIRST: a model that cannot be reached is not a choice, and it is the
+    // one fact a caller cannot work out for itself.
+    const mark = r.ready ? '  ' : '! ';
+    const star = r.id === catalog.default ? ' *' : '';
+    const effort = (r.effort || []).join(', ') || '-';
+    println(`${mark}${String(r.id || '').padEnd(width)}  ${String(r.agent || '').padEnd(14)}`
+      + ` ${String(r.vendor || '').padEnd(22)} effort: ${effort}${star}`);
+  }
+  println('');
+  println(color.dim('  * the one used when nothing is named'));
+  println(color.dim('  ! not reachable right now — sign in under Model Settings'));
+  println(color.dim('  atlas ask --model <id> "..."   hand one piece of work to one of them'));
+  return 0;
+}
+
+export async function askCommand(args) {
+  const flags = args.flags || {};
+  const rest = args.positional || args._ || [];
+  const prompt = (rest.join(' ') || String(flags.prompt || '')).trim();
+  if (!prompt) {
+    eprintln(color.red('Say what to ask.'));
+    eprintln(color.dim('  atlas ask --model gpt-5.6-sol "summarise this filing"'));
+    return 1;
+  }
+  const model = String(flags.model || '').trim();
+  if (model) {
+    // NAMED, AND CHECKED. A typo would otherwise fall back to the default model
+    // in silence, and an orchestrator would believe it had asked three different
+    // models when it had asked one three times.
+    const known = ((await listModels()).models || []).map((r) => String(r.id));
+    if (known.length && !known.includes(model)) {
+      eprintln(color.red(`No model here is called "${model}".`));
+      eprintln(color.dim('  atlas models   lists them'));
+      return 1;
+    }
+  }
+  try {
+    const said = await askModel(prompt, {
+      job: String(flags.job || ''),
+      model,
+      timeoutMs: Number(flags.timeout || 900) * 1000,
+    });
+    println(typeof said === 'string' ? said : JSON.stringify(said, null, 2));
+    return 0;
+  } catch (err) {
+    eprintln(color.red(err.message || String(err)));
+    return 1;
+  }
+}

package/src/config.js

@@ -2,7 +2,7 @@
 import path from 'node:path';
 import os from 'node:os';
 
-export const VERSION = '0.52.0';
+export const VERSION = '0.53.0';
 export const DEFAULT_BASE_URL = 'https://atlasmcp.finmanagerai.com';
 export const DEFAULT_SCOPE = 'atlas broker';
 export const CLIENT_NAME = 'Atlas CLI';

package/src/remote-control.js

@@ -1360,7 +1360,15 @@ export function listRuns(root, limit = 50) {
  *
  * Returns the model's account of what it did. Throws if no model is connected.
  */
-export async function askModel(prompt, { job = '', tools = true, fresh = false, timeoutMs = 900000 } = {}) {
+export async function askModel(
+  prompt,
+  // `model` NAMES WHICH ONE ANSWERS, and its absence here was a real gap: the
+  // python helper has taken it for a long time, so the same call delegated to a
+  // named model in one runtime and quietly used the default in the other. That
+  // is the shape of bug where an orchestrator believes it asked three models and
+  // asked one three times.
+  { job = '', tools = true, fresh = false, timeoutMs = 900000, model = '' } = {},
+) {
   const url = process.env.ATLAS_ASK_URL;
   const token = process.env.ATLAS_ASK_TOKEN;
   if (!url || !token) {
@@ -1372,7 +1380,7 @@ export async function askModel(prompt, { job = '', tools = true, fresh = false,
   const res = await fetch(url, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json', 'X-Atlas-Token': token },
-    body: JSON.stringify({ job, prompt: String(prompt), tools, fresh }),
+    body: JSON.stringify({ job, prompt: String(prompt), tools, fresh, ...(model ? { model } : {}) }),
     signal: AbortSignal.timeout(timeoutMs),
   });
   const out = await res.json().catch(() => ({}));