a2acalling 0.1.0

package/src/lib/openclaw-integration.js

@@ -0,0 +1,329 @@
+/**
+ * OpenClaw Integration for A2A Federation
+ * 
+ * Provides owner-context summarization using OpenClaw's agent system.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Load owner context from OpenClaw workspace files
+ */
+function loadOwnerContext(workspaceDir = process.cwd()) {
+  const context = {
+    goals: [],
+    interests: [],
+    context: '',
+    user: null,
+    memory: null
+  };
+
+  // Load USER.md
+  const userPath = path.join(workspaceDir, 'USER.md');
+  if (fs.existsSync(userPath)) {
+    context.user = fs.readFileSync(userPath, 'utf8');
+    // Extract goals from USER.md
+    const goalsMatch = context.user.match(/##\s*(?:Goals|Current|Seeking)[^\n]*\n([\s\S]*?)(?=\n##|$)/i);
+    if (goalsMatch) {
+      context.goals = goalsMatch[1]
+        .split('\n')
+        .filter(l => l.trim().startsWith('-') || l.trim().startsWith('*'))
+        .map(l => l.replace(/^[\s\-\*]+/, '').trim())
+        .filter(Boolean);
+    }
+    // Extract interests
+    const interestsMatch = context.user.match(/##\s*(?:Interests|Projects)[^\n]*\n([\s\S]*?)(?=\n##|$)/i);
+    if (interestsMatch) {
+      context.interests = interestsMatch[1]
+        .split('\n')
+        .filter(l => l.trim().startsWith('-') || l.trim().startsWith('*'))
+        .map(l => l.replace(/^[\s\-\*]+/, '').trim())
+        .filter(Boolean);
+    }
+  }
+
+  // Load recent memory
+  const memoryDir = path.join(workspaceDir, 'memory');
+  if (fs.existsSync(memoryDir)) {
+    const files = fs.readdirSync(memoryDir)
+      .filter(f => f.endsWith('.md'))
+      .sort()
+      .reverse()
+      .slice(0, 3); // Last 3 memory files
+    
+    context.memory = files.map(f => {
+      const content = fs.readFileSync(path.join(memoryDir, f), 'utf8');
+      return `## ${f}\n${content}`;
+    }).join('\n\n');
+  }
+
+  // Load MEMORY.md if exists
+  const mainMemoryPath = path.join(workspaceDir, 'MEMORY.md');
+  if (fs.existsSync(mainMemoryPath)) {
+    const mainMemory = fs.readFileSync(mainMemoryPath, 'utf8');
+    context.memory = mainMemory + '\n\n' + (context.memory || '');
+  }
+
+  return context;
+}
+
+/**
+ * Build summary prompt for agent
+ * 
+ * Philosophy: Federation 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.
+ */
+function buildSummaryPrompt(messages, ownerContext, callerInfo = {}) {
+  const messageText = messages.map(m => {
+    const role = m.direction === 'inbound' ? `[Caller${callerInfo.name ? ` - ${callerInfo.name}` : ''}]` : '[You]';
+    return `${role}: ${m.content}`;
+  }).join('\n\n');
+
+  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.
+
+## Philosophy
+Federation 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?
+3. **Surface alignment** — does this connect to owner's goals?
+4. **Advise strategically** — protect interests while building relationships
+
+## Your Owner's Context
+${ownerContext.user ? `### From USER.md\n${ownerContext.user.slice(0, 2000)}` : ''}
+
+${goalsSection}
+
+${interestsSection}
+
+## The Conversation
+${messageText}
+
+## Caller Context
+${callerInfo.name ? `Name: ${callerInfo.name}` : 'Unknown caller'}
+${callerInfo.context ? `Context: ${callerInfo.context}` : ''}
+
+## Your Task
+Analyze as a strategic advisor. Return JSON:
+
+{
+  "summary": "Brief neutral summary (shareable)",
+  
+  "exchange": {
+    "weGot": ["info, commitments, or value we extracted"],
+    "weGave": ["info, compute, or commitments we provided"],
+    "balance": "favorable | even | unfavorable",
+    "fair": true
+  },
+  
+  "mutualValue": {
+    "found": true,
+    "opportunities": ["potential wins for BOTH sides"],
+    "alignment": "how this connects to owner's goals"
+  },
+  
+  "actionItems": {
+    "owner": ["what YOUR OWNER should do"],
+    "caller": ["what THEY committed to or should do"],
+    "joint": ["things to do TOGETHER"]
+  },
+  
+  "trust": {
+    "assessment": "appropriate | too_high | too_low",
+    "recommendation": "maintain | increase | decrease | revoke",
+    "pattern": "What's their angle? Genuine partner or extractive?"
+  },
+  
+  "ownerBrief": "2-3 sentences: the strategic takeaway for your owner",
+  "followUp": "concrete next step to advance this relationship (if any)"
+}
+
+Think like a strategic advisor: protect your owner's interests AND find mutual wins.
+
+JSON:`;
+}
+
+/**
+ * Create an OpenClaw summarizer that uses exec to call the agent
+ * This works by writing a prompt file and using openclaw's CLI
+ */
+function createExecSummarizer(workspaceDir = process.cwd()) {
+  const { execSync } = require('child_process');
+  
+  return async function(messages, callerInfo = {}) {
+    const ownerContext = loadOwnerContext(workspaceDir);
+    const prompt = buildSummaryPrompt(messages, ownerContext, callerInfo);
+    
+    // Write prompt to temp file
+    const tmpFile = `/tmp/a2a-summary-${Date.now()}.txt`;
+    fs.writeFileSync(tmpFile, prompt);
+    
+    try {
+      // Call openclaw CLI to get agent response
+      // This assumes openclaw has a way to do single-shot prompts
+      const result = execSync(
+        `cat "${tmpFile}" | openclaw prompt --json 2>/dev/null || echo '{}'`,
+        { encoding: 'utf8', timeout: 30000 }
+      );
+      
+      // Parse JSON from response
+      const jsonMatch = result.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        return JSON.parse(jsonMatch[0]);
+      }
+      
+      return {
+        summary: result.slice(0, 500),
+        ownerSummary: null,
+        relevance: 'unknown',
+        goalsTouched: [],
+        actionItems: [],
+        followUp: null,
+        notes: null
+      };
+    } catch (err) {
+      console.error('[a2a] Exec summarizer failed:', err.message);
+      return { summary: null };
+    } finally {
+      // Cleanup
+      try { fs.unlinkSync(tmpFile); } catch (e) {}
+    }
+  };
+}
+
+/**
+ * Create a summarizer that posts to a local HTTP endpoint
+ * OpenClaw can expose an internal summarization endpoint
+ */
+function createHttpSummarizer(endpoint = 'http://localhost:3000/api/summarize') {
+  const http = require('http');
+  const https = require('https');
+  
+  return async function(messages, callerInfo = {}) {
+    const ownerContext = loadOwnerContext();
+    const prompt = buildSummaryPrompt(messages, ownerContext, callerInfo);
+    
+    return new Promise((resolve) => {
+      const url = new URL(endpoint);
+      const client = url.protocol === 'https:' ? https : http;
+      
+      const req = client.request({
+        hostname: url.hostname,
+        port: url.port,
+        path: url.pathname,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        timeout: 30000
+      }, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          try {
+            resolve(JSON.parse(data));
+          } catch (e) {
+            resolve({ summary: data.slice(0, 500) });
+          }
+        });
+      });
+      
+      req.on('error', (err) => {
+        console.error('[a2a] HTTP summarizer failed:', err.message);
+        resolve({ summary: null });
+      });
+      
+      req.write(JSON.stringify({ prompt, messages, callerInfo }));
+      req.end();
+    });
+  };
+}
+
+/**
+ * Create a summarizer using sessions_send to the main OpenClaw session
+ * This is the preferred method when running inside OpenClaw
+ */
+function createSessionSummarizer(gatewayUrl, gatewayToken) {
+  const http = require('http');
+  const https = require('https');
+  
+  return async function(messages, callerInfo = {}) {
+    const ownerContext = loadOwnerContext();
+    const prompt = buildSummaryPrompt(messages, ownerContext, callerInfo);
+    
+    // Send to OpenClaw gateway's internal API
+    return new Promise((resolve) => {
+      const url = new URL(gatewayUrl || 'http://localhost:3000');
+      const client = url.protocol === 'https:' ? https : http;
+      
+      const req = client.request({
+        hostname: url.hostname,
+        port: url.port,
+        path: '/api/internal/summarize',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${gatewayToken || process.env.OPENCLAW_TOKEN}`
+        },
+        timeout: 60000
+      }, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          try {
+            const result = JSON.parse(data);
+            resolve(result.summary || result);
+          } catch (e) {
+            resolve({ summary: data.slice(0, 500) });
+          }
+        });
+      });
+      
+      req.on('error', (err) => {
+        console.error('[a2a] Session summarizer failed:', err.message);
+        resolve({ summary: null });
+      });
+      
+      req.write(JSON.stringify({ prompt }));
+      req.end();
+    });
+  };
+}
+
+/**
+ * Auto-detect best summarizer based on environment
+ */
+function createAutoSummarizer(options = {}) {
+  const workspaceDir = options.workspaceDir || process.env.OPENCLAW_WORKSPACE || process.cwd();
+  
+  // If gateway URL provided, use session summarizer
+  if (options.gatewayUrl || process.env.OPENCLAW_GATEWAY_URL) {
+    console.log('[a2a] Using session summarizer');
+    return createSessionSummarizer(
+      options.gatewayUrl || process.env.OPENCLAW_GATEWAY_URL,
+      options.gatewayToken || process.env.OPENCLAW_TOKEN
+    );
+  }
+  
+  // If HTTP endpoint provided, use that
+  if (options.summaryEndpoint) {
+    console.log('[a2a] Using HTTP summarizer');
+    return createHttpSummarizer(options.summaryEndpoint);
+  }
+  
+  // Fall back to exec summarizer
+  console.log('[a2a] Using exec summarizer');
+  return createExecSummarizer(workspaceDir);
+}
+
+module.exports = {
+  loadOwnerContext,
+  buildSummaryPrompt,
+  createExecSummarizer,
+  createHttpSummarizer,
+  createSessionSummarizer,
+  createAutoSummarizer
+};

