neoagent 3.2.1-beta.10 → 3.2.1-beta.11

package/server/services/behavior/pipeline.js

@@ -0,0 +1,285 @@
+'use strict';
+
+const { resolveBehaviorConfig, isModuleEnabled } = require('./config');
+const {
+  bumpTurnEpoch,
+  getThreadState,
+  isTurnCurrent,
+  markSpoke,
+} = require('./state');
+const { createBehaviorRegistry } = require('./registry');
+const { BEHAVIOR_MODULES } = require('./modules');
+const { createServiceLogger } = require('../../utils/logger');
+
+const logger = createServiceLogger('Behavior');
+
+function createBehaviorPipeline(deps = {}) {
+  const memoryManager = deps.memoryManager || null;
+  const agentEngine = deps.agentEngine || null;
+  const io = deps.io || null;
+  const registry = createBehaviorRegistry(BEHAVIOR_MODULES);
+
+  function effectiveConfig(userId, agentId, msg) {
+    const config = resolveBehaviorConfig(userId, agentId, {
+      platform: msg.platform,
+      chatId: msg.chatId,
+      isGroup: Boolean(msg.isGroup),
+    });
+    if (
+      msg.isGroup
+      && config.participationModeSource === 'default'
+      && msg.accessPolicyRequireMention === true
+    ) {
+      config.participationMode = 'mention_only';
+    }
+    return config;
+  }
+
+  function noteInbound({ userId, agentId, msg }) {
+    const state = bumpTurnEpoch(userId, agentId, msg.platform, msg.chatId);
+    msg.behaviorTurnEpoch = state.turnEpoch;
+    return state.turnEpoch;
+  }
+
+  function scheduleBackground(baseCtx) {
+    const task = async (backgroundSignal) => {
+      const ctx = { ...baseCtx, signal: backgroundSignal };
+      await registry.run('afterTurn', ctx);
+    };
+    const key = [
+      'social-background',
+      baseCtx.userId,
+      baseCtx.agentId || 'main',
+      baseCtx.msg.platform,
+      baseCtx.msg.chatId,
+    ].join(':');
+    const promise = agentEngine?.trackBackgroundTask
+      ? agentEngine.trackBackgroundTask(task, { key, coalesce: true, signal: baseCtx.signal })
+      : Promise.resolve().then(() => task(baseCtx.signal));
+    promise.catch((error) => {
+      if (!baseCtx.signal?.aborted) logger.warn('background analysis failed:', error?.message || error);
+    });
+  }
+
+  async function handleInbound({ userId, agentId, msg, signal = null }) {
+    const config = effectiveConfig(userId, agentId, msg);
+    const turnEpoch = Number(msg.behaviorTurnEpoch)
+      || noteInbound({ userId, agentId, msg });
+    if (config.enabled === false) {
+      return {
+        engage: true,
+        decision: {
+          decision: 'speak',
+          needScore: 1,
+          confidence: 1,
+          reasonCodes: ['behavior_disabled'],
+          urgency: 'medium',
+          rationale: 'Behavior modules are disabled; using the standard response path.',
+          tokenPath: 'gate_skip',
+          latencyMs: 0,
+          turnEpoch,
+        },
+        config,
+        promptBlocks: [],
+        observeResult: null,
+      };
+    }
+
+    const baseCtx = {
+      userId,
+      agentId,
+      msg,
+      config,
+      signal,
+      memoryManager,
+      agentEngine,
+      turnEpoch,
+      isModuleEnabled: (moduleId) => isModuleEnabled(config, moduleId),
+    };
+
+    const observations = await registry.run('observe', baseCtx);
+    const observeResult = observations.find((item) => item.moduleId === 'social_memory')?.value || null;
+    if (msg.isGroup) scheduleBackground(baseCtx);
+
+    const memoryHints = [];
+    if (observeResult?.scopeId) memoryHints.push(`channel:${observeResult.scopeId}`);
+
+    let decision;
+    if (!isModuleEnabled(config, 'turn_taking')) {
+      decision = {
+        decision: 'speak',
+        needScore: 1,
+        confidence: 1,
+        reasonCodes: ['turn_taking_disabled'],
+        urgency: 'medium',
+        rationale: 'Turn-taking is disabled; using the standard response path.',
+        tokenPath: 'gate_skip',
+        latencyMs: 0,
+        turnEpoch,
+      };
+    } else {
+      decision = (await registry.run('decide', {
+        ...baseCtx,
+        memoryHints,
+      })).find((item) => item.moduleId === 'turn_taking')?.value;
+    }
+    if (!decision) {
+      throw new Error('The turn-taking module did not return a decision.');
+    }
+
+    if (io && userId) {
+      io.to(`user:${userId}`).emit('behavior:decision', {
+        platform: msg.platform,
+        chatId: msg.chatId,
+        agentId,
+        isGroup: Boolean(msg.isGroup),
+        decision: decision.decision,
+        confidence: decision.confidence,
+        needScore: decision.needScore,
+        reasonCodes: decision.reasonCodes || [],
+        urgency: decision.urgency,
+        rationale: decision.rationale || '',
+        tokenPath: decision.tokenPath || 'gate_only',
+        turnEpoch: decision.turnEpoch,
+        model: decision.model || null,
+        at: new Date().toISOString(),
+      });
+    }
+
+    if (decision.decision !== 'speak') {
+      return {
+        engage: false,
+        decision,
+        config,
+        promptBlocks: [],
+        observeResult,
+      };
+    }
+
+    const promptBlocks = await registry.composeContext(baseCtx);
+
+    return {
+      engage: true,
+      decision,
+      config,
+      promptBlocks,
+      observeResult,
+    };
+  }
+
+  async function refineAndMaybeDeliver({
+    userId,
+    agentId,
+    msg,
+    config,
+    draft,
+    messagingManager,
+    runId = null,
+    signal = null,
+    mediaPath = null,
+    deliver = false,
+    turnEpoch = null,
+  }) {
+    const expectedEpoch = Number(turnEpoch || msg.behaviorTurnEpoch || 0);
+    if (msg.isGroup && !isTurnCurrent(
+      userId,
+      agentId,
+      msg.platform,
+      msg.chatId,
+      expectedEpoch,
+    )) {
+      return {
+        action: 'suppress',
+        content: '[NO RESPONSE]',
+        delivered: false,
+        suppressed: true,
+        reasonCodes: ['stale_turn'],
+      };
+    }
+    const tom = await registry.get('theory_of_mind').refineDraft({
+      userId,
+      agentId,
+      msg,
+      config,
+      draft,
+      signal,
+      agentEngine,
+    });
+
+    const content = tom.content;
+    if (!deliver || !messagingManager) {
+      return { ...tom, delivered: false, content };
+    }
+
+    if (!content || content.toUpperCase() === '[NO RESPONSE]') {
+      return { ...tom, delivered: false, suppressed: true, content };
+    }
+
+    const deliveryConfig = isModuleEnabled(config, 'delivery')
+      ? config
+      : { ...config, deliveryStyle: 'single' };
+    const delivery = await registry.get('delivery').deliver({
+      messagingManager,
+      userId,
+      agentId,
+      platform: msg.platform,
+      chatId: msg.chatId,
+      content,
+      config: deliveryConfig,
+      runId,
+      signal,
+      mediaPath,
+      turnEpoch: expectedEpoch,
+      beforeBubble: () => !msg.isGroup || isTurnCurrent(
+        userId,
+        agentId,
+        msg.platform,
+        msg.chatId,
+        expectedEpoch,
+      ),
+    });
+
+    if (
+      (delivery?.success !== false && delivery?.suppressed !== true)
+      || Number(delivery?.deliveredBubbles || 0) > 0
+    ) {
+      markSpoke(userId, agentId, msg.platform, msg.chatId);
+    }
+
+    return {
+      ...tom,
+      delivered: delivery?.success !== false && delivery?.suppressed !== true,
+      suppressed: delivery?.suppressed === true,
+      delivery,
+      content,
+    };
+  }
+
+  function getDiagnostics(userId, agentId, platform, chatId) {
+    const config = resolveBehaviorConfig(userId, agentId, {
+      platform,
+      chatId,
+      isGroup: true,
+    });
+    const state = getThreadState(userId, agentId, platform, chatId);
+    return {
+      config,
+      state,
+      modules: Object.fromEntries(
+        Object.keys(config.modules || {}).map((id) => [id, isModuleEnabled(config, id)]),
+      ),
+    };
+  }
+
+  return {
+    registry,
+    noteInbound,
+    handleInbound,
+    refineAndMaybeDeliver,
+    getDiagnostics,
+  };
+}
+
+module.exports = {
+  createBehaviorPipeline,
+};

