a2acalling 0.6.48 → 0.6.50

package/src/lib/summary-formatter.js

@@ -0,0 +1,168 @@
+/**
+ * Summary Formatter
+ *
+ * Renders the structured JSON summary into a human-readable markdown
+ * format. Designed to be scannable, upbeat, and genuinely useful.
+ *
+ * Layout: most important info at the top, details below.
+ *
+ *   1. Headline (one sentence — the takeaway)
+ *   2. Quick Take (3 bullets — what happened, what to do)
+ *   3. Collaboration score + rating
+ *   4. Next Steps (actionable checklist)
+ *   5. --- separator ---
+ *   6. Details: who, exchange, disclosure, objectives, trust
+ */
+
+const VIBE_LABELS = {
+  productive: 'Productive call',
+  exploratory: 'Exploratory — still feeling things out',
+  mismatch: 'Friendly but not much overlap',
+  guarded: 'Guarded — worth reviewing',
+  breakthrough: 'Great connection — real momentum'
+};
+
+/**
+ * Render a structured summary JSON object into human-readable markdown.
+ *
+ * @param {object} summary - The JSON output from the summary prompt
+ * @returns {string} Formatted markdown
+ */
+function formatSummary(summary) {
+  const lines = [];
+  const s = summary;
+
+  // ── Headline ──
+  lines.push(`# Call with ${s.who?.name || 'Unknown'}`);
+  lines.push('');
+  lines.push(`**${s.headline}**`);
+  lines.push('');
+
+  // ── Vibe + Score one-liner ──
+  const vibeLabel = VIBE_LABELS[s.vibe] || s.vibe;
+  const scoreStr = s.collaboration?.score != null
+    ? ` | Overlap: ${s.collaboration.score.toFixed(2)}/1.00`
+    : '';
+  lines.push(`*${vibeLabel}${scoreStr}* \`${s.vibe}\``);
+  lines.push('');
+
+  // ── Quick Take ──
+  if (s.quickTake?.length) {
+    lines.push('### Quick Take');
+    for (const item of s.quickTake) {
+      lines.push(`- ${item}`);
+    }
+    lines.push('');
+  }
+
+  // ── Collaboration ──
+  if (s.collaboration) {
+    const c = s.collaboration;
+    lines.push(`### Collaboration: ${c.rating || 'N/A'}`);
+    if (c.scoreJustification) {
+      lines.push(c.scoreJustification);
+    }
+    if (c.opportunities?.length) {
+      lines.push('');
+      for (const opp of c.opportunities) {
+        lines.push(`- ${opp}`);
+      }
+    }
+    lines.push('');
+  }
+
+  // ── Next Steps ──
+  if (s.nextSteps?.length) {
+    lines.push('### Next Steps');
+    for (const step of s.nextSteps) {
+      lines.push(`- [ ] ${step}`);
+    }
+    lines.push('');
+  }
+
+  // ── Separator ──
+  lines.push('---');
+  lines.push('');
+
+  // ── Details Section ──
+  lines.push('### Details');
+  lines.push('');
+
+  // Who
+  if (s.who) {
+    lines.push(`**Who:** ${s.who.name || 'Unknown'}${s.who.represents ? ` — ${s.who.represents}` : ''}`);
+    if (s.who.keyFacts?.length) {
+      for (const fact of s.who.keyFacts) {
+        lines.push(`- ${fact}`);
+      }
+    }
+    lines.push('');
+  }
+
+  // Exchange
+  if (s.exchange) {
+    lines.push('**What We Exchanged**');
+    if (s.exchange.weGot?.length) {
+      lines.push(`- Got: ${s.exchange.weGot.join('; ')}`);
+    }
+    if (s.exchange.weGave?.length) {
+      lines.push(`- Gave: ${s.exchange.weGave.join('; ')}`);
+    }
+    if (s.exchange.balance) {
+      lines.push(`- Balance: ${s.exchange.balance}`);
+    }
+    lines.push('');
+  }
+
+  // Disclosure
+  if (s.disclosure) {
+    const d = s.disclosure;
+    const complianceLabel = d.compliance === 'clean' ? 'Clean — no issues'
+      : d.compliance === 'minor_concern' ? 'Minor concern — review below'
+      : d.compliance === 'violation' ? 'VIOLATION — action required'
+      : d.compliance;
+
+    lines.push(`**Disclosure:** ${complianceLabel} \`${d.compliance}\``);
+    if (d.topicsCovered?.length) {
+      lines.push(`- Covered: ${d.topicsCovered.join(', ')}`);
+    }
+    if (d.topicsAvoided?.length) {
+      lines.push(`- Properly avoided: ${d.topicsAvoided.join(', ')}`);
+    }
+    if (d.concerns?.length) {
+      for (const concern of d.concerns) {
+        lines.push(`- **Concern:** ${concern}`);
+      }
+    }
+    lines.push('');
+  }
+
+  // Objectives
+  if (s.objectives) {
+    const o = s.objectives;
+    const parts = [];
+    if (o.achieved?.length) parts.push(`Achieved: ${o.achieved.join(', ')}`);
+    if (o.partiallyAchieved?.length) parts.push(`In progress: ${o.partiallyAchieved.join(', ')}`);
+    if (o.notAchieved?.length) parts.push(`Not addressed: ${o.notAchieved.join(', ')}`);
+    if (parts.length) {
+      lines.push('**Objectives**');
+      for (const p of parts) lines.push(`- ${p}`);
+      lines.push('');
+    }
+  }
+
+  // Trust
+  if (s.trust) {
+    lines.push(`**Trust:** ${s.trust.level}${s.trust.reasoning ? ` — ${s.trust.reasoning}` : ''}`);
+    lines.push('');
+  }
+
+  // Assessment
+  if (s.assessment) {
+    lines.push(`**Bottom line:** ${s.assessment}`);
+  }
+
+  return lines.join('\n');
+}
+
+module.exports = { formatSummary, VIBE_LABELS };

