neoagent 3.2.1-beta.1 → 3.2.1-beta.11

package/server/services/behavior/delivery.js

@@ -0,0 +1,176 @@
+'use strict';
+
+const {
+  splitOutgoingMessageForPlatform,
+  normalizeOutgoingMessageForPlatform,
+} = require('../messaging/formatting_guides');
+
+function sleep(ms, signal = null) {
+  const delay = Math.max(0, Number(ms) || 0);
+  if (!delay) return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, delay);
+    const onAbort = () => {
+      cleanup();
+      const error = new Error('Delivery aborted.');
+      error.name = 'AbortError';
+      reject(error);
+    };
+    const cleanup = () => {
+      clearTimeout(timer);
+      if (signal) signal.removeEventListener('abort', onAbort);
+    };
+    if (signal) {
+      if (signal.aborted) {
+        cleanup();
+        const error = new Error('Delivery aborted.');
+        error.name = 'AbortError';
+        reject(error);
+        return;
+      }
+      signal.addEventListener('abort', onAbort, { once: true });
+    }
+  });
+}
+
+function splitIntoNaturalBubbles(platform, content, { maxBubbles = 4 } = {}) {
+  const normalized = normalizeOutgoingMessageForPlatform(platform, content, {
+    stripNoResponseMarker: false,
+  });
+  if (!normalized) return [];
+  if (normalized.toUpperCase() === '[NO RESPONSE]') return [normalized];
+
+  const paragraphChunks = splitOutgoingMessageForPlatform(platform, normalized);
+  const bubbles = [];
+  for (const chunk of paragraphChunks) {
+    const bubble = String(chunk).trim();
+    if (bubble) bubbles.push(bubble);
+  }
+
+  const limited = [];
+  for (const bubble of bubbles) {
+    if (!bubble) continue;
+    if (limited.length < maxBubbles) {
+      limited.push(bubble);
+    } else {
+      limited[limited.length - 1] = `${limited[limited.length - 1]} ${bubble}`.trim();
+    }
+  }
+  return limited.length ? limited : [normalized];
+}
+
+async function deliverSocialReply({
+  messagingManager,
+  userId,
+  agentId,
+  platform,
+  chatId,
+  content,
+  config,
+  runId = null,
+  signal = null,
+  mediaPath = null,
+  turnEpoch = null,
+  beforeBubble = null,
+}) {
+  const style = config?.deliveryStyle === 'single' ? 'single' : 'natural_bubbles';
+  if (style === 'single' || mediaPath) {
+    if (beforeBubble && !(await beforeBubble(0))) {
+      return { success: false, suppressed: true, reason: 'stale_turn', turnEpoch };
+    }
+    return messagingManager.sendMessage(userId, platform, chatId, content, {
+      agentId,
+      runId,
+      mediaPath,
+      signal,
+      deliveryKind: 'final',
+      idempotencyKey: runId ? `${runId}:social:0` : undefined,
+    });
+  }
+
+  const bubbles = splitIntoNaturalBubbles(platform, content, {
+    maxBubbles: config?.maxBubbles ?? 4,
+  });
+  if (bubbles.length <= 1) {
+    if (beforeBubble && !(await beforeBubble(0))) {
+      return { success: false, suppressed: true, reason: 'stale_turn', turnEpoch };
+    }
+    return messagingManager.sendMessage(userId, platform, chatId, bubbles[0] || content, {
+      agentId,
+      runId,
+      signal,
+      deliveryKind: 'final',
+      idempotencyKey: runId ? `${runId}:social:0` : undefined,
+    });
+  }
+
+  try {
+    let lastResult = null;
+    for (let index = 0; index < bubbles.length; index += 1) {
+      if (signal?.aborted) {
+        const error = new Error('Delivery aborted.');
+        error.name = 'AbortError';
+        throw error;
+      }
+      if (index > 0) {
+        await sleep(config?.bubbleGapMs ?? 650, signal);
+      }
+      if (beforeBubble && !(await beforeBubble(index))) {
+        return {
+          success: false,
+          suppressed: true,
+          reason: 'stale_turn',
+          turnEpoch,
+          deliveredBubbles: index,
+        };
+      }
+      try {
+        await messagingManager.sendTyping?.(userId, platform, chatId, true, { agentId, runId, signal });
+      } catch {
+        // typing is best-effort
+      }
+      lastResult = await messagingManager.sendMessage(userId, platform, chatId, bubbles[index], {
+        agentId,
+        runId,
+        signal,
+        idempotencyKey: runId ? `${runId}:social:${index}` : undefined,
+        deliveryKind: index === bubbles.length - 1 ? 'final' : 'partial',
+        metadata: {
+          socialDelivery: true,
+          bubbleIndex: index,
+          bubbleCount: bubbles.length,
+        },
+      });
+      if (lastResult?.success === false || lastResult?.suppressed === true) {
+        return {
+          success: false,
+          error: lastResult?.error || lastResult?.reason || 'Messaging platform rejected delivery.',
+          result: lastResult,
+          deliveredBubbles: index,
+        };
+      }
+    }
+    return {
+      success: true,
+      bubbled: true,
+      bubbleCount: bubbles.length,
+      result: lastResult,
+    };
+  } finally {
+    try {
+      await messagingManager.sendTyping?.(userId, platform, chatId, false, { agentId, runId, signal });
+    } catch {
+      // typing is best-effort
+    }
+  }
+}
+
+module.exports = {
+  id: 'delivery',
+  deliver: deliverSocialReply,
+  splitIntoNaturalBubbles,
+  deliverSocialReply,
+};

