a2acalling 0.1.5 → 0.1.7

package/AGENTS.md

@@ -24,7 +24,7 @@ a2acalling/
 │   │   ├── tokens.js    # Token storage & validation
 │   │   └── client.js    # Outbound A2A client
 │   └── routes/
-│       └── federation.js # Express routes for /api/federation
+│       └── a2a.js # Express routes for /api/a2a
 ├── docs/
 │   └── protocol.md      # Protocol specification
 └── .env                  # Secrets (gitignored)
@@ -47,15 +47,15 @@ node -e "const a2a = require('./src'); console.log(a2a.version)"
 2. **Permission presets**: `chat-only` (default), `tools-read`, `tools-write`  
 3. **Disclosure levels**: `public`, `minimal` (default), `none`
 4. **Rate limits**: 10/min, 100/hr, 1000/day per token
-5. **Storage**: JSON file at `~/.config/openclaw/a2a-federation.json`
+5. **Storage**: JSON file at `~/.config/openclaw/a2a.json`
 
 ## Integration Points
 
 This package is designed to integrate with OpenClaw:
 
-1. **Gateway routes**: Mount `createRoutes()` at `/api/federation`
-2. **Agent tool**: Add `federation_call` tool using `A2AClient`
-3. **Commands**: Wire `/federation` commands to CLI functions
+1. **Gateway routes**: Mount `createRoutes()` at `/api/a2a`
+2. **Agent tool**: Add `a2a_call` tool using `A2AClient`
+3. **Commands**: Wire `/a2a` commands to CLI functions
 
 ## Commit Convention
 

package/CLAUDE.md

@@ -16,19 +16,19 @@ git remote set-url origin https://${GH_TOKEN}@github.com/onthegonow/A2A_for_Open
 ## What This Does
 
 1. **Token Management** - Create expiring tokens with permissions (chat-only/tools-read/tools-write)
-2. **Inbound Calls** - Express routes handle `/api/federation/invoke` from remote agents
+2. **Inbound Calls** - Express routes handle `/api/a2a/invoke` from remote agents
 3. **Outbound Calls** - `A2AClient` calls remote agents via their invite URLs
 4. **Owner Notifications** - Configurable alerts when your agent gets called
 
 ## Token Flow
 
 ```
-User: /federation create --name "Alice" --expires 7d
+User: /a2a create --name "Alice" --expires 7d
 Bot:  ✅ a2a://myhost.com/fed_abc123
 
 User shares URL with Alice...
 
-Alice's agent: POST /api/federation/invoke
+Alice's agent: POST /api/a2a/invoke
                Authorization: Bearer fed_abc123
                {"message": "Hey, can you help?"}
 
@@ -40,7 +40,7 @@ You get notified (if configured).
 
 - `src/lib/tokens.js` - All token CRUD + validation
 - `src/lib/client.js` - `A2AClient` for outbound calls
-- `src/routes/federation.js` - Express router (mount at `/api/federation`)
+- `src/routes/a2a.js` - Express router (mount at `/api/a2a`)
 - `docs/protocol.md` - Full protocol spec
 
 ## Testing

package/README.md

@@ -40,7 +40,7 @@ a2a create --name "My Agent" --owner "Your Name" --tier friends
 a2a add "a2a://their-host.com/fed_xyz789" "Alice's Agent"
 
 # Make a call
-a2a call "Alice's Agent" "Hey! Want to collaborate on the federation protocol?"
+a2a call "Alice's Agent" "Hey! Want to collaborate on the a2a protocol?"
 
 # Or call directly
 a2a call "a2a://their-host.com/fed_xyz789" "Hello!"
@@ -120,7 +120,7 @@ Every call generates an owner-context summary that tracks the exchange:
 {
   "exchange": {
     "weGot": ["learned about their developer tools project"],
-    "weGave": ["shared our A2A federation work"],
+    "weGave": ["shared our A2A work"],
     "balance": "even",
     "fair": true
   },
@@ -171,7 +171,7 @@ a2a ping <target>             # Check if agent is available
 ### Server
 
 ```bash
-a2a serve [options]           # Start federation server
+a2a server [options]          # Start A2A server
   --port, -p <port>           # Port (default: 3001)
 ```
 
@@ -187,9 +187,10 @@ a2a://<hostname>:<port>/<token>
 
 | Method | Path | Description |
 |--------|------|-------------|
-| `GET` | `/api/federation/status` | Check federation support |
-| `GET` | `/api/federation/ping` | Health check with auth |
-| `POST` | `/api/federation/invoke` | Call the agent |
+| `GET` | `/api/a2a/status` | Check A2A support |
+| `GET` | `/api/a2a/ping` | Health check with auth |
+| `POST` | `/api/a2a/invoke` | Call the agent |
+| `POST` | `/api/a2a/end` | End a conversation and return summary data |
 
 ### Invoke Request
 
@@ -214,6 +215,25 @@ a2a://<hostname>:<port>/<token>
 }
 ```
 
+### End Conversation Request
+
+```json
+{
+  "conversation_id": "conv_123"
+}
+```
+
+### End Conversation Response
+
+```json
+{
+  "success": true,
+  "conversation_id": "conv_123",
+  "status": "concluded",
+  "summary": "Optional call summary"
+}
+```
+
 ## 🔌 Library Usage
 
 ### Making Calls (Client)
@@ -237,6 +257,12 @@ const followUp = await client.call(
   'Thanks! One more question...',
   { conversationId: response.conversation_id }
 );
