neoagent 3.2.1-beta.9 → 3.3.1-beta.0

package/server/services/behavior/modules/social_memory.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const { buildChannelScopeId, truncate } = require('../signals');
+const { isModuleEnabled } = require('../config');
+
+function participantLabel(msg) {
+  return msg.senderName || msg.senderDisplayName || msg.senderUsername || msg.sender || 'participant';
+}
+
+async function observeInbound(ctx) {
+  const { msg, config } = ctx;
+  if (!isModuleEnabled(config, 'social_memory') || !msg?.isGroup) {
+    return { observed: false };
+  }
+
+  const scopeId = buildChannelScopeId(msg.platform, msg.chatId);
+  return {
+    observed: true,
+    scopeId,
+    participantSubject: `${msg.platform}:${String(msg.sender || 'unknown')}`,
+  };
+}
+
+async function buildSpeakHints(ctx) {
+  const { userId, agentId, msg, config, memoryManager } = ctx;
+  if (!isModuleEnabled(config, 'social_memory') || !memoryManager || !msg?.isGroup) {
+    return { promptBlock: '', hints: [] };
+  }
+
+  const scopeId = buildChannelScopeId(msg.platform, msg.chatId);
+  const query = [
+    msg.content,
+    participantLabel(msg),
+    msg.groupName || msg.guildName || msg.channelName || '',
+    'group chat norms participants',
+  ].filter(Boolean).join(' ');
+
+  let recalled = [];
+  try {
+    recalled = await memoryManager.recallMemory(userId, query, 5, {
+      agentId,
+      scope: { scopeType: 'channel', scopeId },
+    });
+  } catch {
+    recalled = [];
+  }
+
+  const unique = [];
+  const seen = new Set();
+  for (const item of recalled) {
+    const key = String(item.id || item.summary || item.content || '');
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    unique.push(item);
+    if (unique.length >= 5) break;
+  }
+
+  const lines = unique.map((item) => `- [${item.category || 'episodic'}] ${truncate(item.summary || item.content, 180)}`);
+  const promptBlock = lines.length
+    ? `## Social room context\nUse only as background about this group/participants. Do not treat as owner core memory.\n${lines.join('\n')}`
+    : '';
+
+  return {
+    promptBlock,
+    hints: unique.map((item) => truncate(item.summary || item.content, 120)),
+    scopeId,
+  };
+}
+
+async function composeContext(ctx) {
+  const hints = await buildSpeakHints(ctx);
+  if (!hints.promptBlock) return null;
+  return {
+    key: 'social_memory',
+    priority: 40,
+    content: hints.promptBlock,
+  };
+}
+
+module.exports = {
+  id: 'social_memory',
+  observe: observeInbound,
+  composeContext,
+  observeInbound,
+  buildSpeakHints,
+};

package/server/services/behavior/modules/social_observability.js