package/src/lib/summary-prompt.js

@@ -0,0 +1,203 @@
+/**
+ * Unified Summary Prompt Builder
+ *
+ * Builds a comprehensive summary prompt that includes all context
+ * needed for accurate, auditable conversation summaries:
+ *
+ *   - Conversation objective (why the call happened)
+ *   - Disclosure manifest (what's in scope for this tier)
+ *   - Collaboration state (phase, overlap score, threads)
+ *   - Full transcript
+ *   - Owner context
+ *
+ * Used by both OpenClaw and spawned-agent summary paths.
+ */
+
+/**
+ * Build a unified summary prompt with full context.
+ *
+ * @param {object} options
+ * @param {Array} options.transcript - [{direction, content}]
+ * @param {object} options.callerInfo - {name, owner, context}
+ * @param {string} [options.conversationObjective] - Why this call was made
+ * @param {object} [options.disclosure] - {topics, objectives, doNotDiscuss, neverDisclose}
+ * @param {object} [options.collaborationState] - {phase, overlapScore, activeThreads, ...}
+ * @param {object} [options.ownerContext] - {agentName, ownerName, goals}
+ * @returns {string} The complete prompt
+ */
+function buildUnifiedSummaryPrompt(options = {}) {
+  const {
+    transcript = [],
+    callerInfo = {},
+    conversationObjective,
+    disclosure,
+    collaborationState,
+    ownerContext = {}
+  } = options;
+
+  const sections = [];
+
+  // ── Header ──
+  sections.push(`You just finished an A2A agent-to-agent call. Summarize it for your owner.
+
+Your tone: friendly, clear, and genuinely helpful. Lead with what matters most.
+Write like you're briefing a smart friend — not filing a report.`);
+
+  // ── Conversation Objective ──
+  if (conversationObjective) {
+    sections.push(`## Why This Call Happened
+${conversationObjective}`);
+  }
+
+  // ── Owner Context ──
+  if (ownerContext.agentName || ownerContext.ownerName || ownerContext.goals) {
+    const parts = [];
+    if (ownerContext.agentName) parts.push(`You are: ${ownerContext.agentName}`);
+    if (ownerContext.ownerName) parts.push(`Your owner: ${ownerContext.ownerName}`);
+    if (ownerContext.goals?.length) {
+      parts.push(`Owner's current goals:\n${ownerContext.goals.map(g => `- ${g}`).join('\n')}`);
+    }
+    sections.push(`## Your Owner\n${parts.join('\n')}`);
+  }
+
+  // ── Disclosure Manifest ──
+  if (disclosure) {
+    const discParts = [];
+
+    if (disclosure.topics?.length) {
+      discParts.push('### Topics In Scope');
+      for (const t of disclosure.topics) {
+        discParts.push(`- **${t.topic}**: ${t.description}`);
+      }
+    }
+
+    if (disclosure.objectives?.length) {
+      discParts.push('\n### Conversation Objectives');
+      for (const o of disclosure.objectives) {
+        const label = o.objective || o.topic;
+        discParts.push(`- **${label}**: ${o.description}`);
+      }
+    }
+
+    if (disclosure.doNotDiscuss?.length) {
+      discParts.push('\n### Do Not Discuss (Deflect These)');
+      for (const d of disclosure.doNotDiscuss) {
+        discParts.push(`- **${d.topic}**: ${d.reason}`);
+      }
+    }
+
+    if (disclosure.neverDisclose?.length) {
+      discParts.push('\n### Never Disclose (Hard Blocks)');
+      for (const n of disclosure.neverDisclose) {
+        discParts.push(`- ${n}`);
+      }
+    }
+
+    sections.push(`## Disclosure Boundaries\nThese are the rules your agent operated under. Check whether they were followed.\n\n${discParts.join('\n')}`);
+  }
+
+  // ── Collaboration State ──
+  if (collaborationState) {
+    const cs = collaborationState;
+    sections.push(`## Collaboration State at End of Call
+- **Phase:** ${cs.phase || 'unknown'} (handshake -> exploring -> deepening -> converging -> close)
+- **Overlap Score:** ${cs.overlapScore != null ? cs.overlapScore.toFixed(2) : 'unknown'}/1.00
+- **Turn Count:** ${cs.turnCount || 'unknown'}
+- **Active Threads:** ${cs.activeThreads?.length ? cs.activeThreads.join(', ') : 'none identified'}
+- **Candidate Collaborations:** ${cs.candidateCollaborations?.length ? cs.candidateCollaborations.join(', ') : 'none yet'}
+- **Close Signal:** ${cs.closeSignal ? 'yes' : 'no'}
+
+### What Overlap Score Means
+- 0.00–0.30: Minimal alignment — different domains, graceful mismatch expected
+- 0.30–0.60: Moderate — some shared interests, worth exploring
+- 0.60–0.80: Strong — clear mutual value, specific opportunities emerging
+- 0.80–1.00: Deep alignment — ready for concrete collaboration`);
+  }
+
+  // ── Transcript ──
+  const callerLabel = callerInfo.name || 'Caller';
+  const messageText = transcript.map(m => {
+    const role = m.direction === 'inbound' ? `[${callerLabel}]` : '[You]';
+    return `${role}: ${m.content}`;
+  }).join('\n\n');
+
+  sections.push(`## Caller
+${callerInfo.name ? `**Name:** ${callerInfo.name}` : 'Unknown caller'}
+${callerInfo.owner ? `**Represents:** ${callerInfo.owner}` : ''}
+${callerInfo.context ? `**Context:** ${callerInfo.context}` : ''}`);
+
+  sections.push(`## Full Transcript\n${messageText}`);
+
+  // ── Output Instructions ──
+  sections.push(`## Your Task
+
+Summarize this call. Return valid JSON matching this exact schema:
+
+{
+  "headline": "One sentence — the single most important takeaway for the owner",
+
+  "vibe": "productive | exploratory | mismatch | guarded | breakthrough",
+
+  "quickTake": [
+    "Most important discovery or outcome",
+    "Key opportunity or concern",
+    "Recommended immediate action"
+  ],
+
+  "who": {
+    "name": "Caller name",
+    "represents": "Who they work for or represent",
+    "keyFacts": ["Notable fact 1", "Notable fact 2"]
+  },
+
+  "collaboration": {
+    "score": 0.00,
+    "scoreJustification": "Why this score — what aligned, what didn't",
+    "rating": "HIGH | MEDIUM | LOW",
+    "opportunities": ["Specific opportunity with details"]
+  },
+
+  "exchange": {
+    "weGot": ["Info or value we received"],
+    "weGave": ["Info or value we shared"],
+    "balance": "favorable | even | unfavorable"
+  },
+
+  "disclosure": {
+    "compliance": "clean | minor_concern | violation",
+    "topicsCovered": ["In-scope topics that were discussed"],
+    "topicsAvoided": ["Topics that were properly deflected"],
+    "concerns": ["Any info shared that shouldn't have been, or empty array"]
+  },
+
+  "objectives": {
+    "achieved": ["Objectives that were met"],
+    "partiallyAchieved": ["Objectives with some progress"],
+    "notAchieved": ["Objectives not addressed"]
+  },
+
+  "nextSteps": [
+    "Specific actionable follow-up 1",
+    "Specific actionable follow-up 2"
+  ],
+
+  "trust": {
+    "level": "maintain | increase | decrease | revoke",
+    "reasoning": "One sentence — why this trust recommendation"
+  },
+
+  "assessment": "One sentence — strategic value judgment for the owner"
+}
+
+Important:
+- Validate the collaboration score — does it match what actually happened in the conversation?
+- Check disclosure compliance — was any never_disclose or do_not_discuss info leaked?
+- Be honest about objectives — don't inflate partial progress into "achieved"
+- quickTake should be genuinely useful, not generic platitudes
+
+JSON:`);
+
+  return sections.join('\n\n');
+}
+
+module.exports = { buildUnifiedSummaryPrompt };

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/lib/update-checker.js