package/server/services/behavior/registry.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const LIFECYCLE_STAGES = Object.freeze([
+  'observe',
+  'decide',
+  'composeContext',
+  'composeSystemPrompt',
+  'refineDraft',
+  'deliver',
+  'afterTurn',
+]);
+
+function createBehaviorRegistry(modules) {
+  const byId = new Map();
+  for (const module of modules) {
+    const id = String(module?.id || '').trim();
+    if (!id) throw new Error('Behavior modules require a stable id.');
+    if (byId.has(id)) throw new Error(`Duplicate behavior module id: ${id}`);
+    byId.set(id, module);
+  }
+
+  function list() {
+    return [...byId.values()];
+  }
+
+  function get(id) {
+    return byId.get(id) || null;
+  }
+
+  async function run(stage, ctx) {
+    if (!LIFECYCLE_STAGES.includes(stage)) {
+      throw new Error(`Unknown behavior lifecycle stage: ${stage}`);
+    }
+    const results = [];
+    for (const module of byId.values()) {
+      if (ctx.isModuleEnabled && !ctx.isModuleEnabled(module.id)) continue;
+      if (typeof module[stage] !== 'function') continue;
+      results.push({ moduleId: module.id, value: await module[stage](ctx) });
+    }
+    return results;
+  }
+
+  async function composeContext(ctx) {
+    const contributions = [];
+    const keys = new Set();
+    for (const { moduleId, value } of await run('composeContext', ctx)) {
+      const entries = Array.isArray(value) ? value : [value];
+      for (const entry of entries) {
+        if (!entry?.content) continue;
+        const key = String(entry.key || moduleId).trim();
+        if (keys.has(key)) {
+          throw new Error(`Duplicate behavior prompt contribution: ${key}`);
+        }
+        keys.add(key);
+        contributions.push({
+          key,
+          priority: Number(entry.priority || 0),
+          content: String(entry.content).trim(),
+        });
+      }
+    }
+    return contributions
+      .sort((left, right) => right.priority - left.priority)
+      .map((entry) => entry.content);
+  }
+
+  return {
+    get,
+    list,
+    run,
+    composeContext,
+  };
+}
+
+module.exports = {
+  LIFECYCLE_STAGES,
+  createBehaviorRegistry,
+};

