a2acalling 0.6.75 → 0.6.76

package/.claude/worktrees/agent-acefedbd/.claude/worktrees/agent-a04dc0fe/src/index.js

@@ -0,0 +1,76 @@
+/**
+ * A2A Calling - Agent-to-Agent Communication for OpenClaw
+ * 
+ * @example
+ * // Server side - mount routes
+ * const { createRoutes, TokenStore } = require('a2acalling');
+ * const tokenStore = new TokenStore();
+ * app.use('/api/a2a', createRoutes({ tokenStore, handleMessage }));
+ * 
+ * @example
+ * // Client side - call remote agent
+ * const { A2AClient } = require('a2acalling');
+ * const client = new A2AClient({ caller: { name: 'My Agent' } });
+ * const response = await client.call('a2a://host/token', 'Hello!');
+ */
+
+const { TokenStore } = require('./lib/tokens');
+const { A2AClient, A2AError } = require('./lib/client');
+const { createRoutes } = require('./routes/a2a');
+const { createDashboardApiRouter, createDashboardUiRouter } = require('./routes/dashboard');
+const { createRuntimeAdapter, resolveRuntimeMode } = require('./lib/runtime-adapter');
+const { createLogger, createTraceId } = require('./lib/logger');
+
+// Lazy load optional dependencies
+let ConversationStore = null;
+let summarizers = null;
+let CallMonitor = null;
+let openclawIntegration = null;
+
+try {
+  ConversationStore = require('./lib/conversations').ConversationStore;
+  summarizers = require('./lib/summarizer');
+  CallMonitor = require('./lib/call-monitor').CallMonitor;
+  openclawIntegration = require('./lib/openclaw-integration');
+} catch (err) {
+  // Optional dependencies not installed
+}
+
+module.exports = {
+  // Token management
+  TokenStore,
+  
+  // Client for outbound calls
+  A2AClient,
+  A2AError,
+  
+  // Express routes for inbound calls
+  createRoutes,
+
+  // Dashboard routes
+  createDashboardApiRouter,
+  createDashboardUiRouter,
+
+  // Runtime adapter
+  createRuntimeAdapter,
+  resolveRuntimeMode,
+
+  // Structured logging
+  createLogger,
+  createTraceId,
+  
+  // Conversation storage (requires better-sqlite3)
+  ConversationStore,
+  
+  // Call monitoring for auto-conclude
+  CallMonitor,
+  
+  // Summarizers for conversation conclusion
+  ...(summarizers || {}),
+  
+  // OpenClaw integration helpers
+  ...(openclawIntegration || {}),
+  
+  // Version
+  version: require('../package.json').version
+};

package/.claude/worktrees/agent-acefedbd/.claude/worktrees/agent-a04dc0fe/src/lib/agent-card.js

