Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

14.3 KB
Raw Blame
/**
 * Agent & social-automation Zod schemas (split out of validation.js, issue #1831).
 *
 * Covers the autonomous social-bot agent domain — agent personality, Moltbook/
 * Moltworld platform accounts, automation schedules, the agent posting/engage
 * tools, the Moltworld tool + websocket payloads — plus the CoS Feature Agent
 * definitions. validation.js re-exports everything here (flat) so existing deep
 * `import { x } from '../lib/validation.js'` callsites keep working; the barrel
 * surfaces it as the `agentValidation` namespace.
 */
import { z } from 'zod';
import { partialWithoutDefaults } from './zodCompat.js';
import { EFFORT_LEVELS } from './providerModels.js';

// =============================================================================
// AGENT PERSONALITY SCHEMAS
// =============================================================================

// Agent personality style
export const personalityStyleSchema = z.enum([
  'professional',
  'casual',
  'witty',
  'academic',
  'creative'
]);

// Agent personality object
export const agentPersonalitySchema = z.object({
  style: personalityStyleSchema,
  tone: z.string().max(500).optional().default(''),
  topics: z.array(z.string().max(100)).default([]),
  quirks: z.array(z.string().max(200)).default([]),
  promptPrefix: z.string().max(2000).optional().default('')
});