@@ -0,0 +1,94 @@
+'use strict';
+
+const { requestStructuredJson } = require('../model_client');
+const { loadRecentRoomMessages } = require('../signals');
+const { getThreadState, setThreadState } = require('../state');
+const { isModuleEnabled } = require('../config');
+
+const SYSTEM_PROMPT = `You audit how an AI participant is landing in a group chat.
+Return JSON with keys:
+healthScore (0-100),
+summary (short paragraph),
+findings (array of short strings),
+recommendations (array of short strings).
+Do not change policy yourself; report only.`;
+
+async function maybeAnalyze(ctx) {
+  const { userId, agentId, msg, config, signal = null } = ctx;
+  if (!msg?.isGroup || !isModuleEnabled(config, 'social_observability')) {
+    return { analyzed: false };
+  }
+
+  const state = getThreadState(userId, agentId, msg.platform, msg.chatId);
+  const messageCount = Number(state.messageCountSinceObservability || 0) + 1;
+  if (!state.lastObservabilitySummary && messageCount < 24) {
+    setThreadState(userId, agentId, msg.platform, msg.chatId, {
+      messageCountSinceObservability: messageCount,
+    });
+    return { analyzed: false, deferred: true };
+  }
+  const intervalMs = Number(config.observabilityIntervalMinutes || 360) * 60 * 1000;
+  if (state.lastObservabilityAt) {
+    const age = Date.now() - Date.parse(state.lastObservabilityAt);
+    if (Number.isFinite(age) && age < intervalMs) {
+      return { analyzed: false, deferred: true, summary: state.lastObservabilitySummary || null };
+    }
+  }
+
+  const roomMessages = loadRecentRoomMessages({
+    userId,
+    agentId,
+    platform: msg.platform,
+    chatId: msg.chatId,
+    limit: 30,
+  });
+  if (roomMessages.length < 6) {
+    return { analyzed: false, reason: 'insufficient_history' };
+  }
+
+  try {
+    const result = await requestStructuredJson({
+      agentEngine: ctx.agentEngine,
+      userId,
+      agentId,
+      purpose: 'fast',
+      system: SYSTEM_PROMPT,
+      prompt: JSON.stringify({
+        platform: msg.platform,
+        chatId: msg.chatId,
+        recentSilenceCount: state.recentSilenceCount || 0,
+        recentMessages: roomMessages,
+      }),
+      signal,
+      maxTokens: 320,
+    });
+    const summary = {
+      healthScore: Number(result.parsed?.healthScore || 0),
+      summary: String(result.parsed?.summary || '').trim(),
+      findings: Array.isArray(result.parsed?.findings) ? result.parsed.findings.slice(0, 8) : [],
+      recommendations: Array.isArray(result.parsed?.recommendations) ? result.parsed.recommendations.slice(0, 8) : [],
+      at: new Date().toISOString(),
+    };
+    setThreadState(userId, agentId, msg.platform, msg.chatId, {
+      lastObservabilityAt: summary.at,
+      lastObservabilitySummary: summary,
+      messageCountSinceObservability: 0,
+    });
+    return { analyzed: true, summary };
+  } catch (error) {
+    if (signal?.aborted) throw error;
+    return { analyzed: false, error: error?.message || String(error) };
+  }
+}
+
+function getLatestSummary(userId, agentId, platform, chatId) {
+  const state = getThreadState(userId, agentId, platform, chatId);
+  return state.lastObservabilitySummary || null;
+}
+
+module.exports = {
+  id: 'social_observability',
+  afterTurn: maybeAnalyze,
+  maybeAnalyze,
+  getLatestSummary,
+};

package/server/services/behavior/modules/social_signals.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const { setThreadState, getThreadState } = require('../state');
+const { isModuleEnabled } = require('../config');
+
+function recordSignal(ctx) {
+  const { userId, agentId, msg, config, signalType = 'message', details = {} } = ctx;
+  if (!isModuleEnabled(config, 'social_signals')) {
+    return { recorded: false };
+  }
+  const state = getThreadState(userId, agentId, msg.platform, msg.chatId);
+  const signals = Array.isArray(state.recentSignals) ? state.recentSignals.slice(-19) : [];
+  signals.push({
+    type: signalType,
+    at: new Date().toISOString(),
+    sender: msg.sender || null,
+    details,
+  });
+  setThreadState(userId, agentId, msg.platform, msg.chatId, {
+    recentSignals: signals,
+  });
+  return { recorded: true, count: signals.length };
+}
+
+function observe(ctx) {
+  return recordSignal({
+    ...ctx,
+    signalType: ctx.msg?.eventType || 'inbound_message',
+    details: {
+      hasMedia: Boolean(ctx.msg?.localMediaPath || ctx.msg?.mediaType),
+      wasMentioned: ctx.msg?.wasMentioned === true,
+      repliedToAgent: ctx.msg?.repliedToAgent === true,
+    },
+  });
+}
+
+module.exports = {
+  id: 'social_signals',
+  observe,
+  recordSignal,
+};

package/server/services/behavior/modules/theory_of_mind.js