@@ -0,0 +1,93 @@
+/**
+ * Update Checker
+ *
+ * Zero-dependency npm version checks for a2acalling.
+ */
+
+const REGISTRY_URL = 'https://registry.npmjs.org/a2acalling/latest';
+const FETCH_TIMEOUT_MS = 15000;
+
+function parseVersion(str) {
+  if (!str || typeof str !== 'string') return null;
+  const match = str.trim().match(/^(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return null;
+  return {
+    major: Number.parseInt(match[1], 10),
+    minor: Number.parseInt(match[2], 10),
+    patch: Number.parseInt(match[3], 10)
+  };
+}
+
+function compareVersions(a, b) {
+  const va = parseVersion(a);
+  const vb = parseVersion(b);
+  if (!va || !vb) return 0;
+  if (va.major !== vb.major) return va.major < vb.major ? -1 : 1;
+  if (va.minor !== vb.minor) return va.minor < vb.minor ? -1 : 1;
+  if (va.patch !== vb.patch) return va.patch < vb.patch ? -1 : 1;
+  return 0;
+}
+
+function isSameMajor(a, b) {
+  const va = parseVersion(a);
+  const vb = parseVersion(b);
+  if (!va || !vb) return false;
+  return va.major === vb.major;
+}
+
+async function fetchLatestVersion() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    const res = await fetch(REGISTRY_URL, {
+      signal: controller.signal,
+      headers: { Accept: 'application/json' }
+    });
+    clearTimeout(timeout);
+    if (!res.ok) {
+      return { error: `Registry returned ${res.status}` };
+    }
+    const data = await res.json();
+    if (!data || typeof data.version !== 'string') {
+      return { error: 'No version field in registry response' };
+    }
+    return { version: data.version };
+  } catch (err) {
+    if (err && err.name === 'AbortError') {
+      return { error: 'Registry request timed out' };
+    }
+    return { error: err && err.message ? err.message : 'Unknown fetch error' };
+  }
+}
+
+async function checkForUpdate(currentVersion) {
+  const result = await fetchLatestVersion();
+  if (result.error) {
+    return {
+      available: false,
+      current: currentVersion,
+      latest: null,
+      sameMajor: false,
+      error: result.error
+    };
+  }
+
+  const latest = result.version;
+  return {
+    available: compareVersions(currentVersion, latest) < 0,
+    current: currentVersion,
+    latest,
+    sameMajor: isSameMajor(currentVersion, latest)
+  };
+}
+
+module.exports = {
+  REGISTRY_URL,
+  FETCH_TIMEOUT_MS,
+  parseVersion,
+  compareVersions,
+  isSameMajor,
+  fetchLatestVersion,
+  checkForUpdate
+};
+