a2acalling 0.6.50 → 0.6.52

package/src/lib/dashboard-events.js

@@ -0,0 +1,205 @@
+const fs = require('fs');
+const path = require('path');
+const { EventEmitter } = require('events');
+
+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-events.db';
+const DEFAULT_RETENTION_COUNT = 5000;
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+class DashboardEventStore {
+  constructor(configDir = DEFAULT_CONFIG_DIR, options = {}) {
+    this.configDir = configDir;
+    this.dbPath = options.dbPath || path.join(configDir, DB_FILENAME);
+    this.retentionCount = Number.isFinite(options.retentionCount)
+      ? Math.max(100, Math.floor(options.retentionCount))
+      : DEFAULT_RETENTION_COUNT;
+    this.db = null;
+    this._dbError = null;
+    this._stmts = null;
+    this._emitter = new EventEmitter();
+    this._ensureDir();
+  }
+
+  _ensureDir() {
+    if (!fs.existsSync(this.configDir)) {
+      fs.mkdirSync(this.configDir, { recursive: true });
+    }
+  }
+
+  _initDb() {
+    if (this.db) return this.db;
+    if (this._dbError) return null;
+    try {
+      const Database = require('better-sqlite3');
+      this.db = new Database(this.dbPath);
+      try {
+        fs.chmodSync(this.dbPath, 0o600);
+      } catch (_) {
+        // Best effort.
+      }
+      this._migrate();
+      this._prepareStatements();
+      return this.db;
+    } catch (err) {
+      this._dbError = err && err.message ? err.message : 'failed_to_initialize_event_db';
+      return null;
+    }
+  }
+
+  _migrate() {
+    this.db.exec(`
+      PRAGMA journal_mode = WAL;
+
+      CREATE TABLE IF NOT EXISTS dashboard_events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        event_type TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        payload_json TEXT NOT NULL,
+        conversation_id TEXT,
+        contact_id TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_dashboard_events_created ON dashboard_events(created_at);
+      CREATE INDEX IF NOT EXISTS idx_dashboard_events_type ON dashboard_events(event_type);
+      CREATE INDEX IF NOT EXISTS idx_dashboard_events_conversation ON dashboard_events(conversation_id);
+      CREATE INDEX IF NOT EXISTS idx_dashboard_events_contact ON dashboard_events(contact_id);
+    `);
+  }
+
+  _prepareStatements() {
+    this._stmts = {
+      insertEvent: this.db.prepare(`
+        INSERT INTO dashboard_events (event_type, created_at, payload_json, conversation_id, contact_id)
+        VALUES (@event_type, @created_at, @payload_json, @conversation_id, @contact_id)
+      `),
+      listSince: this.db.prepare(`
+        SELECT id, event_type, created_at, payload_json, conversation_id, contact_id
+        FROM dashboard_events
+        WHERE id > @since_id
+        ORDER BY id ASC
+        LIMIT @limit
+      `),
+      listLatest: this.db.prepare(`
+        SELECT id, event_type, created_at, payload_json, conversation_id, contact_id
+        FROM dashboard_events
+        ORDER BY id DESC
+        LIMIT @limit
+      `),
+      prune: this.db.prepare(`
+        DELETE FROM dashboard_events
+        WHERE id NOT IN (
+          SELECT id FROM dashboard_events
+          ORDER BY id DESC
+          LIMIT @retention
+        )
+      `)
+    };
+  }
+
+  isAvailable() {
+    return Boolean(this._initDb());
+  }
+
+  getDbError() {
+    this._initDb();
+    return this._dbError;
+  }
+
+  emitEvent(eventType, payload = {}, meta = {}) {
+    const db = this._initDb();
+    if (!db) {
+      return { success: false, error: 'event_storage_unavailable', message: this._dbError };
+    }
+
+    const event_type = String(eventType || '').trim().slice(0, 80);
+    if (!event_type) {
+      return { success: false, error: 'event_type_required' };
+    }
+
+    const created_at = nowIso();
+    const row = {
+      event_type,
+      created_at,
+      payload_json: JSON.stringify(payload || {}),
+      conversation_id: meta && meta.conversationId ? String(meta.conversationId).slice(0, 120) : null,
+      contact_id: meta && meta.contactId ? String(meta.contactId).slice(0, 120) : null
+    };
+
+    const info = this._stmts.insertEvent.run(row);
+    const id = Number(info.lastInsertRowid);
+    const event = {
+      id,
+      type: event_type,
+      created_at,
+      conversation_id: row.conversation_id,
+      contact_id: row.contact_id,
+      payload: payload || {}
+    };
+
+    if (id % 100 === 0) {
+      try {
+        this._stmts.prune.run({ retention: this.retentionCount });
+      } catch (_) {
+        // Best effort.
+      }
+    }
+
+    this._emitter.emit('event', event);
+    return { success: true, event };
+  }
+
+  listSince(sinceId, options = {}) {
+    const db = this._initDb();
+    if (!db) return [];
+    const limit = Math.min(500, Math.max(1, Number.parseInt(String(options.limit || '200'), 10) || 200));
+    const parsedSince = Number.parseInt(String(sinceId || '0'), 10);
+    if (Number.isFinite(parsedSince) && parsedSince > 0) {
+      const rows = this._stmts.listSince.all({ since_id: parsedSince, limit });
+      return rows.map((row) => this._toEvent(row));
+    }
+    const rows = this._stmts.listLatest.all({ limit }).reverse();
+    return rows.map((row) => this._toEvent(row));
+  }
+
+  subscribe(listener) {
+    const safe = (event) => {
+      try {
+        listener(event);
+      } catch (_) {
+        // Keep stream robust.
+      }
+    };
+    this._emitter.on('event', safe);
+    return () => {
+      this._emitter.off('event', safe);
+    };
+  }
+
+  _toEvent(row) {
+    let payload = {};
+    try {
+      payload = row.payload_json ? JSON.parse(row.payload_json) : {};
+    } catch (_) {
+      payload = {};
+    }
+    return {
+      id: row.id,
+      type: row.event_type,
+      created_at: row.created_at,
+      conversation_id: row.conversation_id || null,
+      contact_id: row.contact_id || null,
+      payload
+    };
+  }
+}
+
+module.exports = {
+  DashboardEventStore
+};

