@openagents-org/agent-launcher 0.2.180 → 0.2.181

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openagents-org/agent-launcher",
-  "version": "0.2.180",
+  "version": "0.2.181",
   "description": "OpenAgents Launcher — install, configure, and run AI coding agents from your terminal",
   "main": "src/index.js",
   "bin": {

package/src/adapters/copilot-stream-parser.js

@@ -168,17 +168,50 @@ function parseLine(line) {
  * When real samples are available, extend THIS table only.
  */
 const EVENT_KIND_BY_TYPE = {
-  // session lifecycle / identity (kind only mapped when an id is also present)
+  // ── CAPTURED from a real authenticated run (CLI v1.0.83) ────────────────
+  // Every name in this block was read off a live JSONL stream, not inferred.
+  // The payload of each sits under `data` (see the `data` unwrap in
+  // classifyEvent) — except `result`, which is flat.
+  //
+  // The full type list observed in one turn: assistant.turn_start,
+  // assistant.reasoning_delta, assistant.reasoning, assistant.message_start,
+  // assistant.message_delta, assistant.turn_end, assistant.idle,
+  // model.call_start, model.call_finished, session.auto_mode_resolved,
+  // session.usage_checkpoint, session.tools_updated, session.skills_loaded,
+  // session.mcp_servers_loaded, session.mcp_server_status_changed,
+  // session.custom_agents_updated, user.message, result.
+  //
+  // The ones with no entry here are deliberate: they carry no content the
+  // workspace shows (lifecycle bookkeeping, or `user.message`, which is our
+  // own prompt echoed back). They degrade to `unknown`, which is logged and
+  // ignored — mapping them would put noise in the chat.
+  'assistant.message_delta': 'text_delta',   // data.deltaContent — THE answer
+  'assistant.reasoning': 'reasoning',        // data.content — ONE whole block
+  result: 'done',                            // flat: sessionId, exitCode, usage
+  // NOT mapped on purpose: `assistant.reasoning_delta`. Copilot streams at
+  // TOKEN granularity — 81 deltas for one short thought in the captured turn —
+  // and every adapter here narrates progress in whole blocks (claude sends
+  // `block.text`, codex `item.text`). Mapping the deltas posted one chat
+  // message per token: a column of "How" / "can" / "I" / "help" / "?" in the
+  // workspace. `assistant.reasoning` carries the same content as a single
+  // block afterwards, so that is what gets narrated.
+  'session.usage_checkpoint': 'usage',
+  'session.auto_mode_resolved': 'usage',     // data.chosenModel under Auto
+  'model.call_finished': 'usage',
+
+  // ── INFERRED — no live sample yet ───────────────────────────────────────
+  // The captured turn was a plain greeting, so no tool/file/shell/permission
+  // event appeared in it. The names below predate that capture and are kept
+  // as a net: they cost nothing (the real names above are matched first) and
+  // an unrecognized event is logged, never rendered. Replace them the moment
+  // a tool-using turn is captured — do not add more guesses.
   session: 'session', 'session.created': 'session', 'session.started': 'session',
   session_started: 'session', thread: 'session', 'thread.started': 'session',
-  // streaming assistant text (qualified names only — no bare 'delta'/'token')
   'text.delta': 'text_delta', text_delta: 'text_delta',
   'message.delta': 'text_delta', 'assistant.delta': 'text_delta',
   content_block_delta: 'text_delta',
-  // final assistant text (qualified/explicit names only — no bare 'message')
   text: 'text', 'message.completed': 'text', 'assistant.message': 'text',
   assistant: 'text', completion: 'text', agent_message: 'text',
-  // reasoning / status narration
   reasoning: 'reasoning', thinking: 'reasoning', thought: 'reasoning',
   status: 'reasoning', progress: 'reasoning',
   // tool calls
@@ -250,7 +283,14 @@ function classifyEvent(obj) {
     const itemKind = itemType ? EVENT_KIND_BY_TYPE[itemType.toLowerCase()] : undefined;
     if (itemKind) kind = itemKind;
   }
-  const src = item || obj;
+  // Copilot puts every event's payload under `data`, with the envelope
+  // (type/id/timestamp/parentId) on the outside — so reading fields off the
+  // top level found nothing and the answer came back empty. `result` is the
+  // one exception: it is flat, and falls through to `obj` here.
+  const data = (obj.data && typeof obj.data === 'object' && !Array.isArray(obj.data))
+    ? obj.data
+    : null;
+  const src = item || data || obj;
 
   switch (kind) {
     case 'session': {
@@ -261,7 +301,9 @@ function classifyEvent(obj) {
       return { kind: 'session', sessionId };
     }
     case 'text_delta': {
-      const text = _coerceText(src.delta) ?? _coerceText(src.text) ?? _coerceText(src.content) ?? _coerceText(src);
+      // `deltaContent` is Copilot's own field name, verified on v1.0.83.
+      const text = _coerceText(src.deltaContent) ?? _coerceText(src.delta)
+        ?? _coerceText(src.text) ?? _coerceText(src.content) ?? _coerceText(src);
       return { kind: 'text_delta', text: text || '' };
     }
     case 'text': {
@@ -269,7 +311,8 @@ function classifyEvent(obj) {
       return { kind: 'text', text: text || '' };
     }
     case 'reasoning': {
-      const text = _coerceText(src.text) ?? _coerceText(src.reasoning) ?? _coerceText(src.message)
+      const text = _coerceText(src.deltaContent) ?? _coerceText(src.text)
+        ?? _coerceText(src.reasoning) ?? _coerceText(src.message)
         ?? _coerceText(src.content) ?? _firstString(src, ['status', 'label', 'title']) ?? '';
       return { kind: 'reasoning', text };
     }
@@ -313,7 +356,14 @@ function classifyEvent(obj) {
     }
     case 'done': {
       const status = _firstString(src, ['status', 'reason', 'result']) || 'completed';
-      return { kind: 'done', status };
+      // The `result` frame is also where the real session id finally shows up
+      // — there is no session event earlier in the stream. Carrying it here is
+      // what lets the next turn resume instead of starting over. Read from the
+      // top level too: `result` is flat, so `src` is already `obj`, but an
+      // `item`-wrapped variant would not be.
+      const sessionId = _firstString(src, ['sessionId', 'session_id'])
+        ?? _firstString(obj, ['sessionId', 'session_id']);
+      return sessionId ? { kind: 'done', status, sessionId } : { kind: 'done', status };
     }
     case 'error': {
       const err = (src.error && typeof src.error === 'object') ? src.error : src;

package/src/adapters/copilot.js

@@ -606,10 +606,14 @@ class CopilotAdapter extends BaseAdapter {
             }
             break;
           case 'text_delta':
-            // Streamed interim text is shown live as `thinking`; the final
-            // `text` event (if any) is the authoritative answer.
+            // Accumulate only — never narrate. These deltas ARE the final
+            // answer being streamed a token at a time (Copilot's
+            // `assistant.message_delta`), and the answer is posted in full
+            // when the turn ends. Sending each one as `thinking` published the
+            // reply twice: once as a column of one-word messages, then again
+            // whole.
             if (sawToolSinceText) { finalParts.length = 0; deltaBuf = ''; sawToolSinceText = false; }
-            if (ev.text) { deltaBuf += ev.text; try { await this.sendThinking(channel, ev.text); } catch {} }
+            if (ev.text) deltaBuf += ev.text;
             break;
           case 'text':
             // A complete message supersedes the deltas streamed for this block.
@@ -655,6 +659,13 @@ class CopilotAdapter extends BaseAdapter {
             errorEvent = errorEvent || { message: ev.message, code: ev.code };
             break;
           case 'done':
+            // Copilot reports its session id only in the terminal `result`
+            // frame — no session event precedes it — so this is the one place
+            // a resumable id can be captured.
+            if (ev.sessionId && this._channelSessions[channel] !== ev.sessionId) {
+              this._channelSessions[channel] = ev.sessionId;
+              this._saveSessions();
+            }
             break;
           case 'unknown':
             // Preserve a redacted diagnostic; never crash the task.

package/src/daemon.js

@@ -43,6 +43,7 @@ class Daemon {
     this._statusInterval = null;
     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._runningCommands = new Set();   // node-command ids currently executing
     this._runtimes = [];                 // detected agent runtimes for the node view
@@ -225,6 +226,50 @@ class Daemon {
     }
   }
 
+  /**
+   * Reflect workspace-side renames back onto this device.
+   *
+   * The workspace is treated as authoritative for the label, which needs no
+   * timestamps to be correct: a rename started on the device writes to the
+   * workspace FIRST and only then to local config (see
+   * AgentConnector.setAgentDisplayName), so by the time this reads, the
+   * workspace already holds whatever the device just set. Anything different
+   * from local therefore came from the workspace and should win.
+   *
+   * Never throws — a workspace that is unreachable simply leaves the labels
+   * as they are until the next pass.
+   */
+  async _syncDisplayNames() {
+    let pairings = [];
+    try {
+      pairings = require('./node-config').listPairings();
+    } catch { return; }
+
+    for (const n of pairings) {
+      if (!n.workspace_id || !n.token) continue;
+      let members = [];
+      try {
+        members = await this._nodeClientFor(n).getAgents(n.workspace_id, n.token);
+      } catch { continue; }
+
+      const byName = new Map(members.map((m) => [m.agentName, m]));
+      for (const a of this.config.getAgents()) {
+        // Scoped to this pairing's workspace, like _buildRoster: an agent in
+        // another workspace must never be relabelled from this one.
+        if (!this._agentOnNodeWorkspace(a, n)) continue;
+        const remote = byName.get(a.name);
+        if (!remote) continue;
+        const local = a.display_name || null;
+        const wanted = remote.displayName || null;
+        if (local === wanted) continue;
+        try {
+          this.config.updateAgent(a.name, { display_name: wanted || undefined });
+          this._log(`display name for ${a.name} updated from workspace`);
+        } catch {}
+      }
+    }
+  }
+
   /**
    * True if agent `a` is bound to the node's currently-connected workspace.
    * A missing network never matches (guards against undefined === undefined
@@ -608,6 +653,15 @@ async _runNodeCommand(n, cmd) {
       15000,
     );
 
+    // Pull display-name renames made in the workspace back onto the device, so
+    // the two sides agree whichever one the user typed into. Separate from the
+    // 10s heartbeat on purpose: a label changes rarely and this is an extra
+    // request per paired workspace, so it runs a sixth as often.
+    this._displayNameInterval = setInterval(
+      () => this._syncDisplayNames(),
+      60000,
+    );
+
     // Detect installed/logged-in agent runtimes for the Add-agent gallery. Runs
     // in a child process (off the event loop), refreshed periodically.
     this._refreshRuntimes();
@@ -658,6 +712,7 @@ async _runNodeCommand(n, cmd) {
     if (this._nodeHeartbeatInterval) clearInterval(this._nodeHeartbeatInterval);
     if (this._credReconcileInterval) clearInterval(this._credReconcileInterval);
     if (this._runtimesInterval) clearInterval(this._runtimesInterval);
+    if (this._displayNameInterval) clearInterval(this._displayNameInterval);
     if (this._probeStartupTimer) clearTimeout(this._probeStartupTimer);
     if (this._probeInterval) clearInterval(this._probeInterval);
     if (this._configWatcher) { try { this._configWatcher.close(); } catch {} }

package/src/index.js

@@ -84,6 +84,10 @@ class AgentConnector {
       const network = networks.find((n) => n.slug === a.network || n.id === a.network);
       return {
         name: a.name,
+        // The label to show. `name` stays the identity — callers that key on
+        // it (sessions, working dirs, workspace membership) must keep using
+        // `name`, never this.
+        displayName: a.display_name || null,
         type,
         role: a.role || 'worker',
         network: a.network || null,
@@ -100,6 +104,95 @@ class AgentConnector {
     return { success: true };
   }
 
+  /**
+   * The workspace an agent is bound to, as a ready-to-use client — or null
+   * when it is local-only or its network is no longer configured.
+   *
+   * Each network carries its own endpoint (a self-hosted workspace is not the
+   * official one), so the client is built per call rather than reusing
+   * `this.workspace`, the same way removeWorkspace does.
+   */
+  _workspaceClientFor(agentName) {
+    const agent = this.config.getAgent(agentName);
+    if (!agent || !agent.network) return null;
+    const network = this.config
+      .getNetworks()
+      .find((n) => n.slug === agent.network || n.id === agent.network);
+    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 };
+  }
+
+  /**
+   * Set (or clear, with an empty value) an agent's display label.
+   *
+   * The agent's `name` is its identity — it keys daemon.yaml, the working
+   * directory under ~/.openagents/agents, its sessions and its workspace
+   * membership — so renaming NEVER touches it. What changes is the label the
+   * launcher and the workspace show, which is precisely what the workspace
+   * already models as `display_name` next to `agent_name`.
+   *
+   * When the agent is in a workspace the new label is pushed there too, so the
+   * two sides agree. A workspace that rejects it (a name another member
+   * already answers to) fails the whole call rather than leaving the label
+   * changed on one side only.
+   */
+  async setAgentDisplayName(name, displayName) {
+    const agent = this.config.getAgent(name);
+    if (!agent) throw new Error(`Agent '${name}' not found`);
+    const label = (displayName || '').trim();
+
+    const bound = this._workspaceClientFor(name);
+    if (bound) {
+      await bound.client.setMemberDisplayName(
+        bound.network.id,
+        bound.network.token || '',
+        name,
+        label,
+      );
+    }
+    // Local write comes second: if the workspace refused the label, nothing
+    // here has changed and the two sides are still in agreement.
+    this.config.updateAgent(name, { display_name: label || undefined });
+    return { success: true, displayName: label || null };
+  }
+
+  /**
+   * Drop an agent's member row from the workspace it joined.
+   *
+   * Deliberately SEPARATE from removeAgent rather than a flag on it. Removing
+   * an agent is a synchronous local edit that `agn remove` and the TUI call
+   * without awaiting, inside a try/catch — making it async would turn a thrown
+   * error into an unhandled rejection those callers can no longer see. So the
+   * network half lives here, and a caller that wants both awaits this first:
+   * failing to reach the workspace then leaves the agent intact locally, which
+   * is the recoverable order.
+   *
+   * A local-only agent is a no-op success — there is nothing over there.
+   */
+  async removeAgentFromWorkspace(name) {
+    const bound = this._workspaceClientFor(name);
+    if (!bound) return { success: true, skipped: true };
+    try {
+      await bound.client.removeMember(
+        bound.network.id,
+        bound.network.token || '',
+        name,
+      );
+    } catch (e) {
+      // 404 is the goal state, reached by someone else: the member row is
+      // already gone, or the whole workspace is. Treating it as a failure
+      // would strand the agent on this device — removal happens local-last, so
+      // an error here means it cannot be removed at all. Anything else (a
+      // network blip, an auth failure) is real and must stop the removal so
+      // the user can retry rather than lose track of a live membership.
+      if (!e || e.status !== 404) throw e;
+      return { success: true, alreadyGone: true };
+    }
+    return { success: true };
+  }
+
   removeAgent(name) {
     this.config.removeAgent(name);
     return { success: true };
@@ -193,11 +286,38 @@ class AgentConnector {
     return { success: true };
   }
 
+  /**
+   * Local half of leaving a workspace: forget the binding, keep the agent.
+   *
+   * Synchronous, and deliberately still local-only — `agn disconnect` and the
+   * TUI call it without awaiting, inside a try/catch, so an async version
+   * would turn a throw into an unhandled rejection they can no longer see.
+   * Callers that want the membership dropped too use leaveWorkspace below.
+   */
   disconnectWorkspace(agentName) {
     this.config.setAgentNetwork(agentName, null);
     return { success: true };
   }
 
+  /**
+   * Leave a workspace properly: drop the member row over there, and unbind
+   * here — the agent itself stays, with its config, credentials and working
+   * directory, ready to join another workspace.
+   *
+   * Leaving only the local half is the bug this replaces. The device stopped
+   * showing the agent as connected while the workspace went on listing it as a
+   * member, and nothing in the launcher could reach that row any more. The
+   * workspace-level "remove a workspace" action learned this same lesson
+   * already (see removeWorkspace) — this is the agent-level equivalent.
+   *
+   * Workspace first, local second: a failure there leaves the agent bound and
+   * retryable rather than orphaning a membership.
+   */
+  async leaveWorkspace(agentName) {
+    await this.removeAgentFromWorkspace(agentName);
+    return this.disconnectWorkspace(agentName);
+  }
+
   async removeWorkspace(slug) {
     const networks = this.config.getNetworks();
     const network = networks.find(n => n.slug === slug || n.id === slug);

package/src/workspace-client.js

@@ -84,6 +84,40 @@ class WorkspaceClient {
     }
   }
 
+  /**
+   * Remove one agent from a workspace via
+   * DELETE /v1/workspaces/{workspaceId}/members/{agentName}.
+   *
+   * Unlike deleteWorkspace above this is NOT best-effort: the caller offered
+   * the user a choice ("also remove it from the workspace"), so a failure has
+   * to be reported rather than swallowed — silently leaving the member behind
+   * is the exact problem this exists to fix.
+   */
+  async removeMember(workspaceId, token, agentName) {
+    await this._delete(
+      `/v1/workspaces/${workspaceId}/members/${encodeURIComponent(agentName)}`,
+      this._wsHeaders(token),
+    );
+  }
+
+  /**
+   * Rename one agent's DISPLAY name in a workspace, via
+   * PATCH /v1/workspaces/{workspaceId}/members/{agentName}.
+   *
+   * The agent's identity (`agent_name`) is untouched — this is the label the
+   * workspace shows and accepts as an @-mention alias, which is why the server
+   * rejects one that clashes with another member. An empty string clears the
+   * label there, falling back to `agent_name`, which is exactly what clearing
+   * the display name on this side means too.
+   */
+  async setMemberDisplayName(workspaceId, token, agentName, displayName) {
+    return this._patch(
+      `/v1/workspaces/${workspaceId}/members/${encodeURIComponent(agentName)}`,
+      { display_name: displayName || '' },
+      this._wsHeaders(token),
+    );
+  }
+
   /**
    * Join a workspace via POST /v1/join.
    */
@@ -514,6 +548,10 @@ class WorkspaceClient {
     const agents = (result && result.agents) || [];
     return agents.map((a) => ({
       agentName: (a.address || '').replace('openagents:', ''),
+      // The workspace's label for this agent, or null when it has none and
+      // falls back to agentName. Carried so a rename made in the workspace can
+      // be reflected back on the device.
+      displayName: a.display_name || null,
       role: a.role || 'member',
       status: a.status || 'offline',
       enabledSkills: a.enabled_skills || null,