a2acalling 0.6.32 → 0.6.34

package/bin/cli.js

@@ -1084,6 +1084,9 @@ a2a add "${inviteUrl}" "${ownerText || 'friend'}" && a2a call "${ownerText || 'f
 
     if (!target || !message) {
       console.error('Usage: a2a call <contact_or_url> <message>');
+      console.error('  --multi         Enable multi-turn conversation');
+      console.error('  --min-turns N   Minimum turns before close (default: 8)');
+      console.error('  --max-turns N   Maximum turns (default: 25)');
       process.exit(1);
     }
 
@@ -1098,19 +1101,114 @@ a2a add "${inviteUrl}" "${ownerText || 'friend'}" && a2a call "${ownerText || 'f
       }
     }
 
+    const multi = Boolean(args.flags.multi);
+    const callerName = args.flags.name || 'CLI User';
+
+    if (multi) {
+      // Multi-turn conversation via ConversationDriver
+      const { ConversationDriver } = require('../src/lib/conversation-driver');
+      const { createRuntimeAdapter } = require('../src/lib/runtime-adapter');
+      const { loadManifest } = require('../src/lib/disclosure');
+
+      const workspaceDir = process.env.A2A_WORKSPACE || process.env.OPENCLAW_WORKSPACE || process.cwd();
+      const agentContext = {
+        name: process.env.A2A_AGENT_NAME || process.env.AGENT_NAME || 'a2a-agent',
+        owner: process.env.A2A_OWNER_NAME || process.env.USER || 'Agent Owner'
+      };
+
+      const runtime = createRuntimeAdapter({ workspaceDir, agentContext });
+      const cs = getConvStore();
+      const disclosure = loadManifest();
+
+      const minTurns = parseInt(args.flags['min-turns']) || 8;
+      const maxTurns = parseInt(args.flags['max-turns']) || 25;
+
+      const driver = new ConversationDriver({
+        runtime,
+        agentContext,
+        caller: { name: callerName },
+        endpoint: url,
+        convStore: cs,
+        disclosure,
+        minTurns,
+        maxTurns,
+        onTurn: (info) => {
+          const preview = info.messagePreview.length >= 80
+            ? info.messagePreview + '...'
+            : info.messagePreview;
+          console.log(`  Turn ${info.turn} | ${info.phase} | overlap: ${info.overlapScore.toFixed(2)} | ${preview}`);
+        }
+      });
+
+      console.log(`📞 Starting multi-turn conversation with ${contactName || url}...`);
+      console.log(`  Min turns: ${minTurns} | Max turns: ${maxTurns}\n`);
+
+      try {
+        const result = await driver.run(message);
+
+        if (contactName) {
+          store.updateContactStatus(contactName, 'online');
+        }
+
+        console.log(`\n✅ Conversation complete`);
+        console.log(`  Turns: ${result.turnCount}`);
+        console.log(`  Phase: ${result.collabState.phase}`);
+        console.log(`  Overlap: ${result.collabState.overlapScore.toFixed(2)}`);
+        if (result.collabState.candidateCollaborations.length > 0) {
+          console.log(`  Collaborations: ${result.collabState.candidateCollaborations.join(', ')}`);
+        }
+        console.log(`  Conversation ID: ${result.conversationId}`);
+      } catch (err) {
+        if (contactName) {
+          store.updateContactStatus(contactName, 'offline', err.message);
+        }
+        console.error(`❌ Multi-turn call failed: ${err.message}`);
+        process.exit(1);
+      }
+      return;
+    }
+
+    // Single-shot call (existing behavior)
     const client = new A2AClient({
-      caller: { name: args.flags.name || 'CLI User' }
+      caller: { name: callerName }
     });
 
     try {
       console.log(`📞 Calling ${contactName || url}...`);
       const response = await client.call(url, message);
-      
+
       // Update contact status on success
       if (contactName) {
         store.updateContactStatus(contactName, 'online');
       }
-      
+
+      // Persist conversation locally
+      const cs = getConvStore();
+      if (cs && response.conversation_id) {
+        try {
+          cs.startConversation({
+            id: response.conversation_id,
+            contactId: contactName || null,
+            contactName: contactName || null,
+            direction: 'outbound'
+          });
+          cs.addMessage(response.conversation_id, {
+            direction: 'outbound',
+            role: 'user',
+            content: message
+          });
+          if (response.response) {
+            cs.addMessage(response.conversation_id, {
+              direction: 'inbound',
+              role: 'assistant',
+              content: response.response
+            });
+          }
+        } catch (err) {
+          // Best effort — don't fail the call if persistence fails
+        }
+      }
+
       console.log(`\n✅ Response:\n`);
       console.log(response.response);
       if (response.conversation_id) {
@@ -1942,6 +2040,9 @@ Conversations:
 
 Calling:
   call <contact|url> <msg>  Call a contact (or invite URL)
+    --multi           Enable multi-turn conversation
+    --min-turns N     Minimum turns before close (default: 8)
+    --max-turns N     Maximum turns (default: 25)
   ping <url>          Check if agent is reachable
   status <url>        Get A2A status
   gui                 Open the local dashboard GUI in a browser

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "a2acalling",
-  "version": "0.6.32",
+  "version": "0.6.34",
   "description": "Agent-to-agent calling for OpenClaw - A2A agent communication",
   "main": "src/index.js",
   "bin": {

package/src/lib/client.js

@@ -42,9 +42,9 @@ function resolveProtocolAndPort(host) {
     hostname === '::1' ||
     hostname.startsWith('127.');
 
-  const port = hasExplicitPort ? parsed.port : (isLocalhost ? 80 : 443);
+  const port = hasExplicitPort ? parsed.port : 80;
   // Use HTTP for localhost or explicit non-443 ports, HTTPS otherwise.
-  const useHttp = isLocalhost || (hasExplicitPort && port !== 443);
+  const useHttp = isLocalhost || port === 80 || (hasExplicitPort && port !== 443);
   const protocol = useHttp ? http : https;
 
   return { protocol, hostname, port };

package/src/lib/conversation-driver.js

@@ -0,0 +1,274 @@
+/**
+ * Conversation Driver — Outbound multi-turn orchestrator
+ *
+ * Drives a full multi-turn A2A conversation with a remote agent:
+ *   1. Send message to remote via A2AClient.call()
+ *   2. Store messages in DB
+ *   3. Check close conditions
+ *   4. Build prompt via buildAdaptiveConnectionPrompt()
+ *   5. Call runtime.runTurn() to generate next message
+ *   6. Extract collab state from response
+ *   7. Persist collab state to DB
+ *   8. Repeat until close conditions met
+ *   9. Call A2AClient.end() and conclude locally
+ */
+
+const { A2AClient } = require('./client');
+const {
+  buildAdaptiveConnectionPrompt,
+  extractCollaborationState
+} = require('./prompt-template');
+const { getTopicsForTier, formatTopicsForPrompt, loadManifest } = require('./disclosure');
+const { createLogger } = require('./logger');
+
+const logger = createLogger({ component: 'a2a.conversation-driver' });
+
+class ConversationDriver {
+  /**
+   * @param {object} options
+   * @param {object} options.runtime - Runtime adapter with runTurn()
+   * @param {object} options.agentContext - { name, owner }
+   * @param {object} options.caller - Caller identity { name, owner, instance }
+   * @param {string|object} options.endpoint - a2a:// URL or {host, token}
+   * @param {object} [options.convStore] - ConversationStore instance
+   * @param {object} [options.disclosure] - Disclosure manifest override
+   * @param {number} [options.minTurns=8] - Minimum turns before close
+   * @param {number} [options.maxTurns=30] - Maximum turns
+   * @param {function} [options.onTurn] - Callback per turn: (turnInfo) => void
+   * @param {string} [options.tier='public'] - Access tier
+   */
+  constructor(options) {
+    this.runtime = options.runtime;
+    this.agentContext = options.agentContext;
+    this.caller = options.caller || {};
+    this.endpoint = options.endpoint;
+    this.convStore = options.convStore || null;
+    this.disclosure = options.disclosure || null;
+    this.minTurns = options.minTurns || 8;
+    this.maxTurns = options.maxTurns || 30;
+    this.onTurn = options.onTurn || null;
+    this.tier = options.tier || 'public';
+
+    this.client = new A2AClient({ caller: this.caller, timeout: 65000 });
+  }
+
+  /**
+   * Run the full multi-turn conversation
+   *
+   * @param {string} openingMessage - First message to send
+   * @returns {Promise<{conversationId, turnCount, collabState, transcript}>}
+   */
+  async run(openingMessage) {
+    const transcript = [];
+    let conversationId = null;
+
+    const collabState = {
+      phase: 'handshake',
+      turnCount: 0,
+      overlapScore: 0.15,
+      activeThreads: [],
+      candidateCollaborations: [],
+      openQuestions: [],
+      closeSignal: false,
+      confidence: 0.25
+    };
+
+    // Start conversation in DB if available
+    if (this.convStore) {
+      const convResult = this.convStore.startConversation({ direction: 'outbound' });
+      conversationId = convResult.id;
+    } else {
+      conversationId = `conv_${Date.now()}_local`;
+    }
+
+    let nextMessage = openingMessage;
+
+    for (let turn = 0; turn < this.maxTurns; turn++) {
+      // 1. Send message to remote
+      let remoteResponse;
+      try {
+        remoteResponse = await this.client.call(this.endpoint, nextMessage, {
+          conversationId
+        });
+      } catch (err) {
+        logger.error('Remote call failed', {
+          event: 'driver_remote_call_failed',
+          error: err,
+          data: { turn, conversationId }
+        });
+        break;
+      }
+
+      // Update conversation ID from remote if first turn
+      if (turn === 0 && remoteResponse.conversation_id) {
+        conversationId = remoteResponse.conversation_id;
+      }
+
+      const remoteText = remoteResponse.response || '';
+      const remoteContinue = remoteResponse.can_continue !== false;
+
+      // 2. Store messages in DB
+      if (this.convStore) {
+        this.convStore.addMessage(conversationId, {
+          direction: 'outbound',
+          role: 'user',
+          content: nextMessage
+        });
+        this.convStore.addMessage(conversationId, {
+          direction: 'inbound',
+          role: 'assistant',
+          content: remoteText
+        });
+      }
+
+      transcript.push(
+        { role: 'outbound', content: nextMessage },
+        { role: 'inbound', content: remoteText }
+      );
+
+      collabState.turnCount = turn + 1;
+
+      // 3. Check close conditions
+      if (!remoteContinue) {
+        logger.info('Remote signaled conversation end', {
+          event: 'driver_remote_close',
+          data: { turn: turn + 1, conversationId }
+        });
+        break;
+      }
+
+      if (collabState.closeSignal && collabState.turnCount >= this.minTurns) {
+        logger.info('Local close signal met minimum turns', {
+          event: 'driver_local_close',
+          data: { turn: turn + 1, conversationId }
+        });
+        break;
+      }
+
+      // Don't generate a reply on the last possible turn
+      if (turn + 1 >= this.maxTurns) {
+        break;
+      }
+
+      // 4. Build prompt for our turn
+      const manifest = this.disclosure || loadManifest();
+      const tierTopics = getTopicsForTier(this.tier);
+      const formattedTopics = formatTopicsForPrompt(tierTopics);
+
+      const prompt = buildAdaptiveConnectionPrompt({
+        agentName: this.agentContext.name,
+        ownerName: this.agentContext.owner,
+        otherAgentName: this.caller.name || 'Remote Agent',
+        otherOwnerName: this.caller.owner || 'their owner',
+        roleContext: 'You initiated this call.',
+        accessTier: this.tier,
+        tierTopics: formattedTopics,
+        tierGoals: [],
+        otherAgentGreeting: remoteText,
+        personalityNotes: manifest.personality_notes || '',
+        conversationState: collabState
+      });
+
+      // 5. Call runtime.runTurn() to generate next message
+      const sessionId = `a2a-${conversationId}`;
+      let rawResponse;
+      try {
+        rawResponse = await this.runtime.runTurn({
+          sessionId,
+          prompt,
+          message: remoteText,
+          caller: this.caller,
+          timeoutMs: 65000,
+          context: {
+            conversationId,
+            tier: this.tier,
+            ownerName: this.agentContext.owner
+          }
+        });
+      } catch (err) {
+        logger.error('Runtime turn failed', {
+          event: 'driver_runtime_failed',
+          error: err,
+          data: { turn: turn + 1, conversationId }
+        });
+        break;
+      }
+
+      // 6. Extract collab state from response
+      const parsed = extractCollaborationState(rawResponse);
+      nextMessage = parsed.cleanText || rawResponse;
+
+      if (parsed.hasState && parsed.statePatch) {
+        if (parsed.statePatch.phase) collabState.phase = parsed.statePatch.phase;
+        if (parsed.statePatch.overlapScore != null) {
+          collabState.overlapScore = Math.max(0, Math.min(1, parsed.statePatch.overlapScore));
+        }
+        if (Array.isArray(parsed.statePatch.activeThreads)) {
+          collabState.activeThreads = parsed.statePatch.activeThreads.slice(0, 4);
+        }
+        if (Array.isArray(parsed.statePatch.candidateCollaborations)) {
+          collabState.candidateCollaborations = parsed.statePatch.candidateCollaborations.slice(0, 4);
+        }
+        if (parsed.statePatch.closeSignal != null) {
+          collabState.closeSignal = Boolean(parsed.statePatch.closeSignal);
+        }
+        if (parsed.statePatch.confidence != null) {
+          collabState.confidence = Math.max(0, Math.min(1, parsed.statePatch.confidence));
+        }
+      }
+
+      // 7. Persist collab state to DB
+      if (this.convStore) {
+        try {
+          this.convStore.saveCollabState(conversationId, collabState);
+        } catch (err) {
+          // Best effort
+        }
+      }
+
+      // onTurn callback for progress output
+      if (this.onTurn) {
+        try {
+          this.onTurn({
+            turn: turn + 1,
+            phase: collabState.phase,
+            overlapScore: collabState.overlapScore,
+            closeSignal: collabState.closeSignal,
+            messagePreview: nextMessage.slice(0, 80)
+          });
+        } catch (err) {
+          // Don't let callback errors break the loop
+        }
+      }
+    }
+
+    // 9. End conversation remotely
+    try {
+      await this.client.end(this.endpoint, conversationId);
+    } catch (err) {
+      logger.warn('Failed to end remote conversation', {
+        event: 'driver_end_failed',
+        error: err,
+        data: { conversationId }
+      });
+    }
+
+    // Conclude locally
+    if (this.convStore) {
+      try {
+        await this.convStore.concludeConversation(conversationId);
+      } catch (err) {
+        // Best effort
+      }
+    }
+
+    return {
+      conversationId,
+      turnCount: collabState.turnCount,
+      collabState,
+      transcript
+    };
+  }
+}
+
+module.exports = { ConversationDriver };

package/src/lib/conversations.js

@@ -92,6 +92,17 @@ class ConversationStore {
         message_count INTEGER DEFAULT 0,
         status TEXT DEFAULT 'active', -- 'active', 'concluded', 'timeout'
         
+        -- Live collaboration state
+        collab_phase TEXT DEFAULT 'handshake',
+        collab_turn_count INTEGER DEFAULT 0,
+        collab_overlap_score REAL DEFAULT 0.15,
+        collab_active_threads TEXT,
+        collab_candidate_collaborations TEXT,
+        collab_open_questions TEXT,
+        collab_close_signal INTEGER DEFAULT 0,
+        collab_confidence REAL DEFAULT 0.25,
+        collab_updated_at TEXT,
+
         -- Raw summary (neutral, could be shared)
         summary TEXT,
         summary_at TEXT,
@@ -140,7 +151,8 @@ class ConversationStore {
       const cols = new Set(info.map(row => row && row.name).filter(Boolean));
       const required = [
         'joint_action_items',
-        'collaboration_opportunity'
+        'collaboration_opportunity',
+        'collab_phase'
       ];
       const missing = required.filter(c => !cols.has(c));
       if (missing.length === 0) {
@@ -547,6 +559,76 @@ class ConversationStore {
     };
   }
 
+  /**
+   * Save live collaboration state for a conversation
+   */
+  saveCollabState(conversationId, collabState) {
+    const db = this._initDb();
+    if (!db) return { success: false, error: this._dbError };
+    if (!collabState || typeof collabState !== 'object') {
+      return { success: false, error: 'invalid_state' };
+    }
+
+    const now = new Date().toISOString();
+    db.prepare(`
+      UPDATE conversations SET
+        collab_phase = ?,
+        collab_turn_count = ?,
+        collab_overlap_score = ?,
+        collab_active_threads = ?,
+        collab_candidate_collaborations = ?,
+        collab_open_questions = ?,
+        collab_close_signal = ?,
+        collab_confidence = ?,
+        collab_updated_at = ?
+      WHERE id = ?
+    `).run(
+      collabState.phase || 'handshake',
+      collabState.turnCount || 0,
+      collabState.overlapScore != null ? collabState.overlapScore : 0.15,
+      collabState.activeThreads ? JSON.stringify(collabState.activeThreads) : null,
+      collabState.candidateCollaborations ? JSON.stringify(collabState.candidateCollaborations) : null,
+      collabState.openQuestions ? JSON.stringify(collabState.openQuestions) : null,
+      collabState.closeSignal ? 1 : 0,
+      collabState.confidence != null ? collabState.confidence : 0.25,
+      now,
+      conversationId
+    );
+
+    return { success: true };
+  }
+
+  /**
+   * Load live collaboration state for a conversation
+   */
+  loadCollabState(conversationId) {
+    const db = this._initDb();
+    if (!db) return null;
+
+    const row = db.prepare(
+      'SELECT collab_phase, collab_turn_count, collab_overlap_score, collab_active_threads, collab_candidate_collaborations, collab_open_questions, collab_close_signal, collab_confidence, collab_updated_at FROM conversations WHERE id = ?'
+    ).get(conversationId);
+
+    if (!row || row.collab_phase == null) return null;
+
+    const parseJson = (str) => {
+      if (!str) return [];
+      try { return JSON.parse(str); } catch { return []; }
+    };
+
+    return {
+      phase: row.collab_phase,
+      turnCount: row.collab_turn_count || 0,
+      overlapScore: row.collab_overlap_score != null ? row.collab_overlap_score : 0.15,
+      activeThreads: parseJson(row.collab_active_threads),
+      candidateCollaborations: parseJson(row.collab_candidate_collaborations),
+      openQuestions: parseJson(row.collab_open_questions),
+      closeSignal: Boolean(row.collab_close_signal),
+      confidence: row.collab_confidence != null ? row.collab_confidence : 0.25,
+      updatedAt: row.collab_updated_at
+    };
+  }
+
   /**
    * Close database connection
    */

package/src/routes/a2a.js

@@ -452,7 +452,7 @@ function createRoutes(options = {}) {
         }
       });
 
-      res.json({
+      const responsePayload = {
         success: true,
         trace_id: traceId,
         request_id: requestId,
@@ -460,7 +460,13 @@ function createRoutes(options = {}) {
         response: response.text,
         can_continue: response.canContinue !== false,
         tokens_remaining: validation.calls_remaining
-      });
+      };
+
+      if (response.collaboration) {
+        responsePayload.collaboration = response.collaboration;
+      }
+
+      res.json(responsePayload);
 
     } catch (err) {
       reqLogger.error('Message handling error', {

package/src/server.js

@@ -65,6 +65,27 @@ const runtime = createRuntimeAdapter({
   agentContext,
   logger: logger.child({ component: 'a2a.runtime' })
 });
+// Lazy-load conversation store for collab state persistence
+let ConversationStore = null;
+let serverConvStore = null;
+function getServerConvStore() {
+  if (serverConvStore === false) return null;
+  if (!serverConvStore) {
+    try {
+      ConversationStore = require('./lib/conversations').ConversationStore;
+      serverConvStore = new ConversationStore();
+      if (!serverConvStore.isAvailable()) {
+        serverConvStore = false;
+        return null;
+      }
+    } catch (err) {
+      serverConvStore = false;
+      return null;
+    }
+  }
+  return serverConvStore;
+}
+
 const VALID_PHASES = new Set(['handshake', 'explore', 'deep_dive', 'synthesize', 'close']);
 const collaborationSessions = new Map();
 const COLLAB_STATE_TTL_MS = readPositiveIntEnv('A2A_COLLAB_STATE_TTL_MS', 6 * 60 * 60 * 1000);
@@ -249,6 +270,33 @@ function getOrCreateCollaborationState(conversationId, context = {}) {
     return existing;
   }
 
+  // Check DB for persisted state (enables restart recovery)
+  const convStore = getServerConvStore();
+  if (convStore) {
+    const dbState = convStore.loadCollabState(conversationId);
+    if (dbState) {
+      const now = Date.now();
+      const restored = {
+        conversationId,
+        phase: dbState.phase,
+        turnCount: dbState.turnCount,
+        overlapScore: dbState.overlapScore,
+        activeThreads: dbState.activeThreads,
+        candidateCollaborations: dbState.candidateCollaborations,
+        openQuestions: dbState.openQuestions,
+        closeSignal: dbState.closeSignal,
+        confidence: dbState.confidence,
+        callerName: cleanText(context.callerName, 80),
+        callerOwner: cleanText(context.callerOwner, 80),
+        tier: context.tier || 'public',
+        createdAt: now,
+        updatedAt: now
+      };
+      collaborationSessions.set(conversationId, restored);
+      return restored;
+    }
+  }
+
   const now = Date.now();
   const state = {
     conversationId,
@@ -600,6 +648,19 @@ async function callAgent(message, a2aContext) {
     collabState.updatedAt = Date.now();
     collaborationSessions.set(conversationId, collabState);
 
+    // Write-through to DB for restart recovery
+    const convStoreForPersist = getServerConvStore();
+    if (convStoreForPersist) {
+      try {
+        convStoreForPersist.saveCollabState(conversationId, collabState);
+      } catch (err) {
+        callLogger.warn('Failed to persist collab state to DB', {
+          event: 'collab_state_persist_failed',
+          error: err
+        });
+      }
+    }
+
     callLogger.info('Call turn completed', {
       event: 'call_turn_complete',
       data: {
@@ -747,9 +808,10 @@ app.use('/api/a2a', createRoutes({
   
   async handleMessage(message, context, options) {
     const traceId = context.trace_id || null;
+    const conversationId = context.conversation_id;
     const requestLogger = logger.child({
       traceId,
-      conversationId: context.conversation_id,
+      conversationId,
       tokenId: context.token_id
     });
     requestLogger.info('Inbound message accepted for handling', {
@@ -758,17 +820,38 @@ app.use('/api/a2a', createRoutes({
         caller_name: context.caller?.name || 'unknown'
       }
     });
-    
+
     const response = await callAgent(message, context);
-    
+
+    // Check close conditions from collab state
+    const collabState = collaborationSessions.get(conversationId);
+    let canContinue = true;
+    let collaboration = null;
+
+    if (collabState) {
+      collaboration = {
+        phase: collabState.phase,
+        turnCount: collabState.turnCount,
+        overlapScore: collabState.overlapScore,
+        activeThreads: collabState.activeThreads,
+        candidateCollaborations: collabState.candidateCollaborations,
+        closeSignal: collabState.closeSignal
+      };
+
+      if (collabState.closeSignal && collabState.turnCount >= 8) {
+        canContinue = false;
+      }
+    }
+
     requestLogger.info('Outbound response generated', {
       event: 'handle_message_complete',
       data: {
-        response_length: String(response || '').length
+        response_length: String(response || '').length,
+        can_continue: canContinue
       }
     });
-    
-    return { text: response, canContinue: true };
+
+    return { text: response, canContinue, collaboration };
   },
   
   summarizer: generateSummary,