a2acalling 0.6.49 → 0.6.51

package/src/lib/claude-subagent.js

@@ -9,6 +9,7 @@
 
 const { execSync, spawn } = require('child_process');
 const { createLogger } = require('./logger');
+const { HARD_FALLBACK_TURN_TIMEOUT_MS } = require('./turn-timeout');
 
 const logger = createLogger({ component: 'a2a.claude-subagent' });
 
@@ -216,7 +217,7 @@ function parseSubagentResponse(resultText) {
  * @param {number} timeoutMs - Timeout in milliseconds
  * @returns {Promise<{ stdout: string, stderr: string }>}
  */
-function spawnClaude(args, timeoutMs = 180000) {
+function spawnClaude(args, timeoutMs = HARD_FALLBACK_TURN_TIMEOUT_MS) {
   return new Promise((resolve, reject) => {
     const proc = spawn('claude', args, {
       stdio: ['pipe', 'pipe', 'pipe'],
@@ -302,7 +303,7 @@ function extractResultFromJson(stdout) {
  * @param {Array} options.activeThreads - Active conversation threads
  * @param {Array} options.candidateCollaborations - Candidate collaboration ideas
  * @param {boolean} options.closeSignal - Whether close has been signaled
- * @param {number} [options.timeoutMs=180000] - Timeout in milliseconds
+ * @param {number} [options.timeoutMs=300000] - Timeout in milliseconds
  * @returns {Promise<{ message: string, statePatch: object|null, flags: array, sessionId: string }>}
  */
 async function runClaudeTurn(options) {
@@ -317,7 +318,7 @@ async function runClaudeTurn(options) {
     activeThreads = [],
     candidateCollaborations = [],
     closeSignal = false,
-    timeoutMs = 180000
+    timeoutMs = HARD_FALLBACK_TURN_TIMEOUT_MS
   } = options;
 
   const turnPrompt = buildTurnPrompt({
@@ -396,10 +397,10 @@ async function runClaudeTurn(options) {
  *
  * @param {string} sessionId - Session ID to resume
  * @param {string} reason - Why the conversation is ending
- * @param {number} [timeoutMs=120000] - Timeout in milliseconds
+ * @param {number} [timeoutMs=300000] - Timeout in milliseconds
  * @returns {Promise<{ summary: string, ownerSummary: string, actionItems: array, flags: array }>}
  */
-async function runClaudeSummary(sessionId, reason, timeoutMs = 120000) {
+async function runClaudeSummary(sessionId, reason, timeoutMs = HARD_FALLBACK_TURN_TIMEOUT_MS) {
   if (!sessionId) {
     throw new Error('Cannot summarize without a session ID');
   }

package/src/lib/config.js

@@ -224,6 +224,7 @@ const DEFAULT_CONFIG = {
       perHour: 100,
       perDay: 1000
     },
+    turnTimeoutMs: 300000,      // default Claude turn timeout
     maxPendingRequests: 5       // max connection requests per hour
   },
   

package/src/lib/conversation-driver.js

@@ -22,6 +22,7 @@ const {
 const { getTopicsForTier, formatTopicsForPrompt, loadManifest } = require('./disclosure');
 const { createLogger } = require('./logger');
 const { buildUnifiedSummaryPrompt } = require('./summary-prompt');
+const { resolveTokenTimeoutMs, resolveTurnTimeoutMs } = require('./turn-timeout');
 
 const logger = createLogger({ component: 'a2a.conversation-driver' });
 
@@ -130,9 +131,16 @@ class ConversationDriver {
     this.summarizer = options.summarizer || null;
     this.ownerContext = options.ownerContext || {};
     this.claudeMode = options.runtime?.mode === 'claude';
-    this.claudeTimeoutMs = options.claudeTimeoutMs || 180000;
 
-    const clientTimeout = this.claudeMode ? 200000 : 65000;
+    const tokenTimeoutMs = options.tokenTimeoutMs
+      || options.claudeTimeoutMs
+      || resolveTokenTimeoutMs(options.token);
+    const configTimeoutMs = options.configTurnTimeoutMs;
+    this.claudeTimeoutMs = resolveTurnTimeoutMs({ tokenTimeoutMs, configTimeoutMs });
+
+    const clientTimeout = this.claudeMode
+      ? Math.max(this.claudeTimeoutMs + 20000, 200000)
+      : 65000;
     this.client = new A2AClient({ caller: this.caller, timeout: clientTimeout });
   }
 
@@ -221,7 +229,8 @@ class ConversationDriver {
             sessionId: `summary-${Date.now()}`,
             prompt,
             messages,
-            callerInfo: { name: agentContext.name, owner: agentContext.owner }
+            callerInfo: { name: agentContext.name, owner: agentContext.owner },
+            timeoutMs: this.claudeMode ? this.claudeTimeoutMs : 35000
           });
         } catch (err) {
           logger.warn('Runtime summarizer failed, using default', {

package/src/lib/conversations.js

@@ -18,9 +18,10 @@ const DB_FILENAME = 'a2a-conversations.db';
 const logger = createLogger({ component: 'a2a.conversations' });
 
 class ConversationStore {
-  constructor(configDir = DEFAULT_CONFIG_DIR) {
+  constructor(configDir = DEFAULT_CONFIG_DIR, options = {}) {
     this.configDir = configDir;
     this.dbPath = path.join(configDir, DB_FILENAME);
+    this.eventStore = options.eventStore || null;
     this.db = null;
     this._ensureDir();
   }
@@ -253,6 +254,19 @@ class ConversationStore {
       VALUES (?, ?, ?, ?, ?, ?, ?, 'active')
     `).run(id, contactId, contactName, tokenId, direction, now, now);
 
+    if (this.eventStore && this.eventStore.isAvailable && this.eventStore.isAvailable()) {
+      this.eventStore.emitEvent('call.updated', {
+        conversation_id: id,
+        status: 'active',
+        direction,
+        contact_id: contactId || null,
+        contact_name: contactName || null
+      }, {
+        conversationId: id,
+        contactId: contactId || null
+      });
+    }
+
     return { id, resumed: false };
   }
 
@@ -284,6 +298,14 @@ class ConversationStore {
       WHERE id = ?
     `).run(now, conversationId);
 
+    if (this.eventStore && this.eventStore.isAvailable && this.eventStore.isAvailable()) {
+      this.eventStore.emitEvent('call.updated', {
+        conversation_id: conversationId,
+        status: 'active',
+        direction
+      }, { conversationId });
+    }
+
     return { id, timestamp: now };
   }
 
@@ -450,6 +472,31 @@ class ConversationStore {
       `).run(now, conversationId);
     }
 
+    if (this.eventStore && this.eventStore.isAvailable && this.eventStore.isAvailable()) {
+      this.eventStore.emitEvent('call.updated', {
+        conversation_id: conversationId,
+        status: 'concluded',
+        contact_id: conversation.contact_id || null,
+        contact_name: conversation.contact_name || null
+      }, {
+        conversationId,
+        contactId: conversation.contact_id || null
+      });
+
+      if (summary || ownerSummary) {
+        this.eventStore.emitEvent('summary.completed', {
+          conversation_id: conversationId,
+          contact_id: conversation.contact_id || null,
+          contact_name: conversation.contact_name || null,
+          has_summary: Boolean(summary),
+          has_owner_summary: Boolean(ownerSummary)
+        }, {
+          conversationId,
+          contactId: conversation.contact_id || null
+        });
+      }
+    }
+
     return { 
       success: true, 
       conversationId,
@@ -472,6 +519,13 @@ class ConversationStore {
       WHERE id = ?
     `).run(now, conversationId);
 
+    if (this.eventStore && this.eventStore.isAvailable && this.eventStore.isAvailable()) {
+      this.eventStore.emitEvent('call.updated', {
+        conversation_id: conversationId,
+        status: 'timeout'
+      }, { conversationId });
+    }
+
     return { success: true };
   }
 

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

@@ -14,6 +14,7 @@ const { execSync, spawnSync } = require('child_process');
 const { createLogger } = require('./logger');
 const { runClaudeTurn: invokeClaudeTurn, buildSubagentSystemPrompt, runClaudeSummary } = require('./claude-subagent');
 const { getTopicsForTier, formatTopicsForPrompt, loadManifest } = require('./disclosure');
+const { HARD_FALLBACK_TURN_TIMEOUT_MS } = require('./turn-timeout');
 
 function commandExists(command) {
   try {
@@ -208,7 +209,7 @@ function createRuntimeAdapter(options = {}) {
       activeThreads: context?.activeThreads || [],
       candidateCollaborations: context?.candidateCollaborations || [],
       closeSignal: context?.closeSignal || false,
-      timeoutMs: timeoutMs || 180000
+      timeoutMs: timeoutMs || HARD_FALLBACK_TURN_TIMEOUT_MS
     });
 
     // Store session ID from first turn for subsequent --resume
@@ -379,7 +380,7 @@ function createRuntimeAdapter(options = {}) {
     }
   }
 
-  async function summarize({ sessionId, prompt, messages, callerInfo, traceId, conversationId }) {
+  async function summarize({ sessionId, prompt, messages, callerInfo, traceId, conversationId, timeoutMs }) {
     const effectiveTraceId = traceId || callerInfo?.trace_id || callerInfo?.traceId;
     const requestId = callerInfo?.request_id || callerInfo?.requestId;
     const effectiveConversationId = conversationId || callerInfo?.conversation_id || callerInfo?.conversationId;
@@ -388,7 +389,11 @@ function createRuntimeAdapter(options = {}) {
     if (modeInfo.mode === 'claude') {
       const session = claudeSessions.get(sessionId);
       if (session?.claudeSessionId) {
-        const result = await runClaudeSummary(session.claudeSessionId, 'conversation ended');
+        const result = await runClaudeSummary(
+          session.claudeSessionId,
+          'conversation ended',
+          timeoutMs || HARD_FALLBACK_TURN_TIMEOUT_MS
+        );
         if (result && result.summary) {
           return result;
         }

package/src/lib/tokens.js

@@ -56,6 +56,11 @@ function sanitizeCustomFields(fields, options = {}) {
   return cleaned;
 }
 
+function parsePositiveTimeoutMs(value) {
+  const parsed = Number.parseInt(String(value ?? ''), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+
 class TokenStore {
   constructor(configDir = DEFAULT_CONFIG_DIR) {
     this.configDir = configDir;
@@ -196,7 +201,8 @@ class TokenStore {
       // Snapshot of actual capabilities at creation time
       allowedTopics = null,  // Array of topic strings, e.g. ['chat', 'calendar.read']
       allowedGoals = null,   // Array of goal strings, e.g. ['grow-network', 'find-collaborators']
-      tierSettings = null    // Object with tier-specific settings
+      tierSettings = null,   // Object with tier-specific settings
+      timeoutMs = null
     } = options;
 
     const tier = String(permissions || 'public').trim() || 'public';
@@ -255,6 +261,7 @@ class TokenStore {
       capabilities: capabilities || defaultCapabilities,
       allowed_topics: allowedTopics || defaultTopics[tier] || ['chat'],
       allowed_goals: allowedGoals || defaultGoals[tier] || [],
+      timeout_ms: parsePositiveTimeoutMs(timeoutMs),
       tier_settings: tierSettings || {},  // Snapshot of settings at creation
       disclosure,
       notify,
@@ -327,6 +334,10 @@ class TokenStore {
       || TokenStore.DEFAULT_CAPABILITIES[tier]
       || ['context-read'];
 
+    const timeoutMs = parsePositiveTimeoutMs(record.timeout_ms)
+      || parsePositiveTimeoutMs(record.tier_settings?.timeout_ms)
+      || parsePositiveTimeoutMs(record.tier_settings?.timeoutMs);
+
     return {
       valid: true,
       id: record.id,
@@ -335,6 +346,7 @@ class TokenStore {
       capabilities,
       allowed_topics: record.allowed_topics || ['chat'],
       allowed_goals: record.allowed_goals || [],
+      timeout_ms: timeoutMs,
       tier_settings: record.tier_settings || {},
       disclosure: record.disclosure,
       notify: record.notify,

package/src/lib/turn-timeout.js

@@ -0,0 +1,52 @@
+const HARD_FALLBACK_TURN_TIMEOUT_MS = 300000;
+
+function parsePositiveInt(value) {
+  const parsed = Number.parseInt(String(value ?? ''), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+
+function resolveTokenTimeoutMs(token) {
+  if (!token || typeof token !== 'object') {
+    return null;
+  }
+
+  const topLevel = parsePositiveInt(token.timeout_ms ?? token.timeoutMs);
+  if (topLevel) {
+    return topLevel;
+  }
+
+  const tierSettings = token.tier_settings || token.tierSettings;
+  if (!tierSettings || typeof tierSettings !== 'object') {
+    return null;
+  }
+  return parsePositiveInt(tierSettings.timeout_ms ?? tierSettings.timeoutMs);
+}
+
+function resolveTurnTimeoutMs(options = {}) {
+  const tokenTimeoutMs = parsePositiveInt(options.tokenTimeoutMs);
+  if (tokenTimeoutMs) {
+    return tokenTimeoutMs;
+  }
+
+  const envTimeoutMs = parsePositiveInt(
+    options.envTimeoutMs !== undefined ? options.envTimeoutMs : process.env.A2A_TURN_TIMEOUT
+  );
+  if (envTimeoutMs) {
+    return envTimeoutMs;
+  }
+
+  const configTimeoutMs = parsePositiveInt(options.configTimeoutMs);
+  if (configTimeoutMs) {
+    return configTimeoutMs;
+  }
+
+  const fallbackTimeoutMs = parsePositiveInt(options.hardFallbackMs);
+  return fallbackTimeoutMs || HARD_FALLBACK_TURN_TIMEOUT_MS;
+}
+
+module.exports = {
+  HARD_FALLBACK_TURN_TIMEOUT_MS,
+  parsePositiveInt,
+  resolveTokenTimeoutMs,
+  resolveTurnTimeoutMs
+};

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,
@@ -340,6 +347,7 @@ function createRoutes(options = {}) {
       tier: validation.tier,
       capabilities: validation.capabilities,
       allowed_topics: validation.allowed_topics,
+      timeout_ms: validation.timeout_ms,
       disclosure: validation.disclosure,
       caller: sanitizedCaller,
       conversation_id: conversation_id || `conv_${Date.now()}_${crypto.randomBytes(6).toString('hex')}`,
@@ -366,6 +374,17 @@ 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) {
@@ -562,7 +581,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' }));
     }