neoagent 3.2.1-beta.9 → 3.3.0

package/server/services/ai/tools.js

@@ -12,7 +12,6 @@ const {
     normalizeOutgoingMessageForPlatform,
 } = require('../messaging/formatting_guides');
 const { INTERIM_KINDS, normalizeInterimKind } = require('./interim');
-const { isDeferredWorkReply } = require('./terminal_reply');
 const { normalizeWhatsAppId } = require('../../utils/whatsapp');
 const {
     executeIntegratedTool,
@@ -2401,6 +2400,13 @@ async function executeTool(toolName, args, context, engine) {
             if (!engine || !runId) {
                 return { error: 'Interim updates require an active run.' };
             }
+            if (engine.getRunMeta(runId)?.messagingContext?.behavior?.isGroup === true) {
+                return {
+                    sent: false,
+                    skipped: true,
+                    reason: 'Interim progress updates are suppressed in shared rooms.',
+                };
+            }
             const interimContent = typeof args.content === 'string' ? args.content : '';
             const expectsReply = args.expects_reply === true;
             const deferFollowUp = args.defer_follow_up === true;
@@ -2438,16 +2444,6 @@ async function executeTool(toolName, args, context, engine) {
                 platform: args.platform,
                 to: args.to,
             });
-            if (
-                !suppressReply
-                && triggerSource === 'messaging'
-                && originDelivery
-                && isDeferredWorkReply(normalizedMessage)
-            ) {
-                return {
-                    error: 'send_message cannot end the run with a promise or progress-only reply. Continue the work, or use send_interim_update for a factual interim update.',
-                };
-            }
             if (isProactiveTrigger(triggerSource)) {
                 const proactiveValidation = validateProactiveSendMessageArgs({
                     purpose: args.purpose,
@@ -2506,13 +2502,58 @@ async function executeTool(toolName, args, context, engine) {
             if (triggerSource === 'messaging' && originDelivery) {
                 await engine?.stopMessagingProgressSupervisor?.(runId);
             }
-            const sendResult = await manager.sendMessage(userId, args.platform, args.to, args.content, {
-                agentId,
-                mediaPath: args.media_path,
-                runId,
-                persistConversation: triggerSource === 'schedule' || triggerSource === 'tasks',
-                signal,
-            });
+            const behavior = runState?.messagingContext?.behavior;
+            const behaviorPipeline = app?.locals?.behaviorPipeline;
+            let deliveredContent = normalizedMessage;
+            let sendResult;
+            if (
+                originDelivery
+                && behavior
+                && behavior.enabled !== false
+                && behaviorPipeline
+                && typeof behaviorPipeline.refineAndMaybeDeliver === 'function'
+            ) {
+                const behaviorResult = await behaviorPipeline.refineAndMaybeDeliver({
+                    userId,
+                    agentId,
+                    msg: behavior.message,
+                    config: behavior.config,
+                    draft: normalizedMessage,
+                    messagingManager: manager,
+                    runId,
+                    signal,
+                    mediaPath: args.media_path,
+                    turnEpoch: behavior.turnEpoch,
+                    deliver: true,
+                });
+                deliveredContent = behaviorResult.content;
+                if (behaviorResult.delivered) {
+                    sendResult = { success: true, behavior: true, result: behaviorResult.delivery };
+                } else if (behaviorResult.suppressed) {
+                    markProactiveNoResponse({ runState, deliveryState });
+                    sendResult = {
+                        success: true,
+                        sent: false,
+                        suppressed: true,
+                        reason: behaviorResult.reasonCodes?.[0] || 'behavior_suppressed',
+                    };
+                } else {
+                    sendResult = {
+                        success: false,
+                        error: behaviorResult.delivery?.error
+                            || behaviorResult.delivery?.reason
+                            || 'Behavior delivery was not confirmed.',
+                    };
+                }
+            } else {
+                sendResult = await manager.sendMessage(userId, args.platform, args.to, args.content, {
+                    agentId,
+                    mediaPath: args.media_path,
+                    runId,
+                    persistConversation: triggerSource === 'schedule' || triggerSource === 'tasks',
+                    signal,
+                });
+            }
             // Track that the agent explicitly sent a message during this run
             if (
                 !suppressReply
@@ -2520,7 +2561,7 @@ async function executeTool(toolName, args, context, engine) {
                 && sendResult?.suppressed !== true
                 && originDelivery
             ) {
-                markProactiveMessageSent({ runState, deliveryState, content: normalizedMessage });
+                markProactiveMessageSent({ runState, deliveryState, content: deliveredContent });
                 if (runState && triggerSource === 'messaging') {
                     runState.explicitMessageSent = true;
                 }

package/server/services/behavior/config.js

@@ -0,0 +1,251 @@
+'use strict';
+
+const db = require('../../db/database');
+const { isMainAgent } = require('../agents/manager');
+const { MODULE_IDS, cloneDefaults, DEFAULT_MODULE_CONFIG } = require('./defaults');
+
+const SETTINGS_KEY = 'behavior_modules_config';
+const PARTICIPATION_MODES = new Set(['automatic', 'mention_only', 'always']);
+const MODEL_PURPOSES = new Set(['fast', 'general']);
+const DELIVERY_STYLES = new Set(['single', 'natural_bubbles']);
+
+function clampNumber(value, min, max, fallback) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) return fallback;
+  return Math.min(max, Math.max(min, number));
+}
+
+function asObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function normalizeModules(rawModules, fallbackEnabled = true, sparse = false) {
+  const source = asObject(rawModules);
+  const modules = {};
+  for (const id of MODULE_IDS) {
+    if (sparse && !Object.prototype.hasOwnProperty.call(source, id)) continue;
+    const entry = asObject(source[id]);
+    modules[id] = {
+      enabled: entry.enabled == null ? fallbackEnabled : entry.enabled !== false,
+    };
+  }
+  return modules;
+}
+
+function normalizeOptionalString(value, fallback = null) {
+  if (value == null) return fallback;
+  const normalized = String(value).trim();
+  return normalized || null;
+}
+
+function normalizeLeafConfig(raw = {}, base = cloneDefaults(), sparse = false) {
+  const input = asObject(raw);
+  const output = {};
+  const assign = (key, value) => {
+    if (!sparse || Object.prototype.hasOwnProperty.call(input, key)) output[key] = value;
+  };
+  const enabled = input.enabled == null ? base.enabled !== false : input.enabled !== false;
+  assign('enabled', enabled);
+  if (!sparse || Object.prototype.hasOwnProperty.call(input, 'modules')) {
+    output.modules = normalizeModules(input.modules, enabled, sparse);
+  }
+  assign(
+    'participationMode',
+    PARTICIPATION_MODES.has(String(input.participationMode || ''))
+      ? String(input.participationMode)
+      : (base.participationMode || DEFAULT_MODULE_CONFIG.participationMode),
+  );
+  assign('minimumNeedScore', clampNumber(
+    input.minimumNeedScore,
+    0,
+    1,
+    base.minimumNeedScore ?? DEFAULT_MODULE_CONFIG.minimumNeedScore,
+  ));
+  assign('batchWindowMs', Math.round(clampNumber(
+    input.batchWindowMs,
+    0,
+    5000,
+    base.batchWindowMs ?? DEFAULT_MODULE_CONFIG.batchWindowMs,
+  )));
+  assign('decisionContextMessageLimit', Math.round(clampNumber(
+    input.decisionContextMessageLimit,
+    4,
+    30,
+    base.decisionContextMessageLimit ?? DEFAULT_MODULE_CONFIG.decisionContextMessageLimit,
+  )));
+  assign(
+    'decisionModelId',
+    normalizeOptionalString(input.decisionModelId, base.decisionModelId || null),
+  );
+  assign(
+    'decisionModelPurpose',
+    MODEL_PURPOSES.has(String(input.decisionModelPurpose || ''))
+      ? String(input.decisionModelPurpose)
+      : (base.decisionModelPurpose || DEFAULT_MODULE_CONFIG.decisionModelPurpose),
+  );
+  assign(
+    'deliveryStyle',
+    DELIVERY_STYLES.has(String(input.deliveryStyle || ''))
+      ? String(input.deliveryStyle)
+      : (base.deliveryStyle || DEFAULT_MODULE_CONFIG.deliveryStyle),
+  );
+  assign('maxBubbles', Math.round(clampNumber(
+    input.maxBubbles,
+    1,
+    5,
+    base.maxBubbles ?? DEFAULT_MODULE_CONFIG.maxBubbles,
+  )));
+  assign('bubbleGapMs', Math.round(clampNumber(
+    input.bubbleGapMs,
+    0,
+    5000,
+    base.bubbleGapMs ?? DEFAULT_MODULE_CONFIG.bubbleGapMs,
+  )));
+  assign('normsRefreshMessageGap', Math.round(clampNumber(
+    input.normsRefreshMessageGap,
+    3,
+    200,
+    base.normsRefreshMessageGap ?? DEFAULT_MODULE_CONFIG.normsRefreshMessageGap,
+  )));
+  assign('observabilityIntervalMinutes', Math.round(clampNumber(
+    input.observabilityIntervalMinutes,
+    30,
+    10080,
+    base.observabilityIntervalMinutes ?? DEFAULT_MODULE_CONFIG.observabilityIntervalMinutes,
+  )));
+  return output;
+}
+
+function normalizeStoredConfig(raw) {
+  const base = cloneDefaults();
+  const input = asObject(raw);
+  const normalized = {
+    schemaVersion: DEFAULT_MODULE_CONFIG.schemaVersion,
+    ...normalizeLeafConfig(input, base),
+  };
+  const platformOverrides = {};
+  for (const [platform, value] of Object.entries(asObject(input.platformOverrides))) {
+    const key = String(platform || '').trim();
+    if (!key) continue;
+    platformOverrides[key] = normalizeLeafConfig(value, normalized, true);
+  }
+  const roomOverrides = {};
+  const rawRoomOverrides = Object.keys(asObject(input.roomOverrides)).length
+    ? asObject(input.roomOverrides)
+    : asObject(input.groupOverrides);
+  for (const [roomKey, value] of Object.entries(rawRoomOverrides)) {
+    const key = String(roomKey || '').trim();
+    if (!key) continue;
+    roomOverrides[key] = normalizeLeafConfig(value, normalized, true);
+  }
+  return {
+    ...normalized,
+    platformOverrides,
+    roomOverrides,
+  };
+}
+
+function readSettingRow(userId, agentId) {
+  const row = db.prepare(
+    'SELECT value FROM agent_settings WHERE user_id = ? AND agent_id = ? AND key = ?',
+  ).get(userId, agentId, SETTINGS_KEY);
+  if (row?.value != null) return row.value;
+  if (isMainAgent(userId, agentId)) {
+    const legacy = db.prepare(
+      'SELECT value FROM user_settings WHERE user_id = ? AND key = ?',
+    ).get(userId, SETTINGS_KEY);
+    return legacy?.value;
+  }
+  return null;
+}
+
+function parseStoredValue(value) {
+  if (value == null || value === '') return cloneDefaults();
+  if (typeof value === 'object') return normalizeStoredConfig(value);
+  try {
+    return normalizeStoredConfig(JSON.parse(value));
+  } catch {
+    return cloneDefaults();
+  }
+}
+
+function getBehaviorConfig(userId, agentId = null) {
+  return parseStoredValue(readSettingRow(userId, agentId));
+}
+
+function setBehaviorConfig(userId, agentId, config) {
+  const normalized = normalizeStoredConfig(config);
+  db.prepare(
+    `INSERT INTO agent_settings (user_id, agent_id, key, value)
+     VALUES (?, ?, ?, ?)
+     ON CONFLICT(user_id, agent_id, key) DO UPDATE SET value = excluded.value`,
+  ).run(userId, agentId, SETTINGS_KEY, JSON.stringify(normalized));
+  return normalized;
+}
+
+function roomConfigKey(platform, chatId) {
+  return `${String(platform || '').trim()}::${String(chatId || '').trim()}`;
+}
+
+function mergeConfigs(base, override) {
+  if (!override) return base;
+  return {
+    ...base,
+    ...override,
+    modules: {
+      ...asObject(base.modules),
+      ...asObject(override.modules),
+    },
+  };
+}
+
+function resolveBehaviorConfig(userId, agentId, { platform = null, chatId = null, isGroup = false } = {}) {
+  const storedValue = readSettingRow(userId, agentId);
+  const stored = parseStoredValue(storedValue);
+  let effective = normalizeLeafConfig(stored, cloneDefaults());
+  let participationModeSource = storedValue == null ? 'default' : 'agent';
+  const platformKey = String(platform || '').trim();
+  if (platformKey && stored.platformOverrides?.[platformKey]) {
+    effective = mergeConfigs(effective, stored.platformOverrides[platformKey]);
+    if (Object.prototype.hasOwnProperty.call(stored.platformOverrides[platformKey], 'participationMode')) {
+      participationModeSource = 'platform';
+    }
+  }
+  if (isGroup && platformKey && chatId) {
+    const key = roomConfigKey(platformKey, chatId);
+    if (stored.roomOverrides?.[key]) {
+      effective = mergeConfigs(effective, stored.roomOverrides[key]);
+      if (Object.prototype.hasOwnProperty.call(stored.roomOverrides[key], 'participationMode')) {
+        participationModeSource = 'room';
+      }
+    }
+  }
+  effective.modules = normalizeModules(effective.modules, effective.enabled !== false);
+  effective.platformOverrides = stored.platformOverrides || {};
+  effective.roomOverrides = stored.roomOverrides || {};
+  effective.participationModeSource = participationModeSource;
+  effective.scope = {
+    platform: platformKey || null,
+    chatId: chatId ? String(chatId) : null,
+    isGroup: Boolean(isGroup),
+    roomKey: isGroup && platformKey && chatId ? roomConfigKey(platformKey, chatId) : null,
+  };
+  return effective;
+}
+
+function isModuleEnabled(config, moduleId) {
+  if (!config || config.enabled === false) return false;
+  const entry = config.modules?.[moduleId];
+  if (!entry) return false;
+  return entry.enabled !== false;
+}
+
+module.exports = {
+  SETTINGS_KEY,
+  getBehaviorConfig,
+  setBehaviorConfig,
+  resolveBehaviorConfig,
+  normalizeStoredConfig,
+  roomConfigKey,
+  isModuleEnabled,
+};

package/server/services/behavior/defaults.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const MODULE_IDS = Object.freeze([
+  'turn_taking',
+  'social_memory',
+  'norms',
+  'persona',
+  'agent_identity',
+  'channel_style',
+  'theory_of_mind',
+  'social_signals',
+  'social_observability',
+  'delivery',
+]);
+
+const DEFAULT_MODULE_CONFIG = Object.freeze({
+  schemaVersion: 1,
+  enabled: true,
+  participationMode: 'automatic',
+  minimumNeedScore: 0.72,
+  batchWindowMs: 900,
+  decisionContextMessageLimit: 12,
+  decisionModelId: null,
+  decisionModelPurpose: 'general',
+  deliveryStyle: 'natural_bubbles',
+  maxBubbles: 4,
+  bubbleGapMs: 650,
+  normsRefreshMessageGap: 18,
+  observabilityIntervalMinutes: 360,
+});
+
+function cloneDefaults() {
+  return {
+    schemaVersion: DEFAULT_MODULE_CONFIG.schemaVersion,
+    enabled: DEFAULT_MODULE_CONFIG.enabled,
+    modules: {
+      turn_taking: { enabled: true },
+      social_memory: { enabled: true },
+      norms: { enabled: true },
+      persona: { enabled: true },
+      agent_identity: { enabled: true },
+      channel_style: { enabled: true },
+      theory_of_mind: { enabled: true },
+      social_signals: { enabled: true },
+      social_observability: { enabled: true },
+      delivery: { enabled: true },
+    },
+    participationMode: DEFAULT_MODULE_CONFIG.participationMode,
+    minimumNeedScore: DEFAULT_MODULE_CONFIG.minimumNeedScore,
+    batchWindowMs: DEFAULT_MODULE_CONFIG.batchWindowMs,
+    decisionContextMessageLimit: DEFAULT_MODULE_CONFIG.decisionContextMessageLimit,
+    decisionModelId: DEFAULT_MODULE_CONFIG.decisionModelId,
+    decisionModelPurpose: DEFAULT_MODULE_CONFIG.decisionModelPurpose,
+    deliveryStyle: DEFAULT_MODULE_CONFIG.deliveryStyle,
+    maxBubbles: DEFAULT_MODULE_CONFIG.maxBubbles,
+    bubbleGapMs: DEFAULT_MODULE_CONFIG.bubbleGapMs,
+    normsRefreshMessageGap: DEFAULT_MODULE_CONFIG.normsRefreshMessageGap,
+    observabilityIntervalMinutes: DEFAULT_MODULE_CONFIG.observabilityIntervalMinutes,
+    platformOverrides: {},
+    roomOverrides: {},
+  };
+}
+
+module.exports = {
+  MODULE_IDS,
+  DEFAULT_MODULE_CONFIG,
+  cloneDefaults,
+};

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