package/server/services/behavior/signals.js

@@ -0,0 +1,107 @@
+'use strict';
+
+const db = require('../../db/database');
+
+function truncate(text, max = 280) {
+  const value = String(text || '').replace(/\s+/g, ' ').trim();
+  if (value.length <= max) return value;
+  return `${value.slice(0, max - 1)}…`;
+}
+
+function buildChannelScopeId(platform, chatId) {
+  return `${String(platform || '').trim()}:${String(chatId || '').trim()}`;
+}
+
+function loadRecentRoomMessages({ userId, agentId, platform, chatId, limit = 12 }) {
+  const rows = db.prepare(
+    `SELECT role, content, created_at, metadata
+     FROM messages
+     WHERE user_id = ?
+       AND agent_id IS ?
+       AND platform = ?
+       AND platform_chat_id = ?
+     ORDER BY created_at DESC
+     LIMIT ?`,
+  ).all(userId, agentId, platform, String(chatId), Math.max(1, Math.min(Number(limit) || 12, 30)));
+
+  return rows.reverse().map((row) => {
+    let metadata = null;
+    try {
+      metadata = row.metadata ? JSON.parse(row.metadata) : null;
+    } catch {
+      metadata = null;
+    }
+    const sender = row.role === 'assistant'
+      ? 'assistant'
+      : (metadata?.senderDisplayName || metadata?.senderName || metadata?.sender || 'participant');
+    return {
+      role: row.role,
+      sender,
+      content: truncate(row.content, 320),
+      createdAt: row.created_at,
+    };
+  });
+}
+
+function buildDecisionPacket({
+  msg,
+  config,
+  threadState,
+  roomMessages = [],
+  localMemoryHints = [],
+}) {
+  const recent = Array.isArray(msg.channelContext) && msg.channelContext.length
+    ? msg.channelContext.slice(-12).map((item) => ({
+      sender: item.author || item.sender || 'participant',
+      content: truncate(item.content, 280),
+    }))
+    : roomMessages.slice(-12).map((item) => ({
+      sender: item.sender,
+      content: item.content,
+    }));
+
+  const secondsSinceSpoke = threadState?.lastSpokeAt
+    ? Math.max(0, Math.round((Date.now() - Date.parse(threadState.lastSpokeAt)) / 1000))
+    : null;
+
+  return {
+    chat: {
+      platform: msg.platform,
+      chatId: String(msg.chatId || ''),
+      isGroup: Boolean(msg.isGroup),
+      groupName: msg.groupName || msg.guildName || msg.channelName || null,
+    },
+    sender: {
+      id: msg.sender || null,
+      name: msg.senderName || msg.senderDisplayName || msg.senderUsername || null,
+      username: msg.senderUsername || null,
+      tag: msg.senderTag || null,
+    },
+    event: {
+      content: truncate(msg.content, 800),
+      hasMedia: Boolean(msg.localMediaPath || msg.mediaType),
+      mediaType: msg.mediaType || null,
+      wasMentioned: msg.wasMentioned === true,
+      repliedToAgent: msg.repliedToAgent === true,
+      timestamp: msg.timestamp || new Date().toISOString(),
+    },
+    room: {
+      recentMessages: recent,
+      secondsSinceAgentSpoke: secondsSinceSpoke,
+      recentSilenceCount: Number(threadState?.recentSilenceCount || 0),
+    },
+    policy: {
+      participationMode: config.participationMode || 'automatic',
+      minimumNeedScore: Number(config.minimumNeedScore ?? 0.72),
+      groupDefaultPosture: 'prefer_hold_back',
+    },
+    roomHints: Array.isArray(localMemoryHints) ? localMemoryHints.slice(0, 4) : [],
+  };
+}
+
+module.exports = {
+  truncate,
+  buildChannelScopeId,
+  loadRecentRoomMessages,
+  buildDecisionPacket,
+};