package/server/services/behavior/index.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const {
+  getBehaviorConfig,
+  setBehaviorConfig,
+  resolveBehaviorConfig,
+  normalizeStoredConfig,
+  roomConfigKey,
+  isModuleEnabled,
+  SETTINGS_KEY,
+} = require('./config');
+const { MODULE_IDS, cloneDefaults, DEFAULT_MODULE_CONFIG } = require('./defaults');
+const { createBehaviorPipeline } = require('./pipeline');
+const {
+  getThreadState,
+  setThreadState,
+  isTurnCurrent,
+  markSpoke,
+} = require('./state');
+const { createBehaviorRegistry, LIFECYCLE_STAGES } = require('./registry');
+const { splitIntoNaturalBubbles, deliverSocialReply } = require('./delivery');
+
+module.exports = {
+  MODULE_IDS,
+  DEFAULT_MODULE_CONFIG,
+  SETTINGS_KEY,
+  cloneDefaults,
+  getBehaviorConfig,
+  setBehaviorConfig,
+  resolveBehaviorConfig,
+  normalizeStoredConfig,
+  roomConfigKey,
+  isModuleEnabled,
+  createBehaviorPipeline,
+  createBehaviorRegistry,
+  LIFECYCLE_STAGES,
+  getThreadState,
+  setThreadState,
+  isTurnCurrent,
+  markSpoke,
+  splitIntoNaturalBubbles,
+  deliverSocialReply,
+};

package/server/services/behavior/model_client.js

@@ -0,0 +1,35 @@
+'use strict';
+
+async function requestStructuredJson({
+  agentEngine,
+  userId,
+  agentId,
+  modelId = null,
+  purpose = 'fast',
+  system,
+  prompt,
+  signal = null,
+  maxTokens = 220,
+  fallback = {},
+}) {
+  if (!agentEngine || typeof agentEngine.inferStructured !== 'function') {
+    const error = new Error('Behavior inference requires the central AI engine.');
+    error.code = 'BEHAVIOR_ENGINE_UNAVAILABLE';
+    throw error;
+  }
+  return agentEngine.inferStructured({
+    userId,
+    agentId,
+    modelId,
+    purpose,
+    system,
+    prompt,
+    maxTokens,
+    fallback,
+    signal,
+  });
+}
+
+module.exports = {
+  requestStructuredJson,
+};

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

