@openagents-org/agent-launcher 0.2.127 → 0.2.130

package/package.json

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

package/registry.json

@@ -209,49 +209,44 @@
     "order": 4,
     "builtin": true,
     "install": {
-      "binary": "cursor",
-      "verify": "cursor --version 2>/dev/null | grep -qi cursor",
-      "verify_win": "cursor --version 2>nul | findstr /i cursor",
-      "requires": [
-        null
-      ],
+      "binary": "agent",
+      "verify": "agent --version 2>/dev/null | head -1",
+      "verify_win": "agent --version 2>nul",
+      "requires": [],
       "macos": "curl https://cursor.com/install -fsSL | bash",
       "linux": "curl https://cursor.com/install -fsSL | bash",
-      "windows": "echo 'Download Cursor from https://cursor.com/downloads'"
+      "windows": "irm 'https://cursor.com/install?win32=true' | iex",
+      "npm": "npm install -g @cursor/cli"
     },
     "adapter": {
       "module": "openagents.adapters.cursor",
       "class": "CursorAdapter"
     },
     "launch": {
-      "args": [
-        null
-      ]
+      "args": []
     },
     "env_config": [
       {
-        "name": "OPENAI_API_KEY",
-        "description": "API key for LLM inference",
-        "required": true,
+        "name": "CURSOR_API_KEY",
+        "description": "Cursor API key for CLI authentication",
+        "required": false,
         "password": true
+      },
+      {
+        "name": "CURSOR_MODEL",
+        "description": "Model to use (e.g. claude-sonnet-4-6, gpt-4o)",
+        "required": false
       }
     ],
     "check_ready": {
-      "env_vars": [
-        "OPENAI_API_KEY"
-      ],
-      "saved_env_key": "OPENAI_API_KEY",
-      "not_ready_message": "No API key \u2014 press e to configure"
+      "binary": "agent",
+      "not_ready_message": "Cursor CLI not found \u2014 install with: curl https://cursor.com/install -fsSL | bash"
     },
     "resolve_env": {
       "rules": [
         {
           "from": "LLM_API_KEY",
-          "to": "OPENAI_API_KEY"
-        },
-        {
-          "from": "LLM_BASE_URL",
-          "to": "OPENAI_BASE_URL"
+          "to": "CURSOR_API_KEY"
         },
         {
           "from": "LLM_MODEL",

package/src/adapters/base.js

@@ -42,6 +42,7 @@ class BaseAdapter {
     this.workingDir = workingDir || undefined;
     this.client = new WorkspaceClient(this.endpoint);
     this._lastEventId = null;
+    this._lastToolResultId = null;
     this._running = false;
     this._sessionId = null;  // issued by server on /v1/join; used to prove liveness
     this._processedIds = new Set();
@@ -330,6 +331,14 @@ class BaseAdapter {
         const msgId = msg.id || msg.messageId;
         if (msgId && this._processedIds.has(msgId)) continue;
         if (msg.messageType === 'status') continue;
+        // Handle queue cancellation signals from frontend
+        if (msg.messageType === 'queue_cancel') {
+          if (msgId) this._processedIds.add(msgId);
+          const channel = msg.sessionId || this.channelName || 'general';
+          const queueId = msg.metadata?.queue_id || (msg.content || '').replace('__queue_cancel:', '');
+          if (queueId) this._cancelQueuedMessage(channel, queueId);
+          continue;
+        }
         incoming.push(msg);
       }
 
@@ -350,6 +359,31 @@ class BaseAdapter {
         idleCount++;
       }
 
+      // Sidecar poll: A2UI tool_result events. These are the user's response
+      // to a UI spec this agent (or any agent in the network) emitted. We
+      // surface each one as a synthetic user message so the LLM sees it as
+      // the next turn and can react. Failures here don't break the main
+      // message poll.
+      try {
+        const toolResult = await this.client.pollToolResults(
+          this.workspaceId, this.token,
+          { after: this._lastToolResultId }
+        );
+        if (toolResult.cursor) this._lastToolResultId = toolResult.cursor;
+        for (const event of toolResult.events || []) {
+          const msgId = event.id;
+          if (msgId && this._processedIds.has(msgId)) continue;
+          if (msgId) this._processedIds.add(msgId);
+          const synth = synthesizeToolResultMessage(event);
+          if (synth) await this._dispatchMessage(synth);
+        }
+      } catch (e) {
+        // Non-fatal — log once per poll if it fails
+        if (pollCount <= 3 || pollCount % 20 === 0) {
+          this._log(`tool_result poll #${pollCount} failed: ${e.message}`);
+        }
+      }
+
       // Adaptive polling: 2s active, up to 15s idle.
       // Each connected agent runs this loop, so faster rates multiply across
       // every workspace member — keep this conservative and tune separately
@@ -372,9 +406,14 @@ class BaseAdapter {
 
     if (this._channelBusy.has(channel)) {
       if (!this._channelQueues[channel]) this._channelQueues[channel] = [];
+      const queueId = `q-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+      msg._queueId = queueId;
       this._channelQueues[channel].push(msg);
       try {
-        await this.sendStatus(channel, 'message queued — will process after current task');
+        await this.sendStatus(channel, 'message queued — will process after current task', {
+          queued_message: (msg.content || '').slice(0, 200),
+          queue_id: queueId,
+        });
       } catch {}
       return;
     }
@@ -384,6 +423,16 @@ class BaseAdapter {
     this._wakeControlPoller();
   }
 
+  _cancelQueuedMessage(channel, queueId) {
+    const queue = this._channelQueues[channel];
+    if (!queue) return false;
+    const idx = queue.findIndex((m) => m._queueId === queueId);
+    if (idx === -1) return false;
+    queue.splice(idx, 1);
+    this._log(`Cancelled queued message ${queueId} in ${channel}`);
+    return true;
+  }
+
   async _channelWorker(channel, msg) {
     this._channelBusy.add(channel);
     try {
@@ -398,6 +447,9 @@ class BaseAdapter {
       const queue = this._channelQueues[channel];
       if (!queue || queue.length === 0) break;
       const nextMsg = queue.shift();
+      if (nextMsg._queueId) {
+        try { await this.sendStatus(channel, 'processing queued message', { queue_id: nextMsg._queueId, queue_status: 'processed' }); } catch {}
+      }
       try {
         await this._handleMessage(nextMsg);
       } catch (e) {
@@ -435,13 +487,13 @@ class BaseAdapter {
   // Message helpers
   // ------------------------------------------------------------------
 
-  async sendStatus(channel, content) {
+  async sendStatus(channel, content, extraMeta) {
     try {
       await this.client.sendMessage(this.workspaceId, channel, this.token, content, {
         senderType: 'agent',
         senderName: this.agentName,
         messageType: 'status',
-        metadata: { agent_mode: this._mode },
+        metadata: { agent_mode: this._mode, ...extraMeta },
         sessionId: this._sessionId,
       });
     } catch (e) {
@@ -450,8 +502,15 @@ class BaseAdapter {
   }
 
   async sendThinking(channel, content) {
+    // Strip ```a2ui blocks if they leak into Claude's intermediate thinking
+    // trace — the real spec gets emitted via sendResponse with proper
+    // payload.spec extraction, so showing the raw block here is just noise
+    // (and a duplicate). If stripping leaves the thinking message empty,
+    // skip it entirely.
+    const { cleanContent } = extractA2UISpec(content);
+    if (!cleanContent || !cleanContent.trim()) return;
     try {
-      await this.client.sendMessage(this.workspaceId, channel, this.token, content, {
+      await this.client.sendMessage(this.workspaceId, channel, this.token, cleanContent, {
         senderType: 'agent',
         senderName: this.agentName,
         messageType: 'thinking',
@@ -464,11 +523,14 @@ class BaseAdapter {
   }
 
   async sendResponse(channel, content) {
+    const { cleanContent, spec, specToolCallId } = extractA2UISpec(content);
     try {
-      await this.client.sendMessage(this.workspaceId, channel, this.token, content, {
+      await this.client.sendMessage(this.workspaceId, channel, this.token, cleanContent, {
         senderType: 'agent',
         senderName: this.agentName,
         sessionId: this._sessionId,
+        spec,
+        specToolCallId,
       });
     } catch (e) {
       if (e instanceof SessionRevokedError) {
@@ -576,4 +638,74 @@ class BaseAdapter {
   }
 }
 
+// ------------------------------------------------------------------
+// A2UI helpers
+// ------------------------------------------------------------------
+
+/**
+ * Pull the first ```a2ui ... ``` fenced block out of LLM-produced content.
+ * Returns the content with the block stripped, the parsed spec, and a
+ * tool-call id derived from `spec.tool_call_id` (if present) or a new one.
+ * If no block is present or parsing fails, returns the content unchanged
+ * with null spec — the message still goes out as plain markdown.
+ */
+/**
+ * Convert a workspace.tool_result event into a synthetic user-message
+ * shape that the agent's _handleMessage can dispatch. The LLM sees this
+ * as the next user turn — the content is a short, machine-readable line
+ * the LLM can parse without ambiguity. The original spec it emitted is
+ * already in the LLM's conversation history; the tool_call_id lets the
+ * LLM correlate this back.
+ */
+function synthesizeToolResultMessage(event) {
+  if (!event || !event.payload) return null;
+  const p = event.payload;
+  const actionId = p.action_id || '';
+  const toolCallId = p.tool_call_id || '';
+  let valueStr = '';
+  if (p.value !== undefined && p.value !== null) {
+    try { valueStr = JSON.stringify(p.value); } catch (_) { valueStr = String(p.value); }
+  }
+  const lines = [
+    '[ui_action]',
+    `action=${actionId}`,
+    toolCallId ? `tool_call_id=${toolCallId}` : null,
+    valueStr ? `value=${valueStr}` : null,
+  ].filter(Boolean);
+  const content = lines.join(' ');
+  const target = event.target || '';
+  return {
+    messageId: event.id || '',
+    sessionId: target.startsWith('channel/') ? target.replace('channel/', '') : target,
+    senderType: 'human',
+    senderName: 'user',
+    content,
+    mentions: [],
+    messageType: 'chat',
+    metadata: event.metadata || {},
+  };
+}
+
+function extractA2UISpec(content) {
+  if (!content || typeof content !== 'string') {
+    return { cleanContent: content, spec: null, specToolCallId: null };
+  }
+  const match = content.match(/```a2ui\s*\n([\s\S]*?)\n```/);
+  if (!match) return { cleanContent: content, spec: null, specToolCallId: null };
+
+  let spec;
+  try {
+    spec = JSON.parse(match[1]);
+  } catch (_) {
+    return { cleanContent: content, spec: null, specToolCallId: null };
+  }
+
+  const specToolCallId = (spec && spec.tool_call_id) || `tc_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+  if (spec && spec.tool_call_id) delete spec.tool_call_id;
+
+  const cleanContent = content.replace(match[0], '').trim();
+  return { cleanContent, spec, specToolCallId };
+}
+
 module.exports = BaseAdapter;
+module.exports.extractA2UISpec = extractA2UISpec;

package/src/adapters/claude.js

@@ -569,7 +569,7 @@ class ClaudeAdapter extends BaseAdapter {
     let content = (msg.content || '').trim();
     const attachments = msg.attachments || [];
 
-    const attText = formatAttachmentsForPrompt(attachments);
+    const attText = formatAttachmentsForPrompt(attachments, this.toolMode);
     if (attText) {
       content = content ? content + attText : attText.trim();
     }