package/src/lib/runtime-adapter.js

@@ -149,7 +149,9 @@ function createRuntimeAdapter(options = {}) {
     }
   });
 
-  // Claude subagent session tracking
+  // Claude state tracking.
+  // Design decision (A2A-29): we keep per-conversation state for prompt/metadata
+  // continuity, but Claude execution itself is stateless (no `--resume`).
   const claudeSessions = new Map();
 
   async function runClaudeTurnAdapter({ sessionId, message, caller, context, timeoutMs }) {
@@ -180,7 +182,18 @@ function createRuntimeAdapter(options = {}) {
         roleContext: context?.roleContext || ''
       });
 
-      session = { claudeSessionId: null, systemPrompt, turnCount: 0, lastMeta: null };
+      session = {
+        systemPrompt,
+        turnCount: 0,
+        lastMeta: null,
+        // Keep a permission snapshot so summary runs with the same policy envelope.
+        permissionSnapshot: {
+          capabilities: Array.isArray(context?.capabilities) ? context.capabilities : [],
+          allowedTopics: Array.isArray(context?.allowedTopics || context?.allowed_topics)
+            ? (context?.allowedTopics || context?.allowed_topics)
+            : []
+        }
+      };
       claudeSessions.set(sessionId, session);
     }
 
@@ -199,7 +212,6 @@ function createRuntimeAdapter(options = {}) {
     });
 
     const result = await invokeClaudeTurn({
-      sessionId: session.claudeSessionId,
       systemPrompt: session.systemPrompt,
       turnMessage: message,
       turn: session.turnCount,
@@ -209,12 +221,21 @@ function createRuntimeAdapter(options = {}) {
       activeThreads: context?.activeThreads || [],
       candidateCollaborations: context?.candidateCollaborations || [],
       closeSignal: context?.closeSignal || false,
+      capabilities: Array.isArray(context?.capabilities)
+        ? context.capabilities
+        : (session.permissionSnapshot?.capabilities || []),
+      allowedTopics: Array.isArray(context?.allowedTopics || context?.allowed_topics)
+        ? (context?.allowedTopics || context?.allowed_topics)
+        : (session.permissionSnapshot?.allowedTopics || []),
       timeoutMs: timeoutMs || HARD_FALLBACK_TURN_TIMEOUT_MS
     });
 
-    // Store session ID from first turn for subsequent --resume
-    if (result.sessionId) {
-      session.claudeSessionId = result.sessionId;
+    // Update permission snapshot if the caller supplied explicit context this turn.
+    if (Array.isArray(context?.capabilities)) {
+      session.permissionSnapshot.capabilities = context.capabilities;
+    }
+    if (Array.isArray(context?.allowedTopics || context?.allowed_topics)) {
+      session.permissionSnapshot.allowedTopics = context?.allowedTopics || context?.allowed_topics;
     }
 
     // Store flags/state for retrieval via getLastTurnMeta
@@ -385,20 +406,28 @@ function createRuntimeAdapter(options = {}) {
     const requestId = callerInfo?.request_id || callerInfo?.requestId;
     const effectiveConversationId = conversationId || callerInfo?.conversation_id || callerInfo?.conversationId;
 
-    // Claude mode: use the subagent session for summarization
+    // Claude mode: stateless summary invocation (no session restore dependency).
     if (modeInfo.mode === 'claude') {
       const session = claudeSessions.get(sessionId);
-      if (session?.claudeSessionId) {
-        const result = await runClaudeSummary(
-          session.claudeSessionId,
-          'conversation ended',
-          timeoutMs || HARD_FALLBACK_TURN_TIMEOUT_MS
-        );
-        if (result && result.summary) {
-          return result;
-        }
+      const capabilities = session?.permissionSnapshot?.capabilities
+        || callerInfo?.capabilities
+        || [];
+      const allowedTopics = session?.permissionSnapshot?.allowedTopics
+        || callerInfo?.allowedTopics
+        || callerInfo?.allowed_topics
+        || [];
+
+      const result = await runClaudeSummary({
+        prompt,
+        reason: 'conversation ended',
+        capabilities,
+        allowedTopics,
+        timeoutMs: timeoutMs || HARD_FALLBACK_TURN_TIMEOUT_MS
+      });
+      if (result && result.summary) {
+        return result;
       }
-      throw new Error('Claude summary session not available or returned empty result');
+      throw new Error('Claude summary returned empty result');
     }
 
     if (modeInfo.mode !== 'openclaw') {

package/src/routes/a2a.js

@@ -15,11 +15,14 @@ const { createLogger, createTraceId } = require('../lib/logger');
 // Lazy-load conversation store (optional dependency)
 let ConversationStore = null;
 let conversationStore = null;
-function getConversationStore() {
+function getConversationStore(options = {}) {
   if (!ConversationStore) {
     try {
       ConversationStore = require('../lib/conversations').ConversationStore;
-      conversationStore = new ConversationStore();
+      const configDir = options.configDir || undefined;
+      conversationStore = new ConversationStore(configDir, {
+        eventStore: options.eventStore || null
+      });
       if (!conversationStore.isAvailable()) {
         conversationStore = null;
       }
@@ -162,9 +165,13 @@ function createRoutes(options = {}) {
   const notifyOwner = options.notifyOwner || (() => Promise.resolve());
   const limits = options.rateLimits || { minute: 10, hour: 100, day: 1000 };
   const logger = options.logger || createLogger({ component: 'a2a.routes' });
+  const eventStore = options.eventStore || null;
 
   // Initialize conversation store and call monitor
-  const convStore = getConversationStore();
+  const convStore = getConversationStore({
+    eventStore,
+    configDir: tokenStore.configDir
+  });
   const monitor = getCallMonitor({
     convStore,
     summarizer: options.summarizer,
@@ -367,11 +374,25 @@ function createRoutes(options = {}) {
           tokenId: validation.id,
           direction: 'inbound'
         });
+        if (isNewConversation && eventStore && eventStore.isAvailable && eventStore.isAvailable()) {
+          eventStore.emitEvent('call.inbound', {
+            conversation_id: a2aContext.conversation_id,
+            token_id: validation.id,
+            caller_name: sanitizedCaller.name || validation.name || null,
+            caller_owner: sanitizedCaller.owner || null
+          }, {
+            conversationId: a2aContext.conversation_id,
+            contactId: ensuredContact?.id || validation.id
+          });
+        }
         
         // Track activity for auto-conclude
         if (monitor) {
           monitor.trackActivity(a2aContext.conversation_id, {
             ...sanitizedCaller,
+            tier: validation.tier,
+            capabilities: validation.capabilities,
+            allowed_topics: validation.allowed_topics,
             trace_id: traceId,
             request_id: requestId
           });
@@ -563,7 +584,10 @@ function createRoutes(options = {}) {
       }));
     }
 
-    const convStore = getConversationStore();
+    const convStore = getConversationStore({
+      eventStore,
+      configDir: tokenStore.configDir
+    });
     if (!convStore) {
       return res.json(withTracePayload({ success: true, message: 'Conversation storage not enabled' }));
     }

package/src/routes/dashboard.js

@@ -18,6 +18,7 @@ const { A2AConfig } = require('../lib/config');
 const { loadManifest, saveManifest } = require('../lib/disclosure');
 const { resolveInviteHost } = require('../lib/invite-host');
 const { CallbookStore } = require('../lib/callbook');
+const { DashboardEventStore } = require('../lib/dashboard-events');
 const { createLogger } = require('../lib/logger');
 
 const DASHBOARD_STATIC_DIR = path.join(__dirname, '..', 'dashboard', 'public');
@@ -192,11 +193,12 @@ function buildContext(options = {}) {
   const config = options.config || new A2AConfig();
   const logger = options.logger || createLogger({ component: 'a2a.dashboard' });
   const callbookStore = options.callbookStore || new CallbookStore(tokenStore.configDir);
+  const eventStore = options.eventStore || new DashboardEventStore(tokenStore.configDir);
   const agentContext = resolveAgentContext(options);
   let convStore = options.convStore || null;
   if (!convStore) {
     try {
-      convStore = new ConversationStore();
+      convStore = new ConversationStore(tokenStore.configDir, { eventStore });
       if (!convStore.isAvailable()) {
         convStore = null;
       }
@@ -210,6 +212,7 @@ function buildContext(options = {}) {
     config,
     convStore,
     callbookStore,
+    eventStore,
     getUpdateManager: typeof options.getUpdateManager === 'function'
       ? options.getUpdateManager
       : (() => null),
@@ -444,6 +447,23 @@ function createDashboardApiRouter(options = {}) {
   const context = buildContext(options);
   router.use(express.json());
   const ensureDashboardAccess = makeEnsureDashboardAccess(context);
+  const writeSseEvent = (res, event) => {
+    const eventName = sanitizeString(event?.type || 'message', 80) || 'message';
+    const eventId = Number.parseInt(String(event?.id || ''), 10);
+    const payload = {
+      id: eventId || null,
+      type: eventName,
+      created_at: event?.created_at || new Date().toISOString(),
+      conversation_id: event?.conversation_id || null,
+      contact_id: event?.contact_id || null,
+      payload: event?.payload || {}
+    };
+    if (Number.isFinite(eventId) && eventId > 0) {
+      res.write(`id: ${eventId}\n`);
+    }
+    res.write(`event: ${eventName}\n`);
+    res.write(`data: ${JSON.stringify(payload)}\n\n`);
+  };
 
   // Callbook Remote: exchange a short-lived provisioning code for a long-lived session cookie.
   // This route must be reachable BEFORE dashboard access is established.
@@ -481,6 +501,14 @@ function createDashboardApiRouter(options = {}) {
     });
     res.setHeader('Set-Cookie', cookie);
 
+    if (context.eventStore && context.eventStore.isAvailable()) {
+      context.eventStore.emitEvent('invite.used', {
+        device_id: result.device?.id || null,
+        device_label: result.device?.label || null,
+        source: 'callbook_exchange'
+      });
+    }
+
     return res.json({
       success: true,
       device: result.device,
@@ -491,6 +519,72 @@ function createDashboardApiRouter(options = {}) {
   // All other dashboard API routes require owner access.
   router.use(ensureDashboardAccess);
 
+  router.get('/events', (req, res) => {
+    if (!context.eventStore || !context.eventStore.isAvailable()) {
+      return res.status(503).json({
+        success: false,
+        error: 'event_stream_unavailable',
+        message: context.eventStore ? context.eventStore.getDbError() : 'missing_event_store'
+      });
+    }
+
+    const lastIdHeader = req.headers['last-event-id'];
+    const since = sanitizeString(
+      req.query.since || lastIdHeader || req.query.last_event_id || '',
+      32
+    );
+    const replayLimit = Math.min(500, Math.max(1, Number.parseInt(req.query.replay || '200', 10) || 200));
+
+    res.status(200);
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache, no-transform');
+    res.setHeader('Connection', 'keep-alive');
+    res.flushHeaders?.();
+
+    let lastSentId = Number.parseInt(String(since || '0'), 10);
+    if (!Number.isFinite(lastSentId) || lastSentId < 0) {
+      lastSentId = 0;
+    }
+
+    const pendingLive = [];
+    const unsubscribe = context.eventStore.subscribe((event) => {
+      if (!event || !Number.isFinite(event.id)) return;
+      if (event.id <= lastSentId) return;
+      pendingLive.push(event);
+    });
+
+    const replay = context.eventStore.listSince(since, { limit: replayLimit });
+    for (const row of replay) {
+      writeSseEvent(res, row);
+      if (Number.isFinite(row.id) && row.id > lastSentId) {
+        lastSentId = row.id;
+      }
+    }
+    while (pendingLive.length > 0) {
+      const row = pendingLive.shift();
+      if (!row || !Number.isFinite(row.id) || row.id <= lastSentId) continue;
+      writeSseEvent(res, row);
+      lastSentId = row.id;
+    }
+    res.write(': connected\n\n');
+
+    const liveUnsubscribe = context.eventStore.subscribe((event) => {
+      if (!event || !Number.isFinite(event.id) || event.id <= lastSentId) return;
+      writeSseEvent(res, event);
+      lastSentId = event.id;
+    });
+    const heartbeat = setInterval(() => {
+      res.write(`: heartbeat ${Date.now()}\n\n`);
+    }, 15000);
+
+    req.on('close', () => {
+      clearInterval(heartbeat);
+      unsubscribe();
+      liveUnsubscribe();
+      res.end();
+    });
+  });
+
   router.get('/status', async (req, res) => {
     context.logger.debug('Dashboard status requested', { event: 'dashboard_status' });
     const refreshIp = String(req.query.refresh_ip || 'false') === 'true';
@@ -1028,7 +1122,16 @@ function createDashboardApiRouter(options = {}) {
     const url = `a2a://${contact.host}/${contact.token}`;
     try {
       const result = await client.call(url, message, { conversationId, timeoutSeconds });
+      const previousStatus = String(contact.status || '');
       context.tokenStore.updateContactStatus(contact.id, 'online');
+      if (context.eventStore && context.eventStore.isAvailable() && previousStatus !== 'online') {
+        context.eventStore.emitEvent('contact.status.changed', {
+          contact_id: contact.id,
+          contact_name: contact.name || contact.host || null,
+          previous_status: previousStatus || null,
+          status: 'online'
+        }, { contactId: contact.id });
+      }
 
       if (context.convStore) {
         try {
@@ -1053,7 +1156,17 @@ function createDashboardApiRouter(options = {}) {
         can_continue: result?.can_continue !== false
       });
     } catch (err) {
+      const previousStatus = String(contact.status || '');
       context.tokenStore.updateContactStatus(contact.id, 'offline', err.message);
+      if (context.eventStore && context.eventStore.isAvailable() && previousStatus !== 'offline') {
+        context.eventStore.emitEvent('contact.status.changed', {
+          contact_id: contact.id,
+          contact_name: contact.name || contact.host || null,
+          previous_status: previousStatus || null,
+          status: 'offline',
+          reason: err.message || null
+        }, { contactId: contact.id });
+      }
       return res.status(502).json({
         success: false,
         error: 'contact_call_failed',

package/src/server.js

@@ -26,6 +26,7 @@ const { writePidFile, removePidFile } = require('./lib/pid-file');
 const { buildUnifiedSummaryPrompt } = require('./lib/summary-prompt');
 const { A2AConfig } = require('./lib/config');
 const { UpdateManager } = require('./lib/update-manager');
+const { DashboardEventStore } = require('./lib/dashboard-events');
 const { spawn } = require('child_process');
 const { resolveTurnTimeoutMs } = require('./lib/turn-timeout');
 
@@ -67,6 +68,7 @@ function loadAgentContext() {
 const agentContext = loadAgentContext();
 const tokenStore = new TokenStore();
 const config = new A2AConfig();
+const eventStore = new DashboardEventStore(tokenStore.configDir);
 const runtime = createRuntimeAdapter({
   workspaceDir,
   agentContext,
@@ -619,7 +621,9 @@ async function callAgent(message, a2aContext) {
           conversationId,
           tier: tierInfo,
           ownerName: agentContext.owner,
+          capabilities: Array.isArray(a2aContext.capabilities) ? a2aContext.capabilities : [],
           allowedTopics: a2aContext.allowed_topics || [],
+          allowed_topics: a2aContext.allowed_topics || [],
           timeoutMs: runtime.mode === 'claude' ? claudeTurnTimeoutMs : 65000,
           traceId,
           requestId
@@ -833,6 +837,7 @@ app.use('/api/a2a/dashboard', createDashboardApiRouter({
   tokenStore,
   agentContext,
   config,
+  eventStore,
   getUpdateManager: () => updateManager,
   logger: logger.child({ component: 'a2a.dashboard' })
 }));
@@ -858,6 +863,7 @@ app.use('/callbook', createCallbookRouter());
 
 app.use('/api/a2a', createRoutes({
   tokenStore,
+  eventStore,
   logger: logger.child({ component: 'a2a.routes' }),
   onCallMonitor: (monitor) => {
     activeCallMonitor = monitor;