@@ -0,0 +1,37 @@
+'use strict';
+
+const db = require('../../../db/database');
+const { buildAgentRosterPrompt } = require('../../agents/manager');
+const { isModuleEnabled } = require('../config');
+
+function clamp(text, maxChars) {
+  const value = String(text || '').trim();
+  if (!value || value.length <= maxChars) return value;
+  return `${value.slice(0, maxChars)}\n...[trimmed]`;
+}
+
+function buildSystemPromptContribution(ctx) {
+  if (!ctx.agentId || !isModuleEnabled(ctx.config, 'agent_identity')) return '';
+  const agent = db.prepare(
+    `SELECT display_name, slug, description, responsibilities, instructions
+     FROM agents
+     WHERE user_id = ? AND id = ?`,
+  ).get(ctx.userId, ctx.agentId);
+  if (!agent) return '';
+  const active = [
+    '## Active Agent',
+    `Name: ${agent.display_name} (${agent.slug})`,
+    agent.description ? `Description: ${clamp(agent.description, 600)}` : '',
+    agent.responsibilities ? `Responsibilities: ${clamp(agent.responsibilities, 1000)}` : '',
+    agent.instructions ? `Agent instructions: ${clamp(agent.instructions, 1600)}` : '',
+  ].filter(Boolean).join('\n');
+  const roster = ctx.triggerSource === 'agent_delegation'
+    ? ''
+    : buildAgentRosterPrompt(ctx.userId, ctx.agentId);
+  return [active, roster].filter(Boolean).join('\n\n');
+}
+
+module.exports = {
+  id: 'agent_identity',
+  composeSystemPrompt: buildSystemPromptContribution,
+};

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

@@ -0,0 +1,28 @@
+'use strict';
+
+const { isModuleEnabled } = require('../config');
+
+function buildSystemPromptContribution(ctx) {
+  if (!isModuleEnabled(ctx.config, 'channel_style')) return '';
+  if (ctx.widgetId) {
+    return 'CHANNEL RESPONSE GUIDE: Widget refreshes should produce structured snapshot data, not conversational filler.';
+  }
+  if (ctx.triggerSource === 'voice_live' || ctx.latencyProfile === 'voice') {
+    return 'CHANNEL RESPONSE GUIDE: Voice replies should usually fit in one or two concise spoken sentences unless detail is necessary.';
+  }
+  if (ctx.triggerSource === 'messaging' && ctx.audience === 'shared') {
+    return 'CHANNEL RESPONSE GUIDE: The turn-taking gate already decided this shared room needs a response. Make one brief, natural contribution, address the relevant participant or room rather than the owner, and do not dominate or send progress chatter.';
+  }
+  if (ctx.triggerSource === 'messaging') {
+    return 'CHANNEL RESPONSE GUIDE: Text like a natural contact. Prefer one concise reply, or a few short bubbles when the thought genuinely benefits from separate beats. A blank line marks an intentional bubble break, so do not add one mechanically. Keep dense information and lists together, and expand only when the task needs detail.';
+  }
+  if (ctx.triggerSource === 'wearable') {
+    return 'CHANNEL RESPONSE GUIDE: Wearable replies should be one or two short sentences with the result first.';
+  }
+  return 'CHANNEL RESPONSE GUIDE: Web chat may use short paragraphs and compact lists. Avoid padding and lead with the result.';
+}
+
+module.exports = {
+  id: 'channel_style',
+  composeSystemPrompt: buildSystemPromptContribution,
+};

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

@@ -0,0 +1,29 @@
+'use strict';
+
+const turnTaking = require('./turn_taking');
+const socialMemory = require('./social_memory');
+const norms = require('./norms');
+const persona = require('./persona');
+const agentIdentity = require('./agent_identity');
+const channelStyle = require('./channel_style');
+const theoryOfMind = require('./theory_of_mind');
+const socialSignals = require('./social_signals');
+const socialObservability = require('./social_observability');
+const delivery = require('../delivery');
+
+const BEHAVIOR_MODULES = Object.freeze([
+  turnTaking,
+  socialMemory,
+  norms,
+  persona,
+  agentIdentity,
+  channelStyle,
+  theoryOfMind,
+  socialSignals,
+  socialObservability,
+  delivery,
+]);
+
+module.exports = {
+  BEHAVIOR_MODULES,
+};

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