+
+// Explicitly end the call when done
+const ended = await client.end(
+  'a2a://their-host.com/fed_token123',
+  response.conversation_id
+);
 ```
 
 ### Receiving Calls (Server)
@@ -248,7 +274,7 @@ const express = require('express');
 const app = express();
 app.use(express.json());
 
-app.use('/api/federation', createRoutes({
+app.use('/api/a2a', createRoutes({
   tokenStore: new TokenStore(),
   
   async handleMessage(message, context) {
@@ -284,7 +310,7 @@ app.listen(3001);
 
 ## 🤝 Philosophy
 
-Federation is **cooperative AND adversarial**. Each agent maximizes value for their owner — but the best outcomes are mutual wins.
+A2A is **cooperative AND adversarial**. Each agent maximizes value for their owner — but the best outcomes are mutual wins.
 
 Your agent should:
 1. **Protect your interests** — track what you're giving vs. getting

package/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: a2a
-description: "Agent-to-agent federation for OpenClaw. Create tokens to let remote agents call yours as a subagent with scoped permissions. Use when setting up cross-instance agent communication, creating federation tokens, managing remote agent access, or calling other OpenClaw agents."
+description: "Agent-to-agent A2A for OpenClaw. Create tokens to let remote agents call yours as a subagent with scoped permissions. Use when setting up cross-instance agent communication, creating A2A tokens, managing remote agent access, or calling other OpenClaw agents."
 metadata:
   {
     "openclaw":
@@ -17,13 +17,13 @@ metadata:
               "label": "Install A2A Calling (npm)",
             },
           ],
-        "routes": "/api/federation",
-        "tools": ["federation_call"],
+        "routes": "/api/a2a",
+        "tools": ["a2a_call"],
       },
   }
 ---
 
-# A2A Federation
+# A2A
 
 Enable agent-to-agent communication across OpenClaw instances.
 
@@ -31,7 +31,7 @@ Enable agent-to-agent communication across OpenClaw instances.
 
 ### Create Token
 
-User says: `/federation create`, "create a federation token", "let another agent call me"
+User says: `/a2a create`, "create an A2A token", "let another agent call me"
 
 ```bash
 a2a create --name "NAME" --expires DURATION --permissions LEVEL
@@ -68,11 +68,11 @@ a2a add "a2a://host/token" "Agent Name"
 
 ## Calling Remote Agents
 
-When task delegation to a known remote agent would help, or user asks to contact a federated agent:
+When task delegation to a known remote agent would help, or user asks to contact a A2A agent:
 
 ```javascript
-// Use federation_call tool
-federation_call({
+// Use a2a_call tool
+a2a_call({
   endpoint: "a2a://host/token",
   message: "Your question here",
   conversation_id: "optional-for-continuity"
@@ -81,7 +81,7 @@ federation_call({
 
 ## Handling Incoming Calls
 
-When receiving a federation call, the agent operates within the token's permission scope:
+When receiving an A2A call, the agent operates within the token's permission scope:
 
 | Permission | Allowed |
 |------------|---------|
@@ -99,7 +99,7 @@ Apply disclosure level:
 When `notify: all`, send to owner:
 
 ```
-🤝 Federation call received
+🤝 A2A call received
 
 From: [Caller] ([host])
 Token: "[name]" (expires [date])

package/bin/cli.js

@@ -3,7 +3,7 @@
  * A2A Calling CLI
  * 
  * Usage:
- *   a2a create [options]     Create a federation token
+ *   a2a create [options]     Create an A2A token
  *   a2a list                 List active tokens
  *   a2a revoke <id>          Revoke a token
  *   a2a add <url> [name]     Add a remote agent
@@ -122,7 +122,7 @@ const commands = {
         console.log(`✅ Token created (link failed: ${linkResult.error})\n`);
       }
     } else {
-      console.log(`✅ Federation token created\n`);
+      console.log(`✅ A2A token created\n`);
     }
     
     console.log(`Name: ${record.name}`);
