@openagents-org/agent-launcher 0.2.193 → 0.2.195

package/src/cli.js

@@ -217,7 +217,7 @@ async function cmdCreate(connector, flags, positional) {
         }
       } else {
         print(`  agn connect ${name} <workspace-token>`);
-        print('Or pair this device first: agn node connect <pairing-code>');
+        print('Or pair this device first: agn device connect <pairing-code>');
       }
     } else {
       print(`Agent '${name}' created (type: ${type})`);
@@ -441,7 +441,7 @@ async function cmdConnect(connector, flags, positional) {
   // no server round-trip; the credential is already on disk. This is the
   // pairing-first path; the token form below stays for manual connection.
   if (flags.workspace && typeof flags.workspace === 'string') {
-    connectKnownWorkspace(connector, name, flags.workspace);
+    connectKnownWorkspace(connector, name, flags.workspace, flags.connection);
     return;
   }
 
@@ -480,7 +480,7 @@ async function cmdConnect(connector, flags, positional) {
     // CLI half of the dismissible launcher notice.
     if (!process.env.OPENAGENTS_NO_DEPRECATION_NOTES) {
       print('note: manual token connection is being retired in favor of device pairing.');
-      print('      Pair once with `agn node connect <code>`, then `agn connect <agent> --workspace <slug>`.');
+      print('      Pair once with `agn device connect <code>`, then `agn connect <agent> --workspace <slug>`.');
       print('      (Silence this note with OPENAGENTS_NO_DEPRECATION_NOTES=1.)');
     }
 
@@ -504,7 +504,12 @@ async function cmdConnect(connector, flags, positional) {
  * (node.json) — a pairing registers its network on the spot so the daemon can
  * pick up the token. Never touches the server.
  */
-function connectKnownWorkspace(connector, name, ref) {
+function connectKnownWorkspace(connector, name, ref, connectionId) {
+  const matches = require('./node-config').listPairings().filter((p) => p.workspace_slug === ref || p.workspace_id === ref);
+  if ((!connectionId && matches.length > 1) || (connectionId && !matches.some((p) => p.node_id === connectionId))) {
+    throw new Error("Choose a device connection with --connection <id>");
+  }
+  const chosen = matches.find((p) => !connectionId || p.node_id === connectionId);
   const networks = connector.config.getNetworks() || [];
   let net = networks.find((n) => n.slug === ref || n.id === ref);
 
@@ -538,13 +543,14 @@ function connectKnownWorkspace(connector, name, ref) {
     ].filter(Boolean);
     print(`No workspace '${ref}' is known on this device.`);
     if (known.length) print(`Known workspaces: ${known.join(', ')}`);
-    print('Pair this device first (`agn node connect <code>`), or connect with a token.');
+    print('Pair this device first (`agn device connect <code>`), or connect with a token.');
     process.exitCode = 1;
     return;
   }
 
   const slug = net.slug || ref;
   connector.connectWorkspace(name, slug);
+  if (chosen) connector.config.updateAgent(name, { node_id: chosen.node_id });
   print(`'${name}' connected to workspace '${net.name || slug}'`);
 
   const pid = connector.getDaemonPid();
@@ -570,6 +576,11 @@ function workspaceWebUrl(slug, endpoint) {
     : `https://workspace.openagents.org/${slug}`;
 }
 
+/**
+ * `agn device <connect|status>` — pair this device (formerly "node") to a
+ * workspace. `agn node`, `agn devices` and `agn nodes` are aliases so existing
+ * scripts and older docs keep working; the product wording is "device".
+ */
 async function cmdNode(connector, flags, positional) {
   const sub = positional[0] || 'status';
   const nodeCfg = require('./node-config');
@@ -577,8 +588,8 @@ async function cmdNode(connector, flags, positional) {
   if (sub === 'connect') {
     const code = positional[1] || flags.code;
     if (!code) {
-      print('Usage: agn node connect <pairing-code>');
-      print('Get a pairing code from your workspace: Connect a Node.');
+      print('Usage: agn device connect <pairing-code>');
+      print('Get a pairing code from your workspace: Devices → Connect a device.');
       process.exitCode = 1;
       return;
     }
@@ -616,12 +627,19 @@ async function cmdNode(connector, flags, positional) {
       // credential in place — but the user should hear "already paired", not
       // a duplicate "connected".
       const alreadyPaired = priorPairings.some(
-        (p) => p.workspace_id === res.workspaceId,
+        (p) => p.node_id === res.nodeId,
       );
       // recordPairing, not saveNode: this device can be a node in several
       // workspaces at once, and a bare save would drop the others' pairings.
+      // Freeze legacy bindings before another owner adds a connection here.
+      const prior = priorPairings.filter((p) => p.workspace_id === res.workspaceId);
+      if (prior.length === 1) for (const agent of connector.config.getAgents()) {
+        if (!agent.node_id && (agent.network === prior[0].workspace_slug || agent.network === prior[0].workspace_id))
+          connector.config.updateAgent(agent.name, { node_id: prior[0].node_id });
+      }
       nodeCfg.recordPairing(info.nodeKey, {
         node_id: res.nodeId,
+        owner_email: res.ownerEmail,
         workspace_id: res.workspaceId,
         workspace_slug: res.workspaceSlug,
         workspace_name: res.workspaceName,
@@ -639,7 +657,7 @@ async function cmdNode(connector, flags, positional) {
       if (alreadyPaired) {
         print(`Already paired with '${res.workspaceName}' (${res.workspaceSlug}) — refreshed this device's credential.`);
       } else {
-        print(`Node connected to workspace '${res.workspaceName}' (${res.workspaceSlug})`);
+        print(`Device connected to workspace '${res.workspaceName}' (${res.workspaceSlug})`);
       }
       print(`  This device: ${info.hostname} (${info.deviceType})`);
 
@@ -672,10 +690,10 @@ async function cmdNode(connector, flags, positional) {
   if (sub === 'status') {
     const pairings = nodeCfg.listPairings().filter((p) => p.node_id);
     if (!pairings.length) {
-      print('No node connected. Run: agn node connect <pairing-code>');
+      print('No device connected. Run: agn device connect <pairing-code>');
       return;
     }
-    print(`Node connected to ${pairings.length} workspace(s):`);
+    print(`Device connected to ${pairings.length} workspace(s):`);
     for (const p of pairings) {
       const slug = p.workspace_slug || p.workspace_id;
       print(`  ${p.workspace_name || slug} (${slug}) — ${workspaceWebUrl(slug, p.endpoint)}`);
@@ -683,7 +701,7 @@ async function cmdNode(connector, flags, positional) {
     return;
   }
 
-  print('Usage: agn node <connect|status> [pairing-code]');
+  print('Usage: agn device <connect|status> [pairing-code]   (alias: agn node)');
   process.exitCode = 1;
 }
 
@@ -1024,6 +1042,37 @@ async function cmdProbe(connector, flags, positional) {
   }
 }
 
+async function cmdModels(connector, flags, positional) {
+  const target = positional[0];
+  if (!target) { print('Usage: agn models <type|agent> [--json]'); return; }
+
+  // Accept an agent name, as `agn probe` does: its CLI is asked on that
+  // agent's own env, so a signed-in agent answers for its sign-in.
+  let type = target;
+  let agentEnv;
+  try {
+    const agent = connector.config.getAgent(target);
+    if (agent) { type = agent.type || 'openclaw'; agentEnv = agent.env || {}; }
+  } catch {}
+
+  const result = await connector.listCliModels(type, { agentEnv });
+
+  if (flags && flags.json) {
+    // Machine consumers (the daemon's model sweep) read ONLY stdout JSON —
+    // same contract as `agn probe --json`.
+    process.stdout.write(JSON.stringify(result));
+    if (!result.ok) process.exitCode = 1;
+    return;
+  }
+
+  if (!result.ok) {
+    print(`FAILED ${result.error || ''}`.trim());
+    process.exitCode = 1;
+    return;
+  }
+  for (const m of result.models) print(m.label === m.id ? m.id : `${m.id}  ${m.label}`);
+}
+
 async function cmdVersion() {
   const pkg = require('../package.json');
   print(`${pkg.name} v${pkg.version}`);
@@ -1086,6 +1135,8 @@ Commands:
   uninstall <type>            Uninstall an agent runtime
   search [query]              Browse agent catalog
   runtimes                    List installed runtimes
+  device connect <code>       Pair this device (formerly "node") to a workspace with a pairing code
+  device status               Show the workspaces this device is paired with (alias: node)
   connect <agent> <token>     Connect agent to workspace (or --workspace <slug> for a paired one)
   disconnect <agent>          Disconnect agent from workspace
   env <type> [--set K=V]      View/set env vars for agent type
@@ -1094,6 +1145,7 @@ Commands:
   autostart [--disable]       Enable/disable auto-start on login
   test-llm <type>             Test LLM connection
   probe <type|agent> [--json] Smoke-test an agent (tiny end-to-end prompt)
+  models <type|agent> [--json] List the models the agent's CLI offers its signed-in account
   logs [agent] [--lines N]    View daemon logs
   workspace create [name]     Create a new workspace
   workspace join <token>      Join workspace with token
@@ -1173,7 +1225,10 @@ async function main() {
     search: () => cmdSearch(connector, flags, positional),
     runtimes: () => cmdRuntimes(connector, flags),
     connect: () => cmdConnect(connector, flags, positional),
-    node: () => cmdNode(connector, flags, positional),
+    device: () => cmdNode(connector, flags, positional),
+    devices: () => cmdNode(connector, flags, positional),
+    node: () => cmdNode(connector, flags, positional),     // legacy spelling
+    nodes: () => cmdNode(connector, flags, positional),    // legacy spelling
     disconnect: () => cmdDisconnect(connector, flags, positional),
     logs: () => cmdLogs(connector, flags, positional),
     autostart: () => cmdAutostart(connector, flags),
@@ -1183,6 +1238,7 @@ async function main() {
     'tool-mode': () => cmdToolMode(connector, flags, positional),
     'test-llm': () => cmdTestLLM(connector, flags, positional),
     probe: () => cmdProbe(connector, flags, positional),
+    models: () => cmdModels(connector, flags, positional),
     update: () => cmdUpdate(connector),
     'mcp-server': () => {
       const { runMcpServer } = require('./mcp-server');

package/src/config.js

@@ -110,6 +110,7 @@ class Config {
       agent.network = networkSlug;
     } else {
       delete agent.network;
+      delete agent.node_id;
     }
     this.save(config);
   }

package/src/daemon.js

@@ -2,6 +2,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const crypto = require('crypto');
 const { execSync, execFileSync } = require('child_process');
 // spawn() here is the WSL bridge from ./wsl: same signature as
 // child_process.spawn, and a straight pass-through unless the resolved CLI
@@ -10,10 +11,20 @@ const { spawn } = require('./wsl');
 const os = require('os');
 const { WorkspaceClient } = require('./workspace-client');
 const { listEndpointModels } = require('./model-list');
-const { AUTH_MODE_KEY, isCliLogin, stripForCliLogin, typeEnvFor } = require('./env');
+const { supportsCliModels } = require('./cli-models');
+const { AUTH_MODE_KEY, isCliLogin, modelKeys, stripForCliLogin, typeEnvFor } = require('./env');
 const { getEnhancedEnv, whichBinary, IS_WINDOWS, defaultAgentWorkdir } = require('./paths');
 const { LogWriter } = require('./log-writer');
 
+// A signed-in agent's model list is asked for again after this long. What a
+// CLI is offered changes when the CLI is upgraded (a vendor holds new models
+// back from old versions), so the upgrade should show within the hour.
+const CLI_MODELS_MAX_AGE_MS = 3600 * 1000;
+// A sign-in whose CLI has never answered is asked again sooner: the first ask
+// may have failed for a passing reason (a slow start, an update mid-way). A
+// little under the 10-minute sweep, so the next pass retries it.
+const CLI_MODELS_RETRY_MS = 9 * 60 * 1000;
+
 /**
  * Mask an API key for display (same shape the workspace backend uses for
  * cloud agents): enough to recognize which key it is, never enough to use it.
@@ -111,7 +122,7 @@ class Daemon {
     this._cmdInterval = null;
     this._nodeHeartbeatInterval = null;  // device-level heartbeat (connect-a-node)
     this._displayNameInterval = null;    // pulls workspace-side renames back
-    this._nodeClients = new Map();       // workspace_id -> WorkspaceClient, one per pairing
+    this._nodeClients = new Map();       // node_id -> WorkspaceClient, one per private connection
     this._runningCommands = new Set();   // node-command ids currently executing
     this._runtimes = [];                 // detected agent runtimes for the node view
     this._runtimesInterval = null;
@@ -119,6 +130,10 @@ class Daemon {
     this._probeInterval = null;
     this._probeStartupTimer = null;
     this._probeInFlight = new Set();     // types being probed right now
+    this._cliModels = {};                // sign-in key → { models, askedAt } from the agents' own CLI
+    this._cliModelsInFlight = new Set(); // sign-in keys whose CLI is being asked right now
+    this._cliModelsStartupTimer = null;
+    this._cliModelsInterval = null;
     this._reloadInFlight = null;  // serialize concurrent _reload() calls
   }
 
@@ -199,6 +214,98 @@ class Daemon {
     this._nodeHeartbeat();
   }
 
+  // ── Models a signed-in agent's account is offered ──────────────────────
+  // An agent on a subscription sign-in has no endpoint whose models can be
+  // listed, so its own CLI is asked (see cli-models.js). The answer rides the
+  // heartbeat's roster as agents[].cliModels, which puts it in front of the
+  // workspace's model picker without a command round trip. Kept in memory
+  // only: asking again after a restart costs a CLI start, not a model call.
+
+  /**
+   * Whether this agent runs on its CLI's own sign-in: a type whose CLI can
+   * say what the account is offered, calling that CLI's default endpoint,
+   * with no key the CLI would be handed instead.
+   */
+  _onCliSignIn(a) {
+    if (!supportsCliModels(a.type)) return false;
+    const endpoint = this._agentEndpoint(a);
+    return !endpoint.baseUrl && !endpoint.apiKey;
+  }
+
+  /**
+   * One key per sign-in. Agents of a type run one CLI on one account unless
+   * their own env says otherwise (a token or a config dir of their own), so
+   * those with the same env share an answer: a device with nine Claude agents
+   * starts the CLI once, not nine times. The model each runs is left out, it
+   * does not change what the account is offered. Hashed, since that env can
+   * hold a token.
+   */
+  _cliModelsKey(a) {
+    const skip = modelKeys(a.type, this.registry);
+    const own = Object.entries(a.env || {})
+      .filter(([k]) => !skip.has(k))
+      .sort(([x], [y]) => (x < y ? -1 : x > y ? 1 : 0));
+    return crypto.createHash('sha256').update(JSON.stringify([a.type, own])).digest('hex');
+  }
+
+  /**
+   * Ask an agent's CLI for its models via a child `agn models <name> --json`
+   * (off the event loop, and on that agent's own env, like a probe).
+   * Resolves true when the list it keeps for that sign-in changed.
+   */
+  async _listCliModels(a) {
+    const key = this._cliModelsKey(a);
+    if (this._cliModelsInFlight.has(key)) return false;
+    this._cliModelsInFlight.add(key);
+    try {
+      const r = await this._runAgn(['models', a.name, '--json']);
+      let parsed = null;
+      try { parsed = JSON.parse(r.stdout.trim()); } catch {}
+      const models = parsed && parsed.ok && Array.isArray(parsed.models) ? parsed.models : [];
+      const last = this._cliModels[key];
+      // A CLI that would not answer keeps the list it last gave: that is
+      // still the best answer there is.
+      const kept = models.length ? models : ((last && last.models) || null);
+      this._cliModels[key] = { models: kept, askedAt: Date.now() };
+      return JSON.stringify(kept) !== JSON.stringify((last && last.models) || null);
+    } finally {
+      this._cliModelsInFlight.delete(key);
+    }
+  }
+
+  /** Ask in the background for an agent that was just created or reconfigured. */
+  _askCliModels(name) {
+    let agent = null;
+    try { agent = this.config.getAgent(name); } catch {}
+    if (!agent || !this._onCliSignIn(agent)) return;
+    // A changed list goes out on a heartbeat now, not on the next tick.
+    this._listCliModels(agent)
+      .then((changed) => (changed ? this._nodeHeartbeat() : undefined))
+      .catch(() => {});
+  }
+
+  /**
+   * Periodic sweep: ask for every sign-in whose list is missing or has aged
+   * out, and forget the ones no agent is on any more. Sequential, like the
+   * probe sweep: there is no hurry.
+   */
+  async _refreshCliModels() {
+    const signIns = new Set();
+    for (const a of this.config.getAgents()) {
+      if (!a.network || !this._onCliSignIn(a)) continue;
+      const key = this._cliModelsKey(a);
+      if (signIns.has(key)) continue;
+      signIns.add(key);
+      const last = this._cliModels[key];
+      const maxAge = last && last.models ? CLI_MODELS_MAX_AGE_MS : CLI_MODELS_RETRY_MS;
+      if (last && Date.now() - last.askedAt < maxAge) continue;
+      try { await this._listCliModels(a); } catch {}
+    }
+    for (const key of Object.keys(this._cliModels)) {
+      if (!signIns.has(key)) delete this._cliModels[key];
+    }
+  }
+
   /**
    * Heartbeat this device (node) to EVERY workspace it is paired to,
    * independent of any agent, so each workspace's "connected devices" view
@@ -240,7 +347,7 @@ class Daemon {
       if (!info || !info.networkRef || info._credRestartPending) continue;
       if (!this._adapters || !this._adapters[name]) continue;
       let fresh = null;
-      try { fresh = this._resolveAgentNetwork(info.networkRef); } catch { /* keep running on the current token */ }
+      try { fresh = this._resolveAgentNetwork(info.networkRef, info.connectionId); } catch { /* keep running on the current token */ }
       if (!fresh || !fresh.token || fresh.token === info.credentialToken) continue;
       // Flag on the CURRENT info object: restartAgent replaces it with a fresh
       // one on relaunch, so the flag cannot wedge the watch permanently.
@@ -255,10 +362,10 @@ class Daemon {
 
   /** The WorkspaceClient for one pairing, created on first use and reused. */
   _nodeClientFor(n) {
-    let client = this._nodeClients.get(n.workspace_id);
+    let client = this._nodeClients.get(n.node_id);
     if (!client) {
       client = new WorkspaceClient(n.endpoint);
-      this._nodeClients.set(n.workspace_id, client);
+      this._nodeClients.set(n.node_id, client);
     }
     return client;
   }
@@ -282,8 +389,8 @@ class Daemon {
       // is unreachable, and taking that as the workspace's word unpaired every
       // workspace on the device at once.
       if (_nodeGone(err)) {
-        try { nodeCfg.clearPairing(n.workspace_id); } catch {}
-        this._nodeClients.delete(n.workspace_id);
+        try { nodeCfg.clearPairing(n.workspace_id, n.node_id); } catch {}
+        this._nodeClients.delete(n.node_id);
         this._log(`node ${n.node_id} no longer recognized by workspace ${n.workspace_slug || n.workspace_id} — pairing cleared`);
       }
       return;  // nothing more to do for this pairing this tick
@@ -352,7 +459,13 @@ class Daemon {
    */
   _agentOnNodeWorkspace(a, node) {
     if (!a || !a.network || !node) return false;
-    return a.network === node.workspace_slug || a.network === node.workspace_id;
+    if (a.network !== node.workspace_slug && a.network !== node.workspace_id) return false;
+    if (a.node_id) return a.node_id === node.node_id;
+    // Legacy agents may bind automatically only when the workspace is unambiguous.
+    const candidates = require('./node-config').listPairings().filter(
+      (p) => p.workspace_id === node.workspace_id && p.workspace_id,
+    );
+    return candidates.length <= 1;
   }
 
   /**
@@ -382,6 +495,9 @@ class Daemon {
         try { typeEnv = typeEnvFor(a.type, this.envManager.load(a.type) || {}, this.registry, a.env); } catch {}
         const model = (a.env && a.env.LLM_MODEL) || typeEnv.LLM_MODEL || null;
         const apiKey = (a.env && a.env.LLM_API_KEY) || typeEnv.LLM_API_KEY || null;
+        // What the agent's own CLI says its signed-in account can run. Null
+        // for an agent on a key or a relay, and until its CLI has answered.
+        const listed = supportsCliModels(a.type) ? this._cliModels[this._cliModelsKey(a)] : null;
         roster.push({
           name: a.name,
           type: a.type || 'unknown',
@@ -390,6 +506,7 @@ class Daemon {
           workingDir: a.path || null,
           apiKeyMasked: apiKey ? maskApiKey(apiKey) : null,
           baseUrlHost: endpointHost(this._configuredBaseUrl(a, typeEnv)),
+          cliModels: listed && listed.models && this._onCliSignIn(a) ? listed.models : null,
           probe: this._probes[a.name] || null,
         });
       }
@@ -635,7 +752,7 @@ async _runNodeCommand(n, cmd) {
         // pass and no /v1/token/resolve round-trip to fail (the outage class
         // that used to break remote installs).
         const r2 = await this._runAgn([
-          'connect', name, '--workspace', n.workspace_slug || n.workspace_id,
+          'connect', name, '--workspace', n.workspace_slug || n.workspace_id, '--connection', n.node_id,
         ]);
         if (r2.code !== 0) throw new Error(r2.stderr || r2.stdout || 'connect failed');
         ok = true;
@@ -644,6 +761,7 @@ async _runNodeCommand(n, cmd) {
         // full timeout — never hold the create result hostage). The outcome
         // reaches the workspace via the heartbeat's agents[].probe.
         this._probeAgent(name).then(() => this._nodeHeartbeat()).catch(() => {});
+        this._askCliModels(name);
       } else if (action === 'start_agent') {
         const r = await this._runAgn(['start', name]);
         ok = r.code === 0;
@@ -674,7 +792,7 @@ async _runNodeCommand(n, cmd) {
           if (rc.code !== 0) throw new Error(rc.stderr || rc.stdout || 'recreate failed');
           this._saveNodeAgentEnv(name, type, args);
           const rc2 = await this._runAgn([
-            'connect', name, '--workspace', n.workspace_slug || n.workspace_id,
+            'connect', name, '--workspace', n.workspace_slug || n.workspace_id, '--connection', n.node_id,
           ]);
           if (rc2.code !== 0) throw new Error(rc2.stderr || rc2.stdout || 'connect failed');
         } else {
@@ -690,6 +808,7 @@ async _runNodeCommand(n, cmd) {
         // A reconfigure changes credentials/model — re-verify in the
         // background so the workspace sees the new state without a manual test.
         this._probeAgent(name).then(() => this._nodeHeartbeat()).catch(() => {});
+        this._askCliModels(name);
       } else if (action === 'probe_agent') {
         // Smoke-test on demand ("Re-test" in the workspace). Probes belong to
         // configured agents (by name); the result rides agents[].probe.
@@ -878,6 +997,19 @@ async _runNodeCommand(n, cmd) {
       3600 * 1000,
     );
 
+    // What each signed-in agent's account is offered, for the workspace's
+    // model picker. Asking costs a CLI start and no model call. The pass is
+    // frequent so an agent added on the device is picked up soon; it only
+    // asks for a list that is missing or an hour old.
+    this._cliModelsStartupTimer = setTimeout(
+      () => this._refreshCliModels().catch(() => {}),
+      20 * 1000,
+    );
+    this._cliModelsInterval = setInterval(
+      () => this._refreshCliModels().catch(() => {}),
+      10 * 60 * 1000,
+    );
+
     // Watch config file for hot-reload
     this._watchConfig();
 
@@ -909,6 +1041,8 @@ async _runNodeCommand(n, cmd) {
     if (this._displayNameInterval) clearInterval(this._displayNameInterval);
     if (this._probeStartupTimer) clearTimeout(this._probeStartupTimer);
     if (this._probeInterval) clearInterval(this._probeInterval);
+    if (this._cliModelsStartupTimer) clearTimeout(this._cliModelsStartupTimer);
+    if (this._cliModelsInterval) clearInterval(this._cliModelsInterval);
     if (this._configWatcher) { try { this._configWatcher.close(); } catch {} }
 
     // Kill all child processes
@@ -1164,15 +1298,18 @@ async _runNodeCommand(n, cmd) {
    * fallback. Fields from the network entry win for display (name), the
    * pairing wins for credentials (token/endpoint).
    */
-  _resolveAgentNetwork(ref) {
+  _resolveAgentNetwork(ref, nodeId) {
     const network =
       this.config.getNetworks().find((n) => n.slug === ref || n.id === ref) ||
       null;
     let pairing = null;
     try {
-      pairing = require('./node-config')
-        .listPairings()
-        .find((p) => p.workspace_slug === ref || p.workspace_id === ref) || null;
+      const candidates = require('./node-config').listPairings()
+        .filter((p) => p.workspace_slug === ref || p.workspace_id === ref);
+      pairing = candidates.find((p) => !nodeId || p.node_id === nodeId) || null;
+      if ((nodeId && !pairing) || (!nodeId && candidates.length > 1)) {
+        return { ...(network || {}), token: null };
+      }
     } catch {}
     if (!network && !pairing) return null;
     return {
@@ -1216,7 +1353,7 @@ async _runNodeCommand(n, cmd) {
     // Workspace-connected agents use the adapter loop (poll + CLI per message).
     // Local-only agents use the spawn loop (long-running child process).
     const network = agentCfg.network
-      ? this._resolveAgentNetwork(agentCfg.network)
+      ? this._resolveAgentNetwork(agentCfg.network, agentCfg.node_id)
       : null;
 
     if (network && !network.token) {
@@ -1235,6 +1372,7 @@ async _runNodeCommand(n, cmd) {
       // Remember which credential this adapter runs with, so the rotation
       // watch can restart it when a re-pair hands the workspace a new token.
       info.networkRef = agentCfg.network;
+      info.connectionId = agentCfg.node_id;
       info.credentialToken = network.token;
       this._adapterLoop(name, agentCfg, info, network);
     } else {

package/src/index.js

@@ -121,7 +121,7 @@ class AgentConnector {
     if (!network || !network.id) return null;
     const endpoint = network.endpoint || (this.workspace && this.workspace.endpoint);
     const { WorkspaceClient } = require('./workspace-client');
-    return { client: new WorkspaceClient(endpoint), network };
+    return { client: new WorkspaceClient(endpoint, { agentName }), network };
   }
 
   /**
@@ -431,6 +431,15 @@ class AgentConnector {
     const { probeAgentType } = require('./probe');
     return probeAgentType(this, agentType, opts);
   }
+
+  /**
+   * Ask an agent type's own CLI which models the account it is signed in to
+   * can run. See cli-models.js.
+   */
+  async listCliModels(agentType, opts) {
+    const { listCliModels } = require('./cli-models');
+    return listCliModels(this, agentType, opts);
+  }
 }
 
 const adapters = require('./adapters');