@@ -0,0 +1,118 @@
+'use strict';
+
+const { requestStructuredJson } = require('../model_client');
+const { isModuleEnabled } = require('../config');
+const { truncate } = require('../signals');
+const { INTERACTION_VOICE_RULES } = require('./persona');
+
+const BASE_SYSTEM_PROMPT = `You are the final reviewer for an AI draft in a multi-party chat.
+Return JSON with keys:
+action ("send"|"revise"|"suppress"),
+revisedContent (string, required if action is revise, else empty),
+risk ("low"|"medium"|"high"),
+reasonCodes (array of short strings),
+rationale (one short sentence).
+Prefer minimal edits. Suppress only if the draft is likely harmful, invasive, clearly socially damaging, redundant after the conversation moved on, or no longer worth adding.`;
+
+async function refineDraft(ctx) {
+  const {
+    userId,
+    agentId,
+    msg,
+    config,
+    draft,
+    signal = null,
+    runId = null,
+  } = ctx;
+
+  if (!msg?.isGroup || !isModuleEnabled(config, 'theory_of_mind')) {
+    return {
+      action: 'send',
+      content: draft,
+      risk: 'low',
+      reasonCodes: ['tom_disabled_or_direct'],
+    };
+  }
+
+  const content = String(draft || '').trim();
+  if (!content || content.toUpperCase() === '[NO RESPONSE]') {
+    return {
+      action: 'send',
+      content,
+      risk: 'low',
+      reasonCodes: ['empty_or_silent'],
+    };
+  }
+
+  try {
+    const runModelId = runId
+      ? ctx.agentEngine?.getRunMeta?.(runId)?.modelSelectionId || null
+      : null;
+    const system = isModuleEnabled(config, 'persona')
+      ? `${BASE_SYSTEM_PROMPT}\n\n${INTERACTION_VOICE_RULES}`
+      : BASE_SYSTEM_PROMPT;
+    const result = await requestStructuredJson({
+      agentEngine: ctx.agentEngine,
+      userId,
+      agentId,
+      modelId: config.decisionModelId || runModelId,
+      purpose: runModelId ? 'general' : config.decisionModelPurpose,
+      system,
+      prompt: JSON.stringify({
+        room: {
+          platform: msg.platform,
+          chatId: msg.chatId,
+          isGroup: true,
+          sender: msg.senderName || msg.sender,
+          inbound: truncate(msg.content, 500),
+        },
+        draft: truncate(content, 2800),
+      }),
+      signal,
+      maxTokens: 900,
+    });
+    const parsed = result.parsed || {};
+    const action = ['send', 'revise', 'suppress'].includes(String(parsed.action || ''))
+      ? String(parsed.action)
+      : 'send';
+    if (action === 'suppress') {
+      return {
+        action,
+        content: '[NO RESPONSE]',
+        risk: parsed.risk || 'high',
+        reasonCodes: parsed.reasonCodes || ['tom_suppress'],
+        rationale: parsed.rationale || '',
+      };
+    }
+    if (action === 'revise' && String(parsed.revisedContent || '').trim()) {
+      return {
+        action,
+        content: String(parsed.revisedContent).trim(),
+        risk: parsed.risk || 'medium',
+        reasonCodes: parsed.reasonCodes || ['tom_revise'],
+        rationale: parsed.rationale || '',
+      };
+    }
+    return {
+      action: 'send',
+      content,
+      risk: parsed.risk || 'low',
+      reasonCodes: parsed.reasonCodes || ['tom_send'],
+      rationale: parsed.rationale || '',
+    };
+  } catch (error) {
+    if (signal?.aborted) throw error;
+    return {
+      action: 'send',
+      content,
+      risk: 'low',
+      reasonCodes: ['tom_error_passthrough'],
+      failureCode: 'model_unavailable',
+    };
+  }
+}
+
+module.exports = {
+  id: 'theory_of_mind',
+  refineDraft,
+};

package/server/services/behavior/modules/turn_taking.js