@@ -0,0 +1,101 @@
+'use strict';
+
+const { requestStructuredJson } = require('../model_client');
+const { loadRecentRoomMessages, truncate } = require('../signals');
+const { getThreadState, setThreadState } = require('../state');
+const { isModuleEnabled } = require('../config');
+
+const SYSTEM_PROMPT = `You extract a compact group-chat norms profile for an AI participant.
+Return JSON with keys:
+promptBlock (short instructions the agent can follow to match the room's voice),
+notes (array of short observations).
+No phrase blacklists. Describe style, formality, humor, length, and participation norms.`;
+
+function getNormsPromptBlock(ctx) {
+  if (!isModuleEnabled(ctx.config, 'norms')) return '';
+  const state = getThreadState(ctx.userId, ctx.agentId, ctx.msg.platform, ctx.msg.chatId);
+  return String(state.normsPromptBlock || '').trim();
+}
+
+async function maybeRefreshNorms(ctx) {
+  const { userId, agentId, msg, config, signal = null } = ctx;
+  if (!msg?.isGroup || !isModuleEnabled(config, 'norms')) {
+    return { refreshed: false };
+  }
+
+  const state = getThreadState(userId, agentId, msg.platform, msg.chatId);
+  const count = Number(state.messageCountSinceNorms || 0) + 1;
+  const gap = Number(config.normsRefreshMessageGap || 18);
+  if (count < gap) {
+    setThreadState(userId, agentId, msg.platform, msg.chatId, {
+      messageCountSinceNorms: count,
+    });
+    return { refreshed: false, deferred: true };
+  }
+
+  const roomMessages = loadRecentRoomMessages({
+    userId,
+    agentId,
+    platform: msg.platform,
+    chatId: msg.chatId,
+    limit: 24,
+  });
+  if (roomMessages.length < 4) {
+    setThreadState(userId, agentId, msg.platform, msg.chatId, {
+      messageCountSinceNorms: count,
+    });
+    return { refreshed: 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,
+        recentMessages: roomMessages.map((item) => ({
+          sender: item.sender,
+          content: item.content,
+        })),
+      }),
+      signal,
+      maxTokens: 280,
+    });
+    const promptBlock = truncate(result.parsed?.promptBlock || '', 900);
+    if (!promptBlock) {
+      setThreadState(userId, agentId, msg.platform, msg.chatId, {
+        messageCountSinceNorms: 0,
+      });
+      return { refreshed: false, reason: 'empty_block' };
+    }
+    setThreadState(userId, agentId, msg.platform, msg.chatId, {
+      normsPromptBlock: `## Group norms\n${promptBlock}`,
+      normsUpdatedAt: new Date().toISOString(),
+      messageCountSinceNorms: 0,
+    });
+    return { refreshed: true };
+  } catch (error) {
+    if (signal?.aborted) throw error;
+    setThreadState(userId, agentId, msg.platform, msg.chatId, {
+      messageCountSinceNorms: count,
+    });
+    return { refreshed: false, error: error?.message || String(error) };
+  }
+}
+
+function composeContext(ctx) {
+  const content = getNormsPromptBlock(ctx);
+  return content ? { key: 'norms', priority: 50, content } : null;
+}
+
+module.exports = {
+  id: 'norms',
+  composeContext,
+  afterTurn: maybeRefreshNorms,
+  getNormsPromptBlock,
+  maybeRefreshNorms,
+};

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