@@ -167,11 +167,11 @@ a2a call "${agentName}" "Hello!"
   list: () => {
     const tokens = store.list();
     if (tokens.length === 0) {
-      console.log('No active federation tokens.');
+      console.log('No active A2A tokens.');
       return;
     }
 
-    console.log('Active federation tokens:\n');
+    console.log('Active A2A tokens:\n');
     for (const t of tokens) {
       const expired = t.expires_at && new Date(t.expires_at) < new Date();
       const status = expired ? '⚠️  EXPIRED' : '✅ Active';
@@ -715,7 +715,7 @@ a2a call "${agentName}" "Hello!"
     const client = new A2AClient();
     try {
       const status = await client.status(url);
-      console.log(`Federation status for ${url}:\n`);
+      console.log(`A2A status for ${url}:\n`);
       console.log(JSON.stringify(status, null, 2));
     } catch (err) {
       console.error(`❌ Failed to get status: ${err.message}`);
@@ -726,7 +726,7 @@ a2a call "${agentName}" "Hello!"
   server: (args) => {
     const port = args.flags.port || args.flags.p || process.env.PORT || 3001;
     process.env.PORT = port;
-    console.log(`Starting A2A federation server on port ${port}...`);
+    console.log(`Starting A2A server on port ${port}...`);
     require('../src/server.js');
   },
 
@@ -747,7 +747,7 @@ a2a call "${agentName}" "Hello!"
       const req = http.request({
         hostname: serverHost === 'localhost' ? '127.0.0.1' : serverHost,
         port: serverPort,
-        path: '/api/federation/ping',
+        path: '/api/a2a/ping',
         timeout: 2000
       }, (res) => {
         resolve(res.statusCode === 200);
@@ -822,7 +822,7 @@ ${inviteUrl}
 Usage: a2a <command> [options]
 
 Commands:
-  create              Create a federation token
+  create              Create an A2A token
     --name, -n        Token/agent name
     --owner, -o       Owner name (human behind the agent)
     --expires, -e     Expiration (1h, 1d, 7d, 30d, never)
@@ -864,10 +864,10 @@ Conversations:
 Calling:
   call <contact|url> <msg>  Call a remote agent
   ping <url>          Check if agent is reachable
-  status <url>        Get federation status
+  status <url>        Get A2A status
 
 Server:
-  server              Start the federation server
+  server              Start the A2A server
     --port, -p        Port to listen on (default: 3001)
   
   quickstart          One-command setup: check server + create invite

package/docs/protocol.md

@@ -1,8 +1,8 @@
-# Federation Protocol v0 Reference
+# A2A Protocol v0 Reference
 
 ## Overview
 
-Federation enables OpenClaw agents to call each other across instances with scoped permissions and owner notification.
+A2A enables OpenClaw agents to call each other across instances with scoped permissions and owner notification.
 
 ## Token Format
 
@@ -16,16 +16,16 @@ Token structure: `fed_<base64url(24 random bytes)>`
 
 ## API Endpoints
 
-All endpoints are prefixed with `/api/federation/`
+All endpoints are prefixed with `/api/a2a/`
 
 ### GET /status
 
-Check if federation is enabled.
+Check if A2A is enabled.
 
 Response:
 ```json
 {
-  "federation": true,
+  "a2a": true,
   "version": "0.1.0",
   "capabilities": ["invoke", "multi-turn"],
   "rate_limits": {
@@ -93,6 +93,40 @@ Error responses:
 {"success": false, "error": "missing_message", "message": "..."}
 ```
 
+### POST /end
+
+Explicitly end a conversation and trigger conclusion/summarization.
+
+Headers:
+```
+Authorization: Bearer fed_abc123xyz
+Content-Type: application/json
+```
+
+Request body:
+```json
+{
+  "conversation_id": "conv_123456"
+}
+```
+
+Success response:
+```json
+{
+  "success": true,
+  "conversation_id": "conv_123456",
+  "status": "concluded",
+  "summary": "Optional summary text"
+}
+```
+
+Error responses:
+```json
+{"success": false, "error": "unauthorized", "message": "..."}
+{"success": false, "error": "missing_conversation_id", "message": "..."}
+{"success": false, "error": "internal_error", "message": "..."}
+```
+
 ## Permission Scopes
 
 | Scope | Tools | Files | Memory | Actions |
@@ -111,7 +145,7 @@ Error responses:
 
 ## Token Storage Schema
 
-Stored in `~/.config/openclaw/federation.json`:
+Stored in `~/.config/openclaw/a2a.json`:
 
 ```json
 {
@@ -156,7 +190,7 @@ Limits reset on natural boundaries (minute, hour, day UTC).
 ## Security Considerations
 
 1. **Token hashing**: Tokens stored as SHA-256 hashes server-side
-2. **TLS required**: All federation calls should use HTTPS
+2. **TLS required**: All A2A calls should use HTTPS
 3. **No credential forwarding**: Tokens are never forwarded to other agents
 4. **Audit logging**: All invocations are logged with caller info
 5. **Auto-revocation**: Tokens may auto-revoke after repeated errors
@@ -172,13 +206,17 @@ To continue a conversation, include `conversation_id` from the previous response
 }
 ```
 
+When finished, either:
+- Call `POST /end` with the same `conversation_id` for explicit conclusion, or
+- Let the receiver auto-conclude on idle timeout/max duration (if enabled).
+
 Conversations expire after 1 hour of inactivity.
 
 ## Owner Notifications
 
 When `notify: all`:
 ```
-🤝 Federation call received
+🤝 A2A call received
 
 From: Alice's Agent (alice.example.com)
 Token: "Work collab" (expires 2026-02-18)
@@ -199,16 +237,16 @@ Owner can reply to inject into the conversation.
 
 Add to gateway routes:
 ```javascript
-const federation = require('./skills/federation/scripts/server');
-app.use('/api/federation', federation);
+const a2a = require('./skills/a2a/scripts/server');
+app.use('/api/a2a', a2a);
 ```
 
 ### Agent Context
 
-When handling a federation call, inject context:
+When handling an A2A call, inject context:
 ```json
 {
-  "federation": {
+  "a2a": {
     "active": true,
     "caller": "Alice's Agent",
     "permissions": "chat-only",
@@ -217,10 +255,10 @@ When handling a federation call, inject context:
 }
 ```
 
-### New Tool: federation_call
+### New Tool: a2a_call
 
 ```typescript
-federation_call({
+a2a_call({
   endpoint: string,    // a2a:// URL
   message: string,     // Message to send
   conversation_id?: string  // For multi-turn

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "a2acalling",
-  "version": "0.1.5",
-  "description": "Agent-to-agent calling for OpenClaw - federated agent communication",
+  "version": "0.1.7",
+  "description": "Agent-to-agent calling for OpenClaw - A2A agent communication",
   "main": "src/index.js",
   "bin": {
     "a2a": "bin/cli.js",
@@ -15,8 +15,8 @@
     "openclaw",
     "claudebot",
     "agent",
-    "federation",
     "a2a",
+    "calling",
     "ai"
   ],
   "author": "OpenClaw Contributors",

package/scripts/install-openclaw.js

@@ -5,7 +5,7 @@
  * This script:
  * 1. Installs the a2a skill to the user's OpenClaw skills directory
  * 2. Adds /a2a as a custom command in OpenClaw config
- * 3. Sets up the federation server as a systemd service (optional)
+ * 3. Sets up the A2A server as a systemd service (optional)
  * 
  * Usage:
  *   npx a2acalling install
@@ -47,10 +47,10 @@ function error(msg) { console.error(`${red('[a2a]')} ${msg}`); }
 // Skill content
 const SKILL_MD = `---
 name: a2a
-description: "Agent-to-Agent federation. Handle /a2a commands to create tokens, manage connections, and call remote agents. Triggers on: /a2a, federation, agent token, a2a invite."
+description: "Agent-to-Agent a2a. Handle /a2a commands to create tokens, manage connections, and call remote agents. Triggers on: /a2a, a2a, agent token, a2a invite."
 ---
 
-# A2A Federation
+# A2A
 
 Handle agent-to-agent communication with Telegram inline buttons + \`a2a\` CLI.
 
@@ -88,7 +88,7 @@ message({
   channel: "telegram",
   target: "CHAT_ID",
   threadId: "TOPIC_ID",  // REQUIRED for forum topics!
-  message: "🤝 **A2A Federation**\\n\\nWhat would you like to do?",
+  message: "🤝 **A2A**\\n\\nWhat would you like to do?",
   buttons: [
     [{ text: "📝 Create Invite", callback_data: "/a2a invite" }, { text: "📋 List Tokens", callback_data: "/a2a list" }],
     [{ text: "🗑 Revoke Token", callback_data: "/a2a revoke" }, { text: "📡 Add Remote", callback_data: "/a2a add" }]
@@ -209,7 +209,7 @@ function install() {
   console.log(`
 ${bold('━━━ Server Setup ━━━')}
 
-To receive incoming calls, run the a2a server:
+To receive incoming calls, run the A2A server:
 
   ${green(`A2A_HOSTNAME="${hostname}:${port}" a2a server`)}
 
@@ -257,7 +257,7 @@ ${bold('A2A Calling - OpenClaw Integration')}
 Usage:
   npx a2acalling install [options]    Install A2A for OpenClaw
   npx a2acalling uninstall            Remove A2A skill
-  npx a2acalling server               Start federation server
+  npx a2acalling server               Start A2A server
 
 Install Options:
   --hostname <host>    Hostname for invite URLs (default: system hostname)

package/src/index.js

@@ -5,7 +5,7 @@
  * // Server side - mount routes
  * const { createRoutes, TokenStore } = require('a2acalling');
  * const tokenStore = new TokenStore();
- * app.use('/api/federation', createRoutes({ tokenStore, handleMessage }));
+ * app.use('/api/a2a', createRoutes({ tokenStore, handleMessage }));
  * 
  * @example
  * // Client side - call remote agent
@@ -16,7 +16,7 @@
 
 const { TokenStore } = require('./lib/tokens');
 const { A2AClient, A2AError } = require('./lib/client');
-const { createRoutes } = require('./routes/federation');
+const { createRoutes } = require('./routes/a2a');
 
 // Lazy load optional dependencies
 let ConversationStore = null;

package/src/lib/client.js

@@ -26,7 +26,7 @@ class A2AClient {
   /**
    * Call a remote agent
    * 
-   * @param {string} endpoint - a2a:// URL or {host, token}
+   * @param {string|object} endpoint - a2a:// URL or {host, token}
    * @param {string} message - Message to send
    * @param {object} options - Additional options
    * @returns {Promise<object>} Response from remote agent
@@ -62,7 +62,81 @@ class A2AClient {
       const req = protocol.request({
         hostname,
         port,
-        path: '/api/federation/invoke',
+        path: '/api/a2a/invoke',
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${token}`,
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(body)
+        },
+        timeout: this.timeout
+      }, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          try {
+            const json = JSON.parse(data);
+            if (res.statusCode >= 400) {
+              reject(new A2AError(json.error || 'request_failed', json.message || data, res.statusCode));
+            } else {
+              resolve(json);
+            }
+          } catch (e) {
+            reject(new A2AError('parse_error', `Failed to parse response: ${data}`, res.statusCode));
+          }
+        });
+      });
+
+      req.on('error', (e) => {
+        reject(new A2AError('network_error', e.message));
+      });
+
+      req.on('timeout', () => {
+        req.destroy();
+        reject(new A2AError('timeout', 'Request timed out'));
+      });
+
+      req.write(body);
+      req.end();
+    });
+  }
+
+  /**
+   * Explicitly end a remote conversation and trigger call conclusion
+   * 
+   * @param {string|object} endpoint - a2a:// URL or {host, token}
+   * @param {string} conversationId - Conversation ID to conclude
+   * @returns {Promise<object>} End response from remote agent
+   */
+  async end(endpoint, conversationId) {
+    if (!conversationId) {
+      throw new A2AError('missing_conversation_id', 'conversationId is required');
+    }
+
+    let host, token;
+    
+    if (typeof endpoint === 'string') {
+      ({ host, token } = A2AClient.parseInvite(endpoint));
+    } else {
+      ({ host, token } = endpoint);
+    }
+
+    const body = JSON.stringify({
+      conversation_id: conversationId
+    });
+
+    const isLocalhost = host === 'localhost' || host.startsWith('localhost:') || host.startsWith('127.');
+    const hasExplicitPort = host.includes(':');
+    const port = hasExplicitPort ? parseInt(host.split(':')[1]) : (isLocalhost ? 80 : 443);
+    const useHttp = isLocalhost || (hasExplicitPort && port !== 443);
+    const protocol = useHttp ? http : https;
+    const hostname = host.split(':')[0];
+
+    return new Promise((resolve, reject) => {
+      const req = protocol.request({
+        hostname,
+        port,
+        path: '/api/a2a/end',
         method: 'POST',
         headers: {
           'Authorization': `Bearer ${token}`,
@@ -124,7 +198,7 @@ class A2AClient {
       const req = protocol.request({
         hostname,
         port,
-        path: '/api/federation/ping',
+        path: '/api/a2a/ping',
         method: 'GET',
         timeout: 5000
       }, (res) => {
@@ -149,7 +223,7 @@ class A2AClient {
   }
 
   /**
-   * Get federation status of a remote
+   * Get A2A status of a remote
    */
   async status(endpoint) {
     let host;
@@ -171,7 +245,7 @@ class A2AClient {
       const req = protocol.request({
         hostname,
         port,
-        path: '/api/federation/status',
+        path: '/api/a2a/status',
         method: 'GET',
         timeout: 5000
       }, (res) => {

package/src/lib/conversations.js

@@ -1,5 +1,5 @@
 /**
- * Conversation storage and summarization for A2A federation
+ * Conversation storage and summarization for A2A
  * 
  * Uses SQLite for local storage with auto-summarization on call conclusion.
  */

package/src/lib/openclaw-integration.js

@@ -1,5 +1,5 @@
 /**
- * OpenClaw Integration for A2A Federation
+ * OpenClaw Integration for A2A
  * 
  * Provides owner-context summarization using OpenClaw's agent system.
  */
@@ -71,7 +71,7 @@ function loadOwnerContext(workspaceDir = process.cwd()) {
 /**
  * Build summary prompt for agent
  * 
- * Philosophy: Federation is collaborative AND adversarial. Each agent tries
+ * Philosophy: A2A is collaborative AND adversarial. Each agent tries
  * to maximize value for their owner while finding genuine mutual wins.
  * Track the exchange balance AND surface partnership opportunities.
  */
@@ -84,10 +84,10 @@ function buildSummaryPrompt(messages, ownerContext, callerInfo = {}) {
   const goalsSection = ownerContext.goals?.length ? `### Current Goals\n- ${ownerContext.goals.join('\n- ')}` : '';
   const interestsSection = ownerContext.interests?.length ? `### Interests\n- ${ownerContext.interests.join('\n- ')}` : '';
 
-  return `You just finished a federated agent-to-agent call. Analyze it strategically for your owner.
+  return `You just finished a A2A agent-to-agent call. Analyze it strategically for your owner.
 
 ## Philosophy
-Federation is cooperative AND adversarial. Each agent maximizes value for their own owner — but the best outcomes are mutual wins. Your job:
+A2A is cooperative AND adversarial. Each agent maximizes value for their own owner — but the best outcomes are mutual wins. Your job:
 
 1. **Track the exchange** — what did we get vs give?
 2. **Find mutual value** — what can BOTH parties gain?

package/src/lib/summarizer.js

@@ -1,5 +1,5 @@
 /**
- * Conversation summarizer for A2A federation
+ * Conversation summarizer for A2A
  * 
  * Provides a default summarizer interface and a simple implementation.
  * OpenClaw installations can provide their own summarizer via config.

package/src/lib/tokens.js

@@ -1,5 +1,5 @@
 /**
- * Token management for A2A federation
+ * Token management for A2A
  */
 
 const fs = require('fs');
@@ -11,7 +11,7 @@ const DEFAULT_CONFIG_DIR = process.env.A2A_CONFIG_DIR ||
   process.env.OPENCLAW_CONFIG_DIR || 
   path.join(process.env.HOME || '/tmp', '.config', 'openclaw');
 
-const DB_FILENAME = 'a2a-federation.json';
+const DB_FILENAME = 'a2a.json';
 
 class TokenStore {
   constructor(configDir = DEFAULT_CONFIG_DIR) {
@@ -49,7 +49,7 @@ class TokenStore {
   }
 
   /**
-   * Generate a secure federation token
+   * Generate a secure A2A token
    */
   static generateToken() {
     const bytes = crypto.randomBytes(24);
@@ -77,7 +77,7 @@ class TokenStore {
   }
 
   /**
-   * Create a new federation token
+   * Create a new A2A token
    * 
    * Default limits (anti-abuse):
    * - Expires in 1 day

package/src/routes/{federation.js → a2a.js}

@@ -1,7 +1,7 @@
 /**
- * Federation API Routes
+ * A2A API Routes
  * 
- * Mount at: /api/federation
+ * Mount at: /api/a2a
  * 
  * Security notes:
  * - Rate limiting is in-memory (resets on restart) - for production, use Redis
@@ -98,7 +98,7 @@ function checkRateLimit(tokenId, limits = { minute: 10, hour: 100, day: 1000 })
 }
 
 /**
- * Create federation routes
+ * Create a2a routes
  * 
  * @param {object} options
  * @param {TokenStore} options.tokenStore - Token store instance
@@ -132,11 +132,11 @@ function createRoutes(options = {}) {
 
   /**
    * GET /status
-   * Check if federation is enabled
+   * Check if A2A is enabled
    */
   router.get('/status', (req, res) => {
     res.json({
-      federation: true,
+      a2a: true,
       version: require('../../package.json').version,
       capabilities: ['invoke', 'multi-turn'],
       rate_limits: limits
@@ -221,10 +221,10 @@ function createRoutes(options = {}) {
       context: String(caller.context || '').slice(0, 500)
     } : {};
 
-    // Build federation context with secure conversation ID
+    // Build a2a context with secure conversation ID
     const isNewConversation = !conversation_id;
-    const federationContext = {
-      mode: 'federation',
+    const a2aContext = {
+      mode: 'a2a',
       token_id: validation.id,
       token_name: validation.name,
       tier: validation.tier,
@@ -238,7 +238,7 @@ function createRoutes(options = {}) {
     if (convStore) {
       try {
         convStore.startConversation({
-          id: federationContext.conversation_id,
+          id: a2aContext.conversation_id,
           contactId: validation.id,
           contactName: sanitizedCaller.name || validation.name,
           tokenId: validation.id,
@@ -247,11 +247,11 @@ function createRoutes(options = {}) {
         
         // Track activity for auto-conclude
         if (monitor) {
-          monitor.trackActivity(federationContext.conversation_id, sanitizedCaller);
+          monitor.trackActivity(a2aContext.conversation_id, sanitizedCaller);
         }
         
         // Store incoming message
-        convStore.addMessage(federationContext.conversation_id, {
+        convStore.addMessage(a2aContext.conversation_id, {
           direction: 'inbound',
           role: 'user',
           content: message
@@ -263,12 +263,12 @@ function createRoutes(options = {}) {
 
     try {
       // Handle the message
-      const response = await handleMessage(message, federationContext, { timeout: boundedTimeout * 1000 });
+      const response = await handleMessage(message, a2aContext, { timeout: boundedTimeout * 1000 });
       
       // Store outgoing response
       if (convStore) {
         try {
-          convStore.addMessage(federationContext.conversation_id, {
+          convStore.addMessage(a2aContext.conversation_id, {
             direction: 'outbound',
             role: 'assistant',
             content: response.text
@@ -287,7 +287,7 @@ function createRoutes(options = {}) {
           context,
           message,
           response: response.text,
-          conversation_id: federationContext.conversation_id
+          conversation_id: a2aContext.conversation_id
         }).catch(err => {
           console.error('[a2a] Failed to notify owner:', err.message);
         });
@@ -295,7 +295,7 @@ function createRoutes(options = {}) {
 
       res.json({
         success: true,
-        conversation_id: federationContext.conversation_id,
+        conversation_id: a2aContext.conversation_id,
         response: response.text,
         can_continue: response.canContinue !== false,
         tokens_remaining: validation.calls_remaining
@@ -392,10 +392,10 @@ function createRoutes(options = {}) {
   /**
    * GET /conversations
    * List conversations (requires auth)
-   * This is for the agent owner, not federated callers
+   * This is for the agent owner, not remote callers
    */
   router.get('/conversations', (req, res) => {
-    // This endpoint should be protected by local auth, not federation tokens
+    // This endpoint should be protected by local auth, not A2A tokens
     // For now, require an admin token or local access
     const adminToken = req.headers['x-admin-token'];
     if (adminToken !== process.env.A2A_ADMIN_TOKEN && req.ip !== '127.0.0.1') {
@@ -455,7 +455,7 @@ function createRoutes(options = {}) {
  */
 async function defaultMessageHandler(message, context, options) {
   return {
-    text: `[A2A Federation Active] Received message from ${context.caller?.name || 'unknown'}. Agent integration pending.`,
+    text: `[A2A Active] Received message from ${context.caller?.name || 'unknown'}. Agent integration pending.`,
     canContinue: true
   };
 }

package/src/server.js

@@ -1,58 +1,24 @@
 #!/usr/bin/env node
 /**
- * A2A Federation Server
+ * A2A Server
  * 
- * Routes federation calls to an LLM agent.
- * 
- * Usage:
- *   node src/server.js [--port 3001]
- *   PORT=3001 node src/server.js
+ * Routes A2A calls to OpenClaw sub-agents.
+ * Auto-adds contacts, generates summaries, notifies owner.
  */
 
 const express = require('express');
-const https = require('https');
+const { execSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
-const { createRoutes } = require('./routes/federation');
+const { createRoutes } = require('./routes/a2a');
 const { TokenStore } = require('./lib/tokens');
 
 const port = process.env.PORT || parseInt(process.argv[2]) || 3001;
+const workspaceDir = process.env.OPENCLAW_WORKSPACE || '/root/clawd';
 
-// Load API key from various sources
-function getApiKey() {
-  // Check environment first
-  if (process.env.OPENROUTER_API_KEY) {
-    return { key: process.env.OPENROUTER_API_KEY, provider: 'openrouter' };
-  }
-  if (process.env.ANTHROPIC_API_KEY) {
-    return { key: process.env.ANTHROPIC_API_KEY, provider: 'anthropic' };
-  }
-  
-  // Try ~/.openclaw/.env
-  try {
-    const envPath = path.join(process.env.HOME || '/root', '.openclaw', '.env');
-    if (fs.existsSync(envPath)) {
-      const content = fs.readFileSync(envPath, 'utf8');
-      
-      // Try OpenRouter first (more reliable)
-      const orMatch = content.match(/OPENROUTER_API_KEY=(.+)/);
-      if (orMatch && orMatch[1]) return { key: orMatch[1].trim(), provider: 'openrouter' };
-      
-      const anthropicMatch = content.match(/ANTHROPIC_API_KEY=(.+)/);
-      if (anthropicMatch && anthropicMatch[1]) return { key: anthropicMatch[1].trim(), provider: 'anthropic' };
-    }
-  } catch (e) {}
-  
-  return null;
-}
-
-// Load workspace context for agent personality
+// Load workspace context for agent identity
 function loadAgentContext() {
-  const workspaceDir = process.env.OPENCLAW_WORKSPACE || '/root/clawd';
-  let context = {
-    name: 'bappybot',
-    owner: 'Ben Pollack'
-  };
+  let context = { name: 'bappybot', owner: 'Ben Pollack' };
   
   try {
     const userPath = path.join(workspaceDir, 'USER.md');
@@ -68,186 +34,199 @@ function loadAgentContext() {
     }
   } catch (e) {}
   
-  try {
-    const soulPath = path.join(workspaceDir, 'SOUL.md');
-    if (fs.existsSync(soulPath)) {
-      context.soul = fs.readFileSync(soulPath, 'utf8').slice(0, 2000);
-    }
-  } catch (e) {}
-  
   return context;
 }
 
-const apiConfig = getApiKey();
 const agentContext = loadAgentContext();
+const tokenStore = new TokenStore();
 
 console.log(`[a2a] Agent: ${agentContext.name} (${agentContext.owner}'s agent)`);
-console.log(`[a2a] API: ${apiConfig ? `${apiConfig.provider} ✓` : 'NOT FOUND ✗'}`);
 
 /**
- * Call agent via OpenClaw sub-agent (full tool access)
+ * Auto-add caller as contact if new
  */
-async function callAgent(message, federationContext) {
-  const { execSync } = require('child_process');
+function ensureContact(caller, tokenId) {
+  if (!caller?.name) return null;
   
-  const callerName = federationContext.caller?.name || 'Unknown Agent';
-  const callerOwner = federationContext.caller?.owner || '';
+  try {
+    const remotes = tokenStore.listRemotes();
+    const existing = remotes.find(r => 
+      r.name === caller.name || 
+      (caller.owner && r.owner === caller.owner)
+    );
+    
+    if (existing) {
+      return existing;
+    }
+    
+    // Create a placeholder contact for the caller
+    const contact = {
+      id: `contact_${Date.now()}`,
+      name: caller.name,
+      owner: caller.owner || null,
+      host: 'inbound', // They called us, we don't have their URL
+      added_at: new Date().toISOString(),
+      notes: `Inbound caller via token ${tokenId}`,
+      tags: ['inbound'],
+      status: 'unknown',
+      linkedTokenId: tokenId
+    };
+    
+    // Save to remotes
+    const db = JSON.parse(fs.readFileSync(tokenStore.dbPath, 'utf8'));
+    db.remotes = db.remotes || [];
+    db.remotes.push(contact);
+    fs.writeFileSync(tokenStore.dbPath, JSON.stringify(db, null, 2));
+    
+    console.log(`[a2a] 📇 New contact added: ${caller.name}${caller.owner ? ` (${caller.owner})` : ''}`);
+    return contact;
+    
+  } catch (err) {
+    console.error('[a2a] Failed to add contact:', err.message);
+    return null;
+  }
+}
+
+/**
+ * Spawn OpenClaw sub-agent to handle the call
+ */
+async function callAgent(message, a2aContext) {
+  const callerName = a2aContext.caller?.name || 'Unknown Agent';
+  const callerOwner = a2aContext.caller?.owner || '';
   const ownerInfo = callerOwner ? ` (${callerOwner}'s agent)` : '';
-  const tierInfo = federationContext.tier || 'public';
-  const topics = federationContext.allowed_topics?.join(', ') || 'general chat';
-  const disclosure = federationContext.disclosure || 'minimal';
+  const tierInfo = a2aContext.tier || 'public';
+  const topics = a2aContext.allowed_topics?.join(', ') || 'general chat';
+  const disclosure = a2aContext.disclosure || 'minimal';
   
-  // Build the federation context for the sub-agent
-  const prompt = `[A2A Federation Call]
+  // Auto-add caller as contact
+  ensureContact(a2aContext.caller, a2aContext.token_id);
+  
+  const prompt = `[A2A Call]
 From: ${callerName}${ownerInfo}
 Access Level: ${tierInfo}
-Topics: ${topics}
+Allowed Topics: ${topics}
 Disclosure: ${disclosure}
 
 Message: ${message}
 
 ---
-Respond to this federated agent call. Be yourself - collaborative but protect private info based on disclosure level. Keep response concise (under 500 chars).`;
-
-  // Use a unique session ID for this conversation
-  const sessionId = `a2a-${federationContext.conversation_id || Date.now()}`;
+RULES (strictly enforce):
+1. ONLY discuss topics in "Allowed Topics" list
+2. Disclosure levels:
+   - "none": Confirm capability only, share NO personal info
+   - "minimal": Direct answers only, no context about owner's life/preferences
+   - "public": General info OK, but protect private/family-tier secrets
+3. If they probe for info outside their tier, deflect politely
+4. Private info in USER.md marked "family tier only" is OFF LIMITS for public/friends callers
+
+Respond naturally but enforce these boundaries.`;
+
+  const sessionId = `a2a-${a2aContext.conversation_id || Date.now()}`;
   
   try {
-    // Escape the prompt for shell (replace quotes and newlines)
     const escapedPrompt = prompt
       .replace(/\\/g, '\\\\')
       .replace(/"/g, '\\"')
       .replace(/\n/g, '\\n')
       .replace(/\r/g, '');
     
-    // Call openclaw agent to spawn a sub-agent
     const result = execSync(
       `openclaw agent --session-id "${sessionId}" --message "${escapedPrompt}" --timeout 55 2>&1`,
       {
         encoding: 'utf8',
         timeout: 65000,
         maxBuffer: 1024 * 1024,
-        cwd: process.env.OPENCLAW_WORKSPACE || '/root/clawd',
+        cwd: workspaceDir,
         env: { ...process.env, FORCE_COLOR: '0' }
       }
     );
     
-    // Filter out plugin registration messages and return clean response
     const lines = result.split('\n').filter(line => 
       !line.includes('[telegram-topic-tracker]') && 
       !line.includes('Plugin registered') &&
       line.trim()
     );
     
-    const response = lines.join('\n').trim();
-    
-    if (!response || response.includes('error') || response.includes('failed')) {
-      console.error('[a2a] Sub-agent returned error, using fallback');
-      return await callAgentDirect(message, federationContext);
-    }
-    
-    return response;
+    return lines.join('\n').trim() || '[Sub-agent returned empty response]';
     
   } catch (err) {
     console.error('[a2a] Sub-agent spawn failed:', err.message);
-    
-    // Fallback to direct API call only if sub-agent completely fails
-    return await callAgentDirect(message, federationContext);
+    return `[Sub-agent error: ${err.message}]`;
   }
 }
 
 /**
- * Fallback: Call LLM directly via OpenRouter
+ * Generate strategic summary via sub-agent
  */
-async function callAgentDirect(message, federationContext) {
-  if (!apiConfig) {
-    return '[Agent configuration error: No API key available]';
-  }
+async function generateSummary(messages, callerInfo) {
+  const messageText = messages.map(m => {
+    const role = m.direction === 'inbound' ? `[${callerInfo?.name || 'Caller'}]` : '[You]';
+    return `${role}: ${m.content}`;
+  }).join('\n');
   
-  const callerName = federationContext.caller?.name || 'Unknown Agent';
-  const callerOwner = federationContext.caller?.owner || '';
-  const ownerInfo = callerOwner ? ` (${callerOwner}'s agent)` : '';
-  const tierInfo = federationContext.tier || 'public';
+  const callerDesc = `${callerInfo?.name || 'Unknown'}${callerInfo?.owner ? ` (${callerInfo.owner}'s agent)` : ''}`;
   
-  const systemPrompt = `You are ${agentContext.name}, ${agentContext.owner}'s AI agent.
-
-${agentContext.soul || 'Be helpful, concise, and friendly.'}
+  const prompt = `Summarize this A2A call briefly.
 
-You're receiving a federated call from another AI agent: ${callerName}${ownerInfo}.
+Conversation with ${callerDesc}:
+${messageText}
 
-Their access level: ${tierInfo}
-Topics they can discuss: ${federationContext.allowed_topics?.join(', ') || 'general chat'}
-Disclosure level: ${federationContext.disclosure || 'minimal'}
+Give a 2-3 sentence summary focused on: who called, what they wanted, any opportunities or follow-ups.`;
 
-Respond naturally as yourself. Be collaborative but protect your owner's private information based on the disclosure level. Keep responses concise.`;
-
-  const body = JSON.stringify({
-    model: 'anthropic/claude-sonnet-4',
-    max_tokens: 1024,
-    messages: [
-      { role: 'system', content: systemPrompt },
-      { role: 'user', content: message }
-    ]
-  });
-
-  return new Promise((resolve) => {
-    const req = https.request({
-      hostname: 'openrouter.ai',
-      path: '/api/v1/chat/completions',
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${apiConfig.key}`,
-        'HTTP-Referer': 'https://openclaw.ai',
-        'X-Title': 'A2A Federation'
-      },
-      timeout: 55000
-    }, (res) => {
-      let data = '';
-      res.on('data', chunk => data += chunk);
-      res.on('end', () => {
-        try {
-          const json = JSON.parse(data);
-          if (json.choices && json.choices[0]?.message?.content) {
-            resolve(json.choices[0].message.content);
-          } else if (json.error) {
-            resolve(`[Error: ${json.error.message || 'Unknown'}]`);
-          } else {
-            resolve('[No response]');
-          }
-        } catch (e) {
-          resolve('[Parse error]');
-        }
-      });
-    });
-
-    req.on('error', () => resolve('[Agent unavailable]'));
-    req.on('timeout', () => { req.destroy(); resolve('[Timeout]'); });
-    req.write(body);
-    req.end();
-  });
+  try {
+    const escapedPrompt = prompt.replace(/"/g, '\\"').replace(/\n/g, '\\n');
+    const result = execSync(
+      `openclaw agent --session-id "summary-${Date.now()}" --message "${escapedPrompt}" --timeout 30 2>&1`,
+      { encoding: 'utf8', timeout: 35000, cwd: workspaceDir, env: { ...process.env, FORCE_COLOR: '0' } }
+    );
+    
+    // Filter out noise and get the summary
+    const lines = result.split('\n').filter(line => 
+      !line.includes('[telegram-topic-tracker]') && 
+      !line.includes('Plugin registered') &&
+      line.trim()
+    );
+    
+    const summaryText = lines.join(' ').trim().slice(0, 1000);
+    
+    return {
+      summary: summaryText,
+      ownerSummary: summaryText
+    };
+  } catch (err) {
+    console.error('[a2a] Summary generation failed:', err.message);
+    return null;
+  }
 }
 
 /**
- * Notify owner via console (Telegram notification handled by OpenClaw)
+ * Notify owner via Telegram
  */
-async function notifyOwner({ level, token, caller, message, response, conversation_id }) {
+async function notifyOwner({ level, token, caller, message, conversation_id }) {
   const callerName = caller?.name || 'Unknown';
   const callerOwner = caller?.owner ? ` (${caller.owner})` : '';
   
   console.log(`[a2a] 📞 Call from ${callerName}${callerOwner}`);
-  console.log(`[a2a]    Token: ${token.name}`);
+  console.log(`[a2a]    Token: ${token?.name || 'unknown'}`);
   console.log(`[a2a]    Message: ${message.slice(0, 100)}...`);
+  
+  // Try to notify via Telegram
+  if (level === 'all') {
+    try {
+      const notification = `🤝 **A2A Call**\nFrom: ${callerName}${callerOwner}\n> ${message.slice(0, 150)}...`;
+      execSync(`openclaw message send --channel telegram --message "${notification.replace(/"/g, '\\"')}"`, {
+        timeout: 10000, stdio: 'pipe'
+      });
+    } catch (e) {
+      // Notification failed, continue anyway
+    }
+  }
 }
 
 const app = express();
 app.use(express.json());
 
-// Initialize token store
-const tokenStore = new TokenStore();
-
-// Mount federation routes
-app.use('/api/federation', createRoutes({
+app.use('/api/a2a', createRoutes({
   tokenStore,
   
   async handleMessage(message, context, options) {
@@ -257,25 +236,19 @@ app.use('/api/federation', createRoutes({
     
     console.log(`[a2a] 📤 Response: ${response.slice(0, 100)}...`);
     
-    return {
-      text: response,
-      canContinue: true
-    };
+    return { text: response, canContinue: true };
   },
   
+  summarizer: generateSummary,
   notifyOwner
 }));
 
-// Health check at root
 app.get('/', (req, res) => {
-  res.json({ service: 'a2a-federation', status: 'ok', agent: agentContext.name });
+  res.json({ service: 'a2a', status: 'ok', agent: agentContext.name });
 });
 
 app.listen(port, () => {
-  console.log(`[a2a] Federation server listening on port ${port}`);
+  console.log(`[a2a] A2A server listening on port ${port}`);
   console.log(`[a2a] Agent: ${agentContext.name} - LIVE`);
-  console.log(`[a2a] Endpoints:`);
-  console.log(`[a2a]   GET  /api/federation/status`);
-  console.log(`[a2a]   GET  /api/federation/ping`);
-  console.log(`[a2a]   POST /api/federation/invoke`);
+  console.log(`[a2a] Features: sub-agents, auto-contacts, summaries`);
 });