@@ -0,0 +1,111 @@
+/**
+ * Google A2A Agent Card Builder
+ *
+ * Assembles a standards-compliant Agent Card from existing config,
+ * disclosure manifest, and crypto identity. The card is served at
+ * GET /.well-known/a2a-agent-card and mirrored at GET /api/a2a/agent-card.
+ *
+ * Reference: A2A-75 assessment, A2A-76 implementation ticket.
+ */
+
+const crypto = require('node:crypto');
+const { fingerprint } = require('./crypto');
+
+/**
+ * Build a Google A2A-compliant Agent Card.
+ *
+ * @param {object} opts
+ * @param {object} opts.config    - Result of A2AConfig.getAgent()
+ * @param {object} opts.manifest  - Result of getTopicsForTier('public')
+ * @param {string|null} opts.publicKey - Base64-encoded Ed25519 public key (or null)
+ * @param {string} opts.serverUrl - Externally-reachable base URL (e.g. "https://host.com")
+ * @param {string} opts.version   - Package version string
+ * @returns {object} Agent Card JSON
+ */
+function buildAgentCard({ config, manifest, publicKey, serverUrl, version }) {
+  const agentName = config?.name || 'a2a-agent';
+  const agentDescription = config?.description || '';
+  const ownerName = config?.owner || '';
+
+  // Agent ID: Ed25519 fingerprint if available, else deterministic hash of name + hostname
+  const id = publicKey
+    ? fingerprint(publicKey)
+    : crypto.createHash('sha256')
+        .update(`${agentName}:${config?.hostname || 'localhost'}`)
+        .digest('hex')
+        .match(/.{2}/g)
+        .join(':');
+
+  // Map public-tier disclosure topics → Agent Card skills
+  const topics = (manifest && Array.isArray(manifest.topics)) ? manifest.topics : [];
+  const skills = topics
+    .filter(t => t?.topic)
+    .map(t => ({
+      id: t.topic.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, ''),
+      name: t.topic,
+      description: t.description || ''
+    }));
+
+  // Normalize server URL (strip trailing slash)
+  const baseUrl = (serverUrl || '').replace(/\/+$/, '');
+
+  const card = {
+    id,
+    name: agentName,
+    version: version || '0.0.0',
+    provider: ownerName ? { name: ownerName } : undefined,
+    description: agentDescription || undefined,
+    capabilities: {
+      streaming: false,
+      pushNotifications: false,
+      extendedAgentCard: false
+    },
+    skills,
+    interfaces: [
+      {
+        type: 'rest',
+        url: `${baseUrl}/api/a2a/`,
+        version: '0.3'
+      }
+    ],
+    securitySchemes: {
+      bearerAuth: {
+        type: 'http',
+        scheme: 'bearer',
+        description: 'A2A federation token (fed_xxx)'
+      }
+    },
+    security: [{ bearerAuth: [] }],
+    extensions: [
+      {
+        uri: 'https://openclaw.dev/a2a/extensions/trust-tiers',
+        version: '1.0.0',
+        required: false,
+        data: {
+          tiers: ['public', 'friends', 'family'],
+          default_tier: 'public',
+          disclosure_levels: ['public', 'minimal', 'none'],
+          default_disclosure: 'minimal',
+          supports_topics: true,
+          supports_goals: true,
+          owner_notifications: true,
+          max_calls_enforced: true
+        }
+      }
+    ]
+  };
+
+  // Include signature identity only when a keypair exists
+  if (publicKey) {
+    card.signature = {
+      algorithm: 'ed25519',
+      publicKey,
+      fingerprint: fingerprint(publicKey)
+    };
+  }
+
+  // Strip undefined values for clean JSON
+  return JSON.parse(JSON.stringify(card));
+}
+
+module.exports = { buildAgentCard };

package/.claude/worktrees/agent-acefedbd/.claude/worktrees/agent-a04dc0fe/src/lib/call-monitor.js