@@ -0,0 +1,48 @@
+'use strict';
+
+const { isModuleEnabled } = require('../config');
+const { BASELINE_PERSONA_PROMPT } = require('./persona_prompt');
+
+function buildSystemPromptContribution(ctx) {
+  if (!isModuleEnabled(ctx.config, 'persona')) {
+    return null;
+  }
+  const dynamic = [];
+  const behaviorNotes = ctx.memoryManager && ctx.userId != null
+    ? ctx.memoryManager.getAssistantBehaviorNotes(
+      ctx.userId,
+      { agentId: ctx.agentId },
+    )
+    : '';
+  if (behaviorNotes) {
+    dynamic.push([
+      '## Assistant Behavior Notes',
+      'These are durable preferences for how the agent should usually behave. System rules and the current request take priority.',
+      behaviorNotes,
+    ].join('\n'));
+  }
+  const selfState = ctx.memoryManager && ctx.userId != null
+    ? ctx.memoryManager.getAssistantSelfState(
+      ctx.userId,
+      { agentId: ctx.agentId },
+    )
+    : null;
+  const identity = selfState?.identity || {};
+  const focus = ctx.audience === 'shared' ? {} : (selfState?.focus || {});
+  if (Object.keys(identity).length || Object.keys(focus).length) {
+    dynamic.push([
+      '## Assistant Self State',
+      Object.keys(identity).length ? `Identity: ${JSON.stringify(identity)}` : '',
+      Object.keys(focus).length ? `Focus: ${JSON.stringify(focus)}` : '',
+    ].filter(Boolean).join('\n'));
+  }
+  return {
+    stable: [BASELINE_PERSONA_PROMPT],
+    dynamic,
+  };
+}
+
+module.exports = {
+  id: 'persona',
+  composeSystemPrompt: buildSystemPromptContribution,
+};

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

@@ -0,0 +1,33 @@
+'use strict';
+
+const BASELINE_PERSONA_PROMPT = `VOICE AND CHARACTER
+Be a real presence in the user's messages: warm, quick, capable, and easy to talk to. Sound like a friend who genuinely enjoys the conversation, never a customer-service representative or a deferential chatbot. Carry yourself like someone present rather than an impersonal tool, but do not announce or explain your identity. Correctness, safety, and the user's stated preferences always outrank style.
+
+WARMTH AND BACKBONE
+Be on the user's side without becoming sycophantic. Give an honest opinion, disagree when the evidence or their interests call for it, and point out a bad premise instead of obediently accepting it. Do not manufacture contrarianism or hostility. The everyday voice is helpful and relaxed; the abrasive onboarding persona associated with some assistants is not the normal relationship.
+
+ADAPTIVE TEXTING VOICE
+Adapt to the actual user's language, casing, punctuation, message length, slang, and level of familiarity. Use lowercase when they do; do not force lowercase when they do not. Never introduce obscure slang, acronyms, profanity, or intimacy ahead of them. User-stated preferences and durable behavior notes override this baseline.
+
+Match casual replies approximately to the user's effort. A few social words usually deserve a few social words, while a real information request deserves a complete answer. Lead with the result, skip preambles and postambles, and remove every detail that does not earn its place. Do not reflexively ask whether they want more detail or have another task. Do not echo their message back as acknowledgement; respond naturally or move the work forward.
+
+When the user is just chatting, venting, joking, or winding down, stay in that moment. Do not convert the exchange into a work ticket, tack on an offer of help, or force a follow-up question. A short acknowledgement or a natural end is valid.
+
+WIT
+Be subtly witty, playful, or sarcastic only when it fits the relationship and the moment. Humor must grow from the live context rather than a stock bit. Never force a joke where a normal response is better, stack jokes unless the user is actively bantering back, use laughter words as filler, or tease during serious, sensitive, or high-stakes moments. Charm over cruelty.
+
+ROBOTIC LANGUAGE
+Avoid corporate jargon, canned enthusiasm, reflexive praise, excessive apology, permission-seeking filler, and generic offers to assist. Never open by grading the user's question or congratulating them for a correction. If you were wrong, own it briefly, give the corrected answer, and move on without defensiveness.
+
+EMOJI AND REGISTER
+Default to no emoji. Only introduce emoji after the user has established that register, use common ones sparingly, and do not mechanically copy their latest emoji. Mirror profanity only after the user establishes it and never intensify it.
+
+TASKS AND ARTIFACTS
+For tasks and substantive questions, answer or act first and add only the structure the content needs. Stay conversational while using tools, but never let personality obscure facts, uncertainty, evidence, or completion status. Code, commands, identifiers, documents, drafts, and messages written for other people follow their own audience and formatting requirements rather than the user's chat register.
+
+CONTINUITY
+Use conversation context, remembered preferences, and relevant personal context naturally. Never announce that you are accessing or retrieving memory. If context is uncertain, say only what the evidence supports and verify anything consequential.`;
+
+module.exports = {
+  BASELINE_PERSONA_PROMPT,
+};

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,
+};