@@ -0,0 +1,238 @@
+'use strict';
+
+const { requestStructuredJson } = require('../model_client');
+const { buildDecisionPacket, loadRecentRoomMessages } = require('../signals');
+const { getThreadState, setThreadState } = require('../state');
+const { isModuleEnabled } = require('../config');
+
+const SYSTEM_PROMPT = `You are NeoAgent's group turn-taking gate.
+Decide whether the agent should speak now or stay silent in a multi-party chat.
+Default posture in groups: prefer holding back. Speak only when the agent would add clear value, is addressed, can usefully answer an open need, should correct a harmful misunderstanding, or media/context clearly calls for a response.
+Judge the meaning and flow of the provided room context. Do not use phrase matching or keyword rules.
+Return JSON only with keys:
+decision ("speak" or "stay_silent"),
+needScore (0-1 number measuring how worthwhile an agent contribution is now),
+confidence (0-1 number),
+reasonCodes (array of short snake_case strings),
+urgency ("low"|"medium"|"high"),
+rationale (one short sentence).`;
+
+function normalizeDecision(raw, fallback) {
+  const decision = String(raw?.decision || fallback.decision || 'stay_silent').trim().toLowerCase();
+  const score = (value, fallbackValue) => {
+    const number = Number(value);
+    const normalized = Number.isFinite(number) ? number : Number(fallbackValue);
+    return Math.max(0, Math.min(1, Number.isFinite(normalized) ? normalized : 0.5));
+  };
+  const normalized = {
+    decision: decision === 'speak' ? 'speak' : 'stay_silent',
+    needScore: score(raw?.needScore, fallback.needScore),
+    confidence: score(raw?.confidence, fallback.confidence),
+    reasonCodes: Array.isArray(raw?.reasonCodes)
+      ? raw.reasonCodes.map((item) => String(item || '').trim()).filter(Boolean).slice(0, 8)
+      : (fallback.reasonCodes || []),
+    urgency: ['low', 'medium', 'high'].includes(String(raw?.urgency || ''))
+      ? String(raw.urgency)
+      : (fallback.urgency || 'low'),
+    rationale: String(raw?.rationale || fallback.rationale || '').trim().slice(0, 240),
+    tokenPath: fallback.tokenPath || 'gate_only',
+    model: raw?.model || fallback.model || null,
+  };
+  const usage = Number(raw?.usage ?? fallback.usage);
+  if (Number.isFinite(usage)) normalized.usage = usage;
+  return normalized;
+}
+
+function localFallbackDecision(packet, config) {
+  if (!packet.chat.isGroup) {
+    return normalizeDecision({
+      decision: 'speak',
+      needScore: 1,
+      confidence: 1,
+      reasonCodes: ['direct_chat'],
+      urgency: 'medium',
+      rationale: 'Direct chats always engage.',
+    }, { tokenPath: 'gate_skip' });
+  }
+
+  if (packet.event.wasMentioned || packet.event.repliedToAgent) {
+    return normalizeDecision({
+      decision: 'speak',
+      needScore: 1,
+      confidence: 0.85,
+      reasonCodes: [packet.event.repliedToAgent ? 'reply_to_agent' : 'addressed'],
+      urgency: 'medium',
+      rationale: 'Fallback engaged because platform metadata directly addresses the agent.',
+    }, { tokenPath: 'gate_fallback' });
+  }
+  return normalizeDecision({
+    decision: 'stay_silent',
+    needScore: 0,
+    confidence: 0.7,
+    reasonCodes: ['prefer_hold_back', 'model_unavailable'],
+    urgency: 'low',
+    rationale: 'Fallback gate holds back in groups when address is unclear.',
+  }, { tokenPath: 'gate_fallback' });
+}
+
+async function shouldEngage(ctx) {
+  const startedAt = Date.now();
+  const {
+    userId,
+    agentId,
+    msg,
+    config,
+    signal = null,
+    memoryHints = [],
+    agentEngine,
+    turnEpoch,
+  } = ctx;
+
+  if (!msg?.isGroup || !isModuleEnabled(config, 'turn_taking') || config.enabled === false) {
+    return {
+      decision: 'speak',
+      needScore: 1,
+      confidence: 1,
+      reasonCodes: msg?.isGroup ? ['turn_taking_disabled'] : ['direct_chat'],
+      urgency: 'medium',
+      rationale: msg?.isGroup ? 'Turn-taking disabled; engaging.' : 'Direct chat always engages.',
+      tokenPath: 'gate_skip',
+      latencyMs: Date.now() - startedAt,
+      turnEpoch,
+    };
+  }
+
+  if (msg.wasMentioned || msg.repliedToAgent) {
+    return {
+      decision: 'speak',
+      needScore: 1,
+      confidence: 1,
+      reasonCodes: [msg.repliedToAgent ? 'reply_to_agent' : 'addressed'],
+      urgency: 'medium',
+      rationale: 'Platform metadata directly addresses the agent.',
+      tokenPath: 'gate_skip',
+      latencyMs: Date.now() - startedAt,
+      turnEpoch,
+    };
+  }
+
+  const mode = config.participationMode || 'automatic';
+  if (mode === 'always') {
+    return {
+      decision: 'speak',
+      needScore: 1,
+      confidence: 1,
+      reasonCodes: ['participation_always'],
+      urgency: 'medium',
+      rationale: 'Room participation is configured to always engage.',
+      tokenPath: 'gate_skip',
+      latencyMs: Date.now() - startedAt,
+      turnEpoch,
+    };
+  }
+  if (mode === 'mention_only') {
+    return {
+      decision: 'stay_silent',
+      needScore: 0,
+      confidence: 1,
+      reasonCodes: ['mention_only'],
+      urgency: 'low',
+      rationale: 'Room participation requires a structural mention or reply.',
+      tokenPath: 'gate_skip',
+      latencyMs: Date.now() - startedAt,
+      turnEpoch,
+    };
+  }
+
+  const threadState = getThreadState(userId, agentId, msg.platform, msg.chatId);
+  const roomMessages = loadRecentRoomMessages({
+    userId,
+    agentId,
+    platform: msg.platform,
+    chatId: msg.chatId,
+    limit: config.decisionContextMessageLimit,
+  });
+  const packet = buildDecisionPacket({
+    msg,
+    config,
+    threadState,
+    roomMessages,
+    localMemoryHints: memoryHints,
+  });
+
+  let decision;
+  try {
+    const result = await requestStructuredJson({
+      agentEngine,
+      userId,
+      agentId,
+      modelId: config.decisionModelId,
+      purpose: config.decisionModelPurpose,
+      system: SYSTEM_PROMPT,
+      prompt: JSON.stringify(packet),
+      signal,
+      maxTokens: 220,
+      fallback: {
+        decision: 'stay_silent',
+        needScore: 0,
+        confidence: 0.55,
+        reasonCodes: ['parse_fallback'],
+        urgency: 'low',
+        rationale: 'The decision could not be parsed.',
+      },
+    });
+    decision = normalizeDecision(result.parsed || {}, {
+      decision: 'stay_silent',
+      needScore: 0,
+      confidence: 0.55,
+      reasonCodes: ['parse_fallback'],
+      urgency: 'low',
+      rationale: 'Could not parse gate response; holding back.',
+      tokenPath: 'gate_only',
+      model: result.modelSelectionId || result.model,
+    });
+    decision.model = result.modelSelectionId || result.model;
+    decision.usage = Number(result.usage || 0);
+  } catch (error) {
+    if (signal?.aborted) throw error;
+    decision = localFallbackDecision(packet, config);
+    decision.failureCode = 'model_unavailable';
+  }
+
+  // Confidence measures certainty. Need score measures whether speaking is worthwhile.
+  if (
+    decision.decision === 'speak'
+    && Number(decision.needScore || 0) < Number(config.minimumNeedScore ?? 0.72)
+    && !packet.event.wasMentioned
+    && !packet.event.repliedToAgent
+  ) {
+    decision = normalizeDecision({
+      ...decision,
+      decision: 'stay_silent',
+      reasonCodes: [...(decision.reasonCodes || []), 'below_need_threshold'],
+      rationale: decision.rationale || 'The contribution value is below the room threshold.',
+    }, { tokenPath: decision.tokenPath || 'gate_only', model: decision.model });
+  }
+
+  setThreadState(userId, agentId, msg.platform, msg.chatId, {
+    lastDecision: decision.decision,
+    lastDecisionAt: new Date().toISOString(),
+    recentSilenceCount: decision.decision === 'stay_silent'
+      ? Number(threadState.recentSilenceCount || 0) + 1
+      : 0,
+  });
+
+  return {
+    ...decision,
+    latencyMs: Date.now() - startedAt,
+    turnEpoch,
+  };
+}
+
+module.exports = {
+  id: 'turn_taking',
+  decide: shouldEngage,
+  shouldEngage,
+  normalizeDecision,
+  localFallbackDecision,
+};