package/server/services/behavior/state.js

@@ -0,0 +1,99 @@
+'use strict';
+
+const MAX_THREAD_STATES = 1000;
+const THREAD_STATE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+const threadStates = new Map();
+
+function stateKey(userId, agentId, platform, chatId) {
+  return [
+    String(userId || ''),
+    String(agentId || 'main'),
+    String(platform || ''),
+    String(chatId || ''),
+  ].join('::');
+}
+
+function defaultState() {
+  return {
+    turnEpoch: 0,
+    lastDecision: null,
+    lastDecisionAt: null,
+    lastSpokeAt: null,
+    messageCountSinceNorms: 0,
+    normsPromptBlock: '',
+    normsUpdatedAt: null,
+    lastObservabilityAt: null,
+    lastObservabilitySummary: null,
+    messageCountSinceObservability: 0,
+    recentSilenceCount: 0,
+    recentSignals: [],
+  };
+}
+
+function evictThreadStates() {
+  const cutoff = Date.now() - THREAD_STATE_TTL_MS;
+  for (const [key, entry] of threadStates.entries()) {
+    if (entry.touchedAt < cutoff) threadStates.delete(key);
+  }
+  while (threadStates.size > MAX_THREAD_STATES) {
+    const oldest = threadStates.keys().next().value;
+    if (oldest == null) break;
+    threadStates.delete(oldest);
+  }
+}
+
+function getThreadState(userId, agentId, platform, chatId) {
+  const key = stateKey(userId, agentId, platform, chatId);
+  const entry = threadStates.get(key);
+  if (!entry) return defaultState();
+  threadStates.delete(key);
+  threadStates.set(key, entry);
+  entry.touchedAt = Date.now();
+  return { ...defaultState(), ...entry.value };
+}
+
+function setThreadState(userId, agentId, platform, chatId, patch = {}) {
+  const key = stateKey(userId, agentId, platform, chatId);
+  const current = getThreadState(userId, agentId, platform, chatId);
+  const next = {
+    ...current,
+    ...patch,
+  };
+  threadStates.delete(key);
+  threadStates.set(key, { value: next, touchedAt: Date.now() });
+  evictThreadStates();
+  return next;
+}
+
+function bumpTurnEpoch(userId, agentId, platform, chatId) {
+  const current = getThreadState(userId, agentId, platform, chatId);
+  return setThreadState(userId, agentId, platform, chatId, {
+    turnEpoch: Number(current.turnEpoch || 0) + 1,
+  });
+}
+
+function isTurnCurrent(userId, agentId, platform, chatId, turnEpoch) {
+  return Number(getThreadState(userId, agentId, platform, chatId).turnEpoch || 0)
+    === Number(turnEpoch || 0);
+}
+
+function markSpoke(userId, agentId, platform, chatId) {
+  return setThreadState(userId, agentId, platform, chatId, {
+    lastSpokeAt: new Date().toISOString(),
+    recentSilenceCount: 0,
+  });
+}
+
+function clearThreadStates() {
+  threadStates.clear();
+}
+
+module.exports = {
+  getThreadState,
+  setThreadState,
+  bumpTurnEpoch,
+  isTurnCurrent,
+  markSpoke,
+  clearThreadStates,
+  stateKey,
+};