@@ -0,0 +1,205 @@
+/**
+ * Call Monitor - Auto-concludes idle conversations
+ * 
+ * Monitors active conversations and triggers summarization when:
+ * - No messages for 60 seconds (configurable)
+ * - Explicit end signal received
+ * - Max duration exceeded
+ */
+
+const { createLogger } = require('./logger');
+
+class CallMonitor {
+  constructor(options = {}) {
+    this.convStore = options.convStore;
+    this.summarizer = options.summarizer;
+    this.notifyOwner = options.notifyOwner || (() => {});
+    this.ownerContext = options.ownerContext || {};
+    this.logger = options.logger || createLogger({ component: 'a2a.call-monitor' });
+    
+    // Timing config
+    this.idleTimeoutMs = options.idleTimeoutMs || 60000;      // 60s idle
+    this.maxDurationMs = options.maxDurationMs || 300000;     // 5min max
+    this.checkIntervalMs = options.checkIntervalMs || 10000;  // Check every 10s
+    
+    this.intervalId = null;
+    this.activeConversations = new Map(); // conversationId -> { startTime, lastActivity, callerInfo }
+  }
+
+  /**
+   * Start monitoring
+   */
+  start() {
+    if (this.intervalId) return;
+    
+    this.intervalId = setInterval(() => {
+      this._checkIdleConversations();
+    }, this.checkIntervalMs);
+    
+    this.logger.info('Call monitor started', {
+      event: 'call_monitor_started',
+      data: {
+        idle_timeout_ms: this.idleTimeoutMs,
+        max_duration_ms: this.maxDurationMs,
+        check_interval_ms: this.checkIntervalMs
+      }
+    });
+  }
+
+  /**
+   * Stop monitoring
+   */
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+      this.logger.info('Call monitor stopped', { event: 'call_monitor_stopped' });
+    }
+  }
+
+  /**
+   * Track a new or continuing conversation
+   */
+  trackActivity(conversationId, callerInfo = {}) {
+    const now = Date.now();
+    const existing = this.activeConversations.get(conversationId);
+    
+    if (existing) {
+      existing.lastActivity = now;
+    } else {
+      this.activeConversations.set(conversationId, {
+        startTime: now,
+        lastActivity: now,
+        callerInfo
+      });
+      this.logger.debug('Tracking new conversation activity', {
+        event: 'call_monitor_track_new',
+        conversationId,
+        traceId: callerInfo?.trace_id || callerInfo?.traceId,
+        data: {
+          caller_name: callerInfo?.name || null
+        }
+      });
+    }
+  }
+
+  /**
+   * Explicitly end a conversation
+   */
+  async endConversation(conversationId, reason = 'explicit') {
+    const convData = this.activeConversations.get(conversationId);
+    this.activeConversations.delete(conversationId);
+    
+    if (!this.convStore) return { success: false, error: 'no_store' };
+    
+    try {
+      this.logger.info('Concluding conversation', {
+        event: 'call_monitor_end_conversation',
+        conversationId,
+        traceId: convData?.callerInfo?.trace_id || convData?.callerInfo?.traceId,
+        data: {
+          reason
+        }
+      });
+      const result = await this.convStore.concludeConversation(conversationId, {
+        summarizer: this.summarizer,
+        ownerContext: this.ownerContext
+      });
+      
+      if (result.success) {
+        // Notify owner
+        const context = this.convStore.getConversationContext(conversationId);
+        this.notifyOwner({
+          type: 'conversation_concluded',
+          reason,
+          conversation: context,
+          callerInfo: convData?.callerInfo
+        }).catch(err => {
+          this.logger.error('Failed to notify owner after conversation conclusion', {
+            event: 'call_monitor_owner_notify_failed',
+            conversationId,
+            traceId: convData?.callerInfo?.trace_id || convData?.callerInfo?.traceId,
+            error_code: 'CALL_MONITOR_OWNER_NOTIFY_FAILED',
+            hint: 'Check notification runtime and owner notification handler reliability.',
+            error: err,
+            data: {
+              reason
+            }
+          });
+        });
+      }
+      
+      return result;
+    } catch (err) {
+      this.logger.error('Failed to conclude conversation', {
+        event: 'call_monitor_conclude_failed',
+        conversationId,
+        traceId: convData?.callerInfo?.trace_id || convData?.callerInfo?.traceId,
+        error_code: 'CALL_MONITOR_CONCLUDE_FAILED',
+        hint: 'Check conversation store write access and summarizer function stability.',
+        error: err,
+        data: {
+          reason
+        }
+      });
+      return { success: false, error: err.message };
+    }
+  }
+
+  /**
+   * Check for idle conversations
+   */
+  async _checkIdleConversations() {
+    const now = Date.now();
+    
+    for (const [convId, data] of this.activeConversations) {
+      const idleTime = now - data.lastActivity;
+      const duration = now - data.startTime;
+      
+      // Check max duration
+      if (duration > this.maxDurationMs) {
+        this.logger.info('Conversation exceeded max duration; concluding', {
+          event: 'call_monitor_max_duration',
+          conversationId: convId,
+          traceId: data?.callerInfo?.trace_id || data?.callerInfo?.traceId,
+          data: {
+            duration_ms: duration,
+            max_duration_ms: this.maxDurationMs
+          }
+        });
+        await this.endConversation(convId, 'max_duration');
+        continue;
+      }
+      
+      // Check idle timeout
+      if (idleTime > this.idleTimeoutMs) {
+        this.logger.info('Conversation idle timeout reached; concluding', {
+          event: 'call_monitor_idle_timeout',
+          conversationId: convId,
+          traceId: data?.callerInfo?.trace_id || data?.callerInfo?.traceId,
+          data: {
+            idle_ms: idleTime,
+            idle_timeout_ms: this.idleTimeoutMs
+          }
+        });
+        await this.endConversation(convId, 'idle_timeout');
+      }
+    }
+  }
+
+  /**
+   * Get active conversation count
+   */
+  getActiveCount() {
+    return this.activeConversations.size;
+  }
+
+  /**
+   * Get all active conversation IDs
+   */
+  getActiveConversations() {
+    return Array.from(this.activeConversations.keys());
+  }
+}
+
+module.exports = { CallMonitor };