package/src/lib/summarizer.js

@@ -0,0 +1,137 @@
+/**
+ * Conversation summarizer for A2A federation
+ * 
+ * Provides a default summarizer interface and a simple implementation.
+ * OpenClaw installations can provide their own summarizer via config.
+ */
+
+/**
+ * Default summarizer using simple extraction (no LLM)
+ * Returns basic summary without owner context
+ */
+function defaultSummarizer(messages, ownerContext = {}) {
+  if (!messages || messages.length === 0) {
+    return { summary: null };
+  }
+
+  // Extract key information
+  const messageCount = messages.length;
+  const firstMessage = messages[0];
+  const lastMessage = messages[messages.length - 1];
+  const inboundCount = messages.filter(m => m.direction === 'inbound').length;
+  const outboundCount = messages.filter(m => m.direction === 'outbound').length;
+
+  // Simple extractive summary (first message + last message)
+  const summary = `${messageCount} messages exchanged. Started: "${truncate(firstMessage.content, 100)}". Ended: "${truncate(lastMessage.content, 100)}"`;
+
+  return {
+    summary,
+    ownerSummary: null, // No owner context without LLM
+    relevance: 'unknown',
+    goalsTouched: [],
+    actionItems: [],
+    followUp: null,
+    notes: null
+  };
+}
+
+/**
+ * Create a summarizer that uses an LLM via a callback
+ * 
+ * @param {function} llmCall - async function(prompt) => string
+ * @returns {function} summarizer function
+ */
+function createLLMSummarizer(llmCall) {
+  return async function(messages, ownerContext = {}) {
+    if (!messages || messages.length === 0) {
+      return { summary: null };
+    }
+
+    // Format messages for prompt
+    const messageText = messages.map(m => {
+      const role = m.direction === 'inbound' ? 'Caller' : 'You';
+      return `${role}: ${m.content}`;
+    }).join('\n');
+
+    // Build owner context section
+    let ownerSection = '';
+    if (ownerContext.goals) {
+      ownerSection += `\nOwner's current goals:\n${ownerContext.goals.join('\n- ')}`;
+    }
+    if (ownerContext.interests) {
+      ownerSection += `\nOwner's interests:\n${ownerContext.interests.join('\n- ')}`;
+    }
+    if (ownerContext.context) {
+      ownerSection += `\nAdditional context:\n${ownerContext.context}`;
+    }
+
+    const prompt = `You are summarizing a conversation between two AI agents for the receiving agent's owner.
+${ownerSection}
+
+Conversation:
+${messageText}
+
+Provide a JSON response with:
+{
+  "summary": "Brief neutral summary of what was discussed",
+  "ownerSummary": "Summary from the owner's perspective - what does this mean for them?",
+  "relevance": "low/medium/high - how relevant to owner's goals",
+  "goalsTouched": ["list", "of", "goals", "this", "relates", "to"],
+  "actionItems": ["any", "action", "items", "for", "owner"],
+  "followUp": "Suggested follow-up if any",
+  "notes": "Any other relevant notes for the owner"
+}
+
+JSON response:`;
+
+    try {
+      const response = await llmCall(prompt);
+      // Extract JSON from response
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        return JSON.parse(jsonMatch[0]);
+      }
+      // Fallback if JSON extraction fails
+      return {
+        summary: response,
+        ownerSummary: null,
+        relevance: 'unknown',
+        goalsTouched: [],
+        actionItems: [],
+        followUp: null,
+        notes: null
+      };
+    } catch (err) {
+      console.error('[a2a] LLM summarization failed:', err.message);
+      return defaultSummarizer(messages, ownerContext);
+    }
+  };
+}
+
+/**
+ * Summarizer that calls OpenClaw's sessions_send to use the main agent
+ * This allows using the owner's configured model
+ */
+function createOpenClawSummarizer(openclawConfig = {}) {
+  return async function(messages, ownerContext = {}) {
+    // This would integrate with OpenClaw's internal APIs
+    // For now, fall back to default
+    console.warn('[a2a] OpenClaw summarizer not yet integrated, using default');
+    return defaultSummarizer(messages, ownerContext);
+  };
+}
+
+/**
+ * Truncate string with ellipsis
+ */
+function truncate(str, maxLen) {
+  if (!str) return '';
+  if (str.length <= maxLen) return str;
+  return str.substring(0, maxLen - 3) + '...';
+}
+
+module.exports = {
+  defaultSummarizer,
+  createLLMSummarizer,
+  createOpenClawSummarizer
+};