package/server/services/behavior/system_prompt.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const { resolveBehaviorConfig, isModuleEnabled } = require('./config');
+const { createBehaviorRegistry } = require('./registry');
+const { BEHAVIOR_MODULES } = require('./modules');
+
+async function buildBehaviorSystemPrompt({
+  userId,
+  agentId,
+  triggerSource,
+  context,
+  memoryManager,
+}) {
+  const config = resolveBehaviorConfig(userId, agentId, {
+    platform: context.source || null,
+    chatId: context.chatId || null,
+    isGroup: context.memoryAudience === 'shared' || context.socialIntelligence?.isGroup === true,
+  });
+  const ctx = {
+    ...context,
+    userId,
+    agentId,
+    triggerSource,
+    audience: context.memoryAudience || 'owner',
+    config,
+    memoryManager,
+  };
+  const registry = createBehaviorRegistry(BEHAVIOR_MODULES);
+  const results = await registry.run('composeSystemPrompt', {
+    ...ctx,
+    isModuleEnabled: (moduleId) => isModuleEnabled(config, moduleId),
+  });
+  const priorities = {
+    channel_style: 100,
+    persona: 80,
+    agent_identity: 60,
+  };
+  const entries = [];
+  for (const entry of results) {
+    if (!entry.value) continue;
+    const priority = priorities[entry.moduleId] || 0;
+    if (typeof entry.value === 'string') {
+      entries.push({
+        moduleId: entry.moduleId,
+        content: entry.value,
+        section: entry.moduleId === 'channel_style' ? 'stable' : 'dynamic',
+        priority,
+      });
+      continue;
+    }
+    for (const section of ['stable', 'dynamic']) {
+      const values = Array.isArray(entry.value[section])
+        ? entry.value[section]
+        : [entry.value[section]];
+      for (const content of values) {
+        if (!content) continue;
+        entries.push({
+          moduleId: entry.moduleId,
+          content,
+          section,
+          priority,
+        });
+      }
+    }
+  }
+  entries.sort((left, right) => right.priority - left.priority);
+  return {
+    stable: entries.filter((entry) => entry.section === 'stable').map((entry) => entry.content),
+    dynamic: entries.filter((entry) => entry.section === 'dynamic').map((entry) => entry.content),
+  };
+}
+
+module.exports = {
+  buildBehaviorSystemPrompt,
+};