// Agent avatar
export const agentAvatarSchema = z.object({
  imageUrl: z.string().url().optional(),
  emoji: z.string().max(10).optional(),
  color: z.string().regex(/^#[0-9A-Fa-f]{6}$/).optional()
}).optional();

// Per-function AI provider/model override
const aiFunctionConfigSchema = z.object({
  providerId: z.string().min(1).optional(),
  model: z.string().min(1).optional()
});

// Agent AI config (preferred provider/model, with optional per-function overrides)
export const agentAiConfigSchema = z.object({
  providerId: z.string().min(1).optional(),
  model: z.string().min(1).optional(),
  content: aiFunctionConfigSchema.optional(),
  engagement: aiFunctionConfigSchema.optional(),
  challenge: aiFunctionConfigSchema.optional()
}).optional();

// Full agent schema
export const agentSchema = z.object({
  userId: z.string().min(1).max(100),
  name: z.string().min(1).max(100),
  description: z.string().max(1000).optional().default(''),
  personality: agentPersonalitySchema,
  avatar: agentAvatarSchema,
  enabled: z.boolean().default(true),
  aiConfig: agentAiConfigSchema
});

// partialWithoutDefaults handles the top-level fields; the nested `personality`
// object is also field-merged by updateAgent(), so it needs its own default-free
// partial — otherwise a PATCH of one personality key (e.g. just `style`) injects
// the other keys' defaults and clobbers the stored tone/topics/quirks/promptPrefix.
export const agentUpdateSchema = partialWithoutDefaults(agentSchema).extend({
  personality: partialWithoutDefaults(agentPersonalitySchema).optional(),
});

// Request body for AI personality generation. Reuse the create shape so seed
// text has the same bounds as a persisted personality before it reaches a
// provider prompt.
export const agentGenerateSchema = z.object({
  seed: agentSchema.partial().extend({
    // A blank form asks the generator to invent the name; only persisted
    // personalities require a non-empty name.
    name: z.string().max(100).optional(),
    personality: partialWithoutDefaults(agentPersonalitySchema).optional(),
  }).optional().default({}),
  providerId: z.string().min(1).max(128).nullable().optional(),
  model: z.string().min(1).max(300).nullable().optional()
}).strict();

// Toggle is a separate write contract: unlike a partial agent update, enabled
// is required and must remain a boolean all the way to storage.
export const agentToggleSchema = z.object({
  enabled: z.boolean()
}).strict();

// =============================================================================
// PLATFORM ACCOUNT SCHEMAS
// =============================================================================

export const platformTypeSchema = z.enum(['moltbook', 'moltworld']);

export const accountCredentialsSchema = z.object({
  apiKey: z.string().min(1),
  username: z.string().min(1).max(100),
  agentId: z.string().min(1).optional()    // Moltworld-specific agent ID
});

export const accountStatusSchema = z.enum(['active', 'pending', 'suspended', 'error']);

export const platformAccountSchema = z.object({
  agentId: z.string().min(1),
  platform: platformTypeSchema,
  credentials: accountCredentialsSchema,
  status: accountStatusSchema.default('pending'),
  platformData: z.record(z.unknown()).optional().default({})
});

// Account registration (when creating new Moltbook account)
export const accountRegistrationSchema = z.object({
  agentId: z.string().min(1),
  platform: platformTypeSchema,
  name: z.string().min(1).max(100),
  description: z.string().max(500).optional().default('')
});

// =============================================================================
// AUTOMATION SCHEDULE SCHEMAS
// =============================================================================

export const scheduleActionTypeSchema = z.enum([
  'post', 'comment', 'vote', 'heartbeat', 'engage', 'monitor',
  'mw_explore', 'mw_build', 'mw_say', 'mw_think', 'mw_heartbeat', 'mw_interact'
]);

export const scheduleActionSchema = z.object({
  type: scheduleActionTypeSchema,
  params: z.record(z.unknown()).optional().default({})
});

export const scheduleTypeSchema = z.enum(['cron', 'interval', 'random']);

export const scheduleTimingSchema = z.object({
  type: scheduleTypeSchema,
  cron: z.string().optional(),
  intervalMs: z.number().int().min(1000).optional(),
  randomWindow: z.object({
    minMs: z.number().int().min(1000),
    maxMs: z.number().int().min(1000)
  }).optional(),
  rolledIntervalMs: z.number().nullable().optional()
}).refine(
  (data) => {
    if (data.type === 'cron') return !!data.cron;
    if (data.type === 'interval') return !!data.intervalMs;
    if (data.type === 'random') return !!data.randomWindow;
    return false;
  },
  { message: 'Schedule timing must match its type' }
);

export const scheduleRateLimitSchema = z.object({
  maxPerDay: z.number().int().min(1).optional(),
  cooldownMs: z.number().int().min(0).optional()
}).optional();

export const automationScheduleSchema = z.object({
  agentId: z.string().min(1),
  accountId: z.string().min(1),
  action: scheduleActionSchema,
  schedule: scheduleTimingSchema,
  rateLimit: scheduleRateLimitSchema,
  enabled: z.boolean().default(true),
  rolledIntervalMs: z.number().nullable().optional()
});

export const automationScheduleUpdateSchema = partialWithoutDefaults(automationScheduleSchema);

// =============================================================================
// AGENT TOOLS SCHEMAS
// =============================================================================

export const generatePostSchema = z.object({
  agentId: z.string().min(1),
  accountId: z.string().min(1),
  submolt: z.string().max(100).optional(),
  providerId: z.string().optional(),
  model: z.string().optional()
});

export const generateCommentSchema = z.object({
  agentId: z.string().min(1),
  accountId: z.string().min(1),
  postId: z.string().min(1),
  parentId: z.string().optional(),
  providerId: z.string().optional(),
  model: z.string().optional()
});

export const publishPostSchema = z.object({
  agentId: z.string().min(1),
  accountId: z.string().min(1),
  submolt: z.string().min(1).max(100),
  title: z.string().min(1).max(300),
  content: z.string().min(1).max(10000)
});

export const publishCommentSchema = z.object({
  agentId: z.string().min(1),
  accountId: z.string().min(1),
  postId: z.string().min(1),
  content: z.string().min(1).max(5000),
  parentId: z.string().optional()
});

export const engageSchema = z.object({
  agentId: z.string().min(1),
  accountId: z.string().min(1),
  maxComments: z.number().int().min(0).max(5).optional().default(1),
  maxVotes: z.number().int().min(0).max(10).optional().default(3)
});

export const checkPostsSchema = z.object({
  agentId: z.string().min(1),
  accountId: z.string().min(1),
  days: z.number().int().min(1).max(30).optional().default(7),
  maxReplies: z.number().int().min(0).max(5).optional().default(2),
  maxUpvotes: z.number().int().min(0).max(20).optional().default(10)
});

export const createDraftSchema = z.object({
  agentId: z.string().min(1),
  type: z.enum(['post', 'comment']),
  title: z.string().max(300).optional().nullable(),
  content: z.string().min(1).max(10000),
  submolt: z.string().max(100).optional().nullable(),
  postId: z.string().optional().nullable(),
  parentId: z.string().optional().nullable(),
  postTitle: z.string().max(300).optional().nullable(),
  accountId: z.string().optional().nullable()
});

export const updateDraftSchema = z.object({
  title: z.string().max(300).optional().nullable(),
  content: z.string().min(1).max(10000).optional(),
  submolt: z.string().max(100).optional().nullable(),
  status: z.enum(['draft', 'published']).optional(),
  publishedPostId: z.string().optional().nullable(),
  publishedAt: z.string().optional().nullable()
});

// =============================================================================
// MOLTWORLD TOOL SCHEMAS
// =============================================================================

export const moltworldJoinSchema = z.object({
  accountId: z.string().min(1),
  agentId: z.string().min(1).optional(),
  x: z.number().int().min(-240).max(240).optional(),
  y: z.number().int().min(-240).max(240).optional(),
  thinking: z.string().max(500).optional(),
  say: z.string().max(500).optional(),
  sayTo: z.string().optional()
});

export const moltworldBuildSchema = z.object({
  accountId: z.string().min(1),
  agentId: z.string().min(1).optional(),
  x: z.number().int().min(-500).max(500),
  y: z.number().int().min(-500).max(500),
  z: z.number().int().min(0).max(100),
  type: z.enum(['wood', 'stone', 'dirt', 'grass', 'leaves']).optional().default('stone'),
  action: z.enum(['place', 'remove']).optional().default('place')
});

export const moltworldExploreSchema = z.object({
  accountId: z.string().min(1),
  agentId: z.string().min(1).optional(),
  x: z.number().int().min(-240).max(240).optional(),
  y: z.number().int().min(-240).max(240).optional(),
  thinking: z.string().max(500).optional()
});

export const moltworldThinkSchema = z.object({
  accountId: z.string().min(1),
  agentId: z.string().min(1).optional(),
  thought: z.string().min(1).max(500)
});

export const moltworldSaySchema = z.object({
  accountId: z.string().min(1),
  agentId: z.string().min(1).optional(),
  message: z.string().min(1).max(500),
  sayTo: z.string().optional()
});

// =============================================================================
// MOLTWORLD WEBSOCKET SCHEMAS
// =============================================================================

export const moltworldWsConnectSchema = z.object({
  accountId: z.string().min(1)
});

export const moltworldWsMoveSchema = z.object({
  x: z.number().int().min(-240).max(240),
  y: z.number().int().min(-240).max(240),
  thought: z.string().max(500).optional()
});

export const moltworldWsThinkSchema = z.object({
  thought: z.string().min(1).max(500)
});

export const moltworldWsNearbySchema = z.object({
  radius: z.number().int().min(1).max(500).optional()
});

export const moltworldWsInteractSchema = z.object({
  to: z.string().min(1),
  payload: z.record(z.unknown()).optional().default({})
});

export const moltworldQueueActionTypeSchema = z.enum([
  'mw_explore', 'mw_build', 'mw_say', 'mw_think', 'mw_heartbeat', 'mw_interact'
]);

export const moltworldQueueAddSchema = z.object({
  agentId: z.string().min(1),
  actionType: moltworldQueueActionTypeSchema,
  params: z.record(z.unknown()).optional().default({}),
  scheduledFor: z.string().datetime().optional().nullable()
});

// =============================================================================
// FEATURE AGENT SCHEMAS
// =============================================================================

// A feature agent's `status` is server-owned — stamped by the start/pause/
// complete routes, never accepted from a request body — so it has no request
// schema (#5730).
export const featureAgentScheduleModeSchema = z.enum(['continuous', 'interval']);
export const featureAgentAutonomySchema = z.enum(['standby', 'assistant', 'manager', 'yolo']);
export const featureAgentPrioritySchema = z.enum(['LOW', 'MEDIUM', 'HIGH', 'CRITICAL']);

export const featureAgentSchema = z.object({
  name: z.string().min(1).max(200),
  description: z.string().min(1).max(2000),
  persona: z.string().max(5000).optional().default(''),
  appId: z.string().min(1),
  // .prefault({}) (not .default({})) so the nested field defaults still apply
  // when `schedule` is omitted — Zod 4's .default() no longer re-parses its
  // value, so a bare .default({}) would yield {} instead of the filled object.
  schedule: z.object({
    mode: featureAgentScheduleModeSchema.default('continuous'),
    intervalMs: z.number().int().min(30000).optional(),
    pauseBetweenRunsMs: z.number().int().min(0).default(60000)
  }).prefault({}),
  goals: z.array(z.string()).default([]),
  constraints: z.array(z.string()).default([]),
  providerId: z.string().optional().nullable(),
  model: z.string().optional().nullable(),
  effort: z.preprocess((value) => (value === '' ? undefined : value), z.enum(EFFORT_LEVELS).nullable().optional()),
  autonomyLevel: featureAgentAutonomySchema.default('assistant'),
  priority: featureAgentPrioritySchema.default('MEDIUM')
});

// Update schema: all fields optional, no defaults (prevents overwriting existing values)
export const featureAgentUpdateSchema = z.object({
  name: z.string().min(1).max(200).optional(),
  description: z.string().min(1).max(2000).optional(),
  persona: z.string().max(5000).optional(),
  appId: z.string().min(1).optional(),
  schedule: z.object({
    mode: featureAgentScheduleModeSchema.optional(),
    intervalMs: z.number().int().min(30000).optional(),
    pauseBetweenRunsMs: z.number().int().min(0).optional()
  }).optional(),
  goals: z.array(z.string()).optional(),
  constraints: z.array(z.string()).optional(),
  providerId: z.string().optional().nullable(),
  model: z.string().optional().nullable(),
  effort: z.preprocess((value) => (value === '' ? undefined : value), z.enum(EFFORT_LEVELS).nullable().optional()),
  autonomyLevel: featureAgentAutonomySchema.optional(),
  priority: featureAgentPrioritySchema.optional()
});