@mxf-dev/core 1.0.0

package/dist/schemas/EventPayloadSchema.js

@@ -0,0 +1,2049 @@
+/**
+ * Copyright 2024 Brad Anderson
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @author Brad Anderson <BradA1878@pm.me>
+ * @repository https://github.com/mxf-dev/mxf
+ * @documentation https://mxf-dev.github.io/mxf/
+ */
+import { v4 as uuidv4 } from 'uuid';
+import { createStrictValidator } from '../utils/validation.js';
+import { MemoryScope } from '../types/MemoryTypes.js';
+import { Logger } from '../utils/Logger.js';
+import { OrparMemoryEvents } from '../events/event-definitions/OrparMemoryEvents.js';
+import { DagEvents, } from '../events/event-definitions/DagEvents.js';
+import { TensorFlowEvents, } from '../events/event-definitions/TensorFlowEvents.js';
+import { UserInputEvents, } from '../events/event-definitions/UserInputEvents.js';
+import { CompactionEvents, } from '../events/event-definitions/CompactionEvents.js';
+// Create logger instance for event payload schema
+const logger = new Logger('warn', 'EventPayloadSchema', 'server');
+/** Agent ID for system-level events not tied to a specific agent (e.g., MxfMLService, PredictiveAnalyticsService) */
+export const SYSTEM_AGENT_ID = 'system';
+/** Channel ID for system-level events not tied to a specific channel */
+export const SYSTEM_CHANNEL_ID = 'system';
+// --- Helper Functions ---
+/**
+ * Creates a standardized base event payload.
+ * This is the core function for generating all event payloads in the system.
+ *
+ * @param eventType - The specific type of event (e.g., Events.ControlLoop.INITIALIZE).
+ * @param agentId - ID of the agent primarily associated with this event.
+ * @param channelId - ID of the channel primarily associated with this event.
+ * @param data - The event-specific data.
+ * @param options - Optional parameters like source, recursion protection, or overrides for eventId and timestamp.
+ * @returns A fully formed BaseEventPayload.
+ */
+export function createBaseEventPayload(eventType, agentId, channelId, data, options = {}) {
+    const validator = createStrictValidator('createBaseEventPayload');
+    validator.assertIsNonEmptyString(eventType, 'eventType');
+    validator.assertIsNonEmptyString(agentId, 'agentId');
+    validator.assertIsNonEmptyString(channelId, 'channelId'); // Enforcing channelId as per requirement
+    // data can be anything, so no generic validation here, specific helpers can validate their data.
+    return {
+        eventId: options.eventId || uuidv4(),
+        eventType,
+        timestamp: options.timestamp || Date.now(),
+        agentId,
+        channelId,
+        source: options.source,
+        isRecursionProtection: options.isRecursionProtection,
+        data,
+    };
+}
+// --- Specific Event Payload Creator Helpers ---
+/**
+ * Creates a ConnectionEventPayload.
+ * @param eventType - The specific connection event type (e.g., Events.Agent.CONNECTED, Events.Agent.DISCONNECTED).
+ * @param agentId - The Agent ID involved in the connection event.
+ * @param channelId - The Channel ID context for this event (can be a default/system channel if not specific).
+ * @param connectionData - The specific data for the connection event.
+ * @param options - Optional base event payload options.
+ * @returns A ConnectionEventPayload.
+ */
+export function createConnectionEventPayload(eventType, agentId, channelId, connectionData, options = {}) {
+    return createBaseEventPayload(eventType, agentId, channelId, connectionData, options);
+}
+/**
+ * Creates an AgentEventPayload.
+ * @param eventType - The specific agent event type (e.g., Events.Agent.REGISTERED, Events.Agent.STATUS_CHANGE).
+ * @param agentId - The Agent ID to whom this event pertains.
+ * @param channelId - The Channel ID context for this agent event.
+ * @param agentData - The specific data for the agent event.
+ * @param options - Optional base event payload options.
+ * @returns An AgentEventPayload.
+ */
+export function createAgentEventPayload(eventType, agentId, channelId, agentData, options = {}) {
+    return createBaseEventPayload(eventType, agentId, channelId, agentData, options);
+}
+/**
+ * Creates an AllowedToolsUpdateEventPayload.
+ * Used when dynamically changing an agent's allowed tools during runtime.
+ *
+ * @param eventType - The event type (e.g., Events.Agent.ALLOWED_TOOLS_UPDATE).
+ * @param agentId - The Agent ID whose tools are being updated.
+ * @param channelId - The Channel ID context for the update.
+ * @param allowedTools - The new list of allowed tool names.
+ * @param options - Optional base event payload options.
+ * @returns An AllowedToolsUpdateEventPayload.
+ */
+export function createAllowedToolsUpdateEventPayload(eventType, agentId, channelId, allowedTools, options = {}) {
+    return createBaseEventPayload(eventType, agentId, channelId, { allowedTools }, options);
+}
+/**
+ * Creates an LLM Reasoning EventPayload.
+ * @param eventType - The specific LLM reasoning event type (e.g., AgentEvents.LLM_REASONING).
+ * @param agentId - The Agent ID that generated the reasoning.
+ * @param channelId - The Channel ID context for this reasoning event.
+ * @param reasoningData - The specific data for the reasoning event.
+ * @param options - Optional base event payload options.
+ * @returns An LlmReasoningEventPayload.
+ */
+export function createLlmReasoningEventPayload(eventType, agentId, channelId, reasoningData, options = {}) {
+    // Add validation for reasoning data
+    const validator = createStrictValidator('LlmReasoningEventPayload');
+    validator.assertIsNonEmptyString(reasoningData.reasoning, 'Reasoning content is required');
+    return createBaseEventPayload(eventType, agentId, channelId, reasoningData, options);
+}
+/**
+ * Creates an LlmReasoningParsedEventPayload.
+ * Used when reasoning text is parsed for tool intentions.
+ *
+ * @param eventType - The specific event type (e.g., AgentEvents.LLM_REASONING_PARSED).
+ * @param agentId - The Agent ID that generated the reasoning.
+ * @param channelId - The Channel ID for the agent.
+ * @param parsedData - The parsed reasoning data including tool intentions.
+ * @param options - Optional base event payload options.
+ * @returns An LlmReasoningParsedEventPayload.
+ */
+export function createLlmReasoningParsedEventPayload(eventType, agentId, channelId, parsedData, options = {}) {
+    // Add validation for parsed data
+    const validator = createStrictValidator('LlmReasoningParsedEventPayload');
+    validator.assertIsNonEmptyString(parsedData.reasoning, 'Reasoning content is required');
+    validator.assertIsArray(parsedData.toolIntentions, 'Tool intentions must be an array');
+    return createBaseEventPayload(eventType, agentId, channelId, parsedData, options);
+}
+/**
+ * Creates an LlmReasoningToolsSynthesizedEventPayload.
+ * Used when tool_calls are synthesized from reasoning intentions.
+ *
+ * @param eventType - The specific event type (e.g., AgentEvents.LLM_REASONING_TOOLS_SYNTHESIZED).
+ * @param agentId - The Agent ID that generated the reasoning.
+ * @param channelId - The Channel ID for the agent.
+ * @param synthesizedData - The synthesized tool calls data.
+ * @param options - Optional base event payload options.
+ * @returns An LlmReasoningToolsSynthesizedEventPayload.
+ */
+export function createLlmReasoningToolsSynthesizedEventPayload(eventType, agentId, channelId, synthesizedData, options = {}) {
+    // Add validation for synthesized data
+    const validator = createStrictValidator('LlmReasoningToolsSynthesizedEventPayload');
+    validator.assertIsArray(synthesizedData.toolCalls, 'Tool calls must be an array');
+    validator.assertIsArray(synthesizedData.toolIntentions, 'Tool intentions must be an array');
+    return createBaseEventPayload(eventType, agentId, channelId, synthesizedData, options);
+}
+/**
+ * Creates an LLM Stream Chunk EventPayload for live TUI preview.
+ * Emitted during streaming LLM responses as partial tokens arrive.
+ *
+ * @param eventType - The event type (e.g., AgentEvents.LLM_STREAM_CHUNK).
+ * @param agentId - The Agent ID that is streaming.
+ * @param channelId - The Channel ID context for this streaming event.
+ * @param chunkData - The partial chunk data.
+ * @param options - Optional base event payload options.
+ * @returns An LlmStreamChunkEventPayload.
+ */
+export function createLlmStreamChunkEventPayload(eventType, agentId, channelId, chunkData, options = {}) {
+    return createBaseEventPayload(eventType, agentId, channelId, chunkData, options);
+}
+/**
+ * Creates an LLM Usage EventPayload for token cost tracking.
+ * Emitted after each LLM response to track input/output token consumption.
+ *
+ * @param eventType - The event type (e.g., AgentEvents.LLM_USAGE).
+ * @param agentId - The Agent ID that consumed the tokens.
+ * @param channelId - The Channel ID context for this usage event.
+ * @param usageData - Token usage data from the LLM response.
+ * @param options - Optional base event payload options.
+ * @returns An LlmUsageEventPayload.
+ */
+export function createLlmUsageEventPayload(eventType, agentId, channelId, usageData, options = {}) {
+    const validator = createStrictValidator('createLlmUsageEventPayload');
+    validator.assertIsObject(usageData, 'usageData');
+    validator.assertIsNonEmptyString(usageData.model, 'usageData.model');
+    return createBaseEventPayload(eventType, agentId, channelId, usageData, options);
+}
+/**
+ * Creates a ChannelEventPayload.
+ * @param eventType - The specific channel event type (e.g., Events.Channel.CREATED, Events.Channel.AGENT_JOINED).
+ * @param agentId - The Agent ID initiating or primarily affected by the channel event.
+ * @param channelId - The Channel ID to which this event pertains.
+ * @param channelData - The specific data for the channel event.
+ * @param options - Optional base event payload options.
+ * @returns A ChannelEventPayload.
+ */
+export function createChannelEventPayload(eventType, agentId, channelId, channelData, options = {}) {
+    return createBaseEventPayload(eventType, agentId, channelId, channelData, options);
+}
+/**
+ * Creates a SubscriptionEventPayload.
+ * @param eventType - Usually Events.Channel.SUBSCRIBE or Events.Channel.UNSUBSCRIBE.
+ * @param agentId - The Agent ID performing the subscribe/unsubscribe action.
+ * @param channelId - The Channel ID where the subscription is happening.
+ * @param subscriptionData - The specific data for the subscription event.
+ * @param options - Optional base event payload options.
+ * @returns A SubscriptionEventPayload.
+ */
+export function createSubscriptionEventPayload(eventType, agentId, channelId, subscriptionData, options = {}) {
+    return createBaseEventPayload(eventType, agentId, channelId, subscriptionData, options);
+}
+/**
+ * Creates a TaskEventPayload (for task requests).
+ * @param eventType - Usually Events.Task.REQUEST.
+ * @param emittingAgentId - The Agent ID emitting this task request event.
+ * @param channelId - The Channel ID context for this task event.
+ * @param taskData - The specific data for the task request.
+ * @param options - Optional base event payload options.
+ * @returns A TaskEventPayload.
+ */
+export function createTaskEventPayload(eventType, emittingAgentId, channelId, taskData, options = {}) {
+    // Fail-fast validation for task event payload
+    const validator = createStrictValidator('TaskEventPayload');
+    // Validate required event parameters
+    validator.assertIsNonEmptyString(eventType, 'Event type is required');
+    validator.assertIsNonEmptyString(emittingAgentId, 'Emitting agent ID is required');
+    validator.assertIsNonEmptyString(channelId, 'Channel ID is required');
+    // Validate task data structure
+    validator.assertIsObject(taskData, 'Task data must be an object');
+    validator.assertIsNonEmptyString(taskData.taskId, 'Task ID is required');
+    //validator.assertIsNonEmptyString(taskData.toAgentId, 'Target agent ID is required');
+    // Task content is either a plain instruction string (simple request flow)
+    // or a creation-fields object — validate per shape.
+    const task = taskData.task;
+    if (typeof task === 'string') {
+        validator.assertIsNonEmptyString(task, 'Task instruction must be a non-empty string');
+    }
+    else {
+        validator.assertIsObject(task, 'Task content must be an object');
+        validator.assertIsNonEmptyString(task.title, 'Task title is required');
+        validator.assertIsNonEmptyString(task.description, 'Task description is required');
+        validator.assertIsNonEmptyString(task.assignmentStrategy, 'Assignment strategy is required');
+        // Validate assignment scope and related fields
+        if (task.assignmentScope) {
+            const validScopes = ['single', 'multiple', 'channel-wide'];
+            validator.assert(validScopes.includes(task.assignmentScope), `Assignment scope must be one of: ${validScopes.join(', ')}`);
+            // Validate multi-agent assignment requirements
+            if (task.assignmentScope === 'multiple') {
+                validator.assert(Array.isArray(task.assignedAgentIds) && task.assignedAgentIds.length > 1, 'Multiple assignment scope requires assignedAgentIds array with 2+ agents');
+            }
+            // Validate channel-wide assignment requirements
+            if (task.assignmentScope === 'channel-wide') {
+                validator.assert(task.channelWideTask === true || (task.maxParticipants ?? 0) > 0, 'Channel-wide assignment requires channelWideTask flag or maxParticipants limit');
+            }
+        }
+        // Validate coordination mode if specified
+        if (task.coordinationMode) {
+            const validModes = ['independent', 'collaborative', 'sequential', 'hierarchical'];
+            validator.assert(validModes.includes(task.coordinationMode), `Coordination mode must be one of: ${validModes.join(', ')}`);
+        }
+    }
+    // Ensure fromAgentId is present in taskData, if not, use emittingAgentId
+    const dataWithFromAgent = { ...taskData, fromAgentId: taskData.fromAgentId || emittingAgentId };
+    // The spread widens the literal; the narrowed return is runtime-true
+    // because data IS the TData object the caller passed (plus fromAgentId).
+    return createBaseEventPayload(eventType, emittingAgentId, channelId, dataWithFromAgent, options);
+}
+/**
+ * Creates a TaskResponseEventPayload.
+ * @param eventType - Usually Events.Task.RESPONSE.
+ * @param emittingAgentId - The Agent ID emitting this task response event (usually the one that performed the task).
+ * @param channelId - The Channel ID context for this task response event.
+ * @param taskResponseData - The specific data for the task response.
+ * @param options - Optional base event payload options.
+ * @returns A TaskResponseEventPayload.
+ */
+export function createTaskResponseEventPayload(eventType, emittingAgentId, channelId, taskResponseData, options = {}) {
+    // Ensure fromAgentId is present in taskResponseData, if not, use emittingAgentId
+    const dataWithFromAgent = { ...taskResponseData, fromAgentId: taskResponseData.fromAgentId || emittingAgentId };
+    return createBaseEventPayload(eventType, emittingAgentId, channelId, dataWithFromAgent, options);
+}
+/**
+ * Creates a TaskAssignmentEventPayload.
+ * @param eventType - Usually Events.Task.ASSIGNED.
+ * @param assignedAgentId - The Agent ID that was assigned the task.
+ * @param channelId - The Channel ID context for this task assignment event.
+ * @param taskAssignmentData - The specific data for the task assignment.
+ * @param options - Optional base event payload options.
+ * @returns A TaskAssignmentEventPayload.
+ */
+export function createTaskAssignmentEventPayload(eventType, assignedAgentId, channelId, taskAssignmentData, options = {}) {
+    return createBaseEventPayload(eventType, assignedAgentId, channelId, taskAssignmentData, options);
+}
+/**
+ * Creates a ControlLoopEventPayload.
+ * @param eventType - The specific control loop event type (e.g., Events.ControlLoop.INITIALIZE, Events.ControlLoop.OBSERVATION).
+ * @param agentId - The Agent ID that owns/runs this control loop.
+ * @param channelId - The Channel ID with which this control loop is associated.
+ * @param controlLoopData - The specific data for the control loop event.
+ * @param options - Optional base event payload options.
+ * @returns A ControlLoopEventPayload.
+ */
+export function createControlLoopEventPayload(eventType, agentId, channelId, controlLoopData, options = {}) {
+    return createBaseEventPayload(eventType, agentId, channelId, controlLoopData, options);
+}
+// --- Memory Event Payload Creator Helpers ---
+/**
+ * Creates a MemoryGetEventPayload.
+ * @param eventType - Usually Events.Memory.GET.
+ * @param agentId - Agent requesting or involved in the memory operation.
+ * @param channelId - Channel context for the memory operation.
+ * @param memoryGetData - Specific data for the memory get request.
+ * @param options - Optional base event payload options.
+ * @returns A MemoryGetEventPayload.
+ */
+export function createMemoryGetEventPayload(eventType, agentId, channelId, memoryGetData, options = {}) {
+    const validator = createStrictValidator('createMemoryGetEventPayload');
+    validator.assertIsNonEmptyString(memoryGetData.operationId, 'memoryGetData.operationId');
+    validator.assert(Object.values(MemoryScope).includes(memoryGetData.scope), `memoryGetData.scope must be a valid MemoryScope value. Received: ${memoryGetData.scope}`);
+    // Validate 'id' which is string | string[]
+    if (Array.isArray(memoryGetData.id)) {
+        validator.assert(memoryGetData.id.length > 0, 'memoryGetData.id array must not be empty');
+        memoryGetData.id.forEach((item, index) => {
+            validator.assertIsNonEmptyString(item, `memoryGetData.id[${index}] must be a non-empty string`);
+        });
+    }
+    else {
+        validator.assertIsNonEmptyString(memoryGetData.id, 'memoryGetData.id must be a non-empty string or a non-empty array of non-empty strings');
+    }
+    return createBaseEventPayload(eventType, agentId, channelId, memoryGetData, options);
+}
+/**
+ * Creates a MemoryGetResultEventPayload.
+ * @param eventType - Usually Events.Memory.GET_RESULT or Events.Memory.GET_ERROR.
+ * @param agentId - Agent involved in the memory operation result.
+ * @param channelId - Channel context for the memory operation result.
+ * @param memoryGetResultData - Specific data for the memory get result.
+ * @param options - Optional base event payload options.
+ * @returns A MemoryGetResultEventPayload.
+ */
+export function createMemoryGetResultEventPayload(eventType, agentId, channelId, memoryGetResultData, options = {}) {
+    const validator = createStrictValidator('createMemoryGetResultEventPayload');
+    validator.assertIsNonEmptyString(memoryGetResultData.operationId, 'memoryGetResultData.operationId');
+    validator.assert(Object.values(MemoryScope).includes(memoryGetResultData.scope), `memoryGetResultData.scope must be a valid MemoryScope value. Received: ${memoryGetResultData.scope}`);
+    // Validate 'id' which is string | string[]
+    if (Array.isArray(memoryGetResultData.id)) {
+        validator.assert(memoryGetResultData.id.length > 0, 'memoryGetResultData.id array must not be empty');
+        memoryGetResultData.id.forEach((item, index) => {
+            validator.assertIsNonEmptyString(item, `memoryGetResultData.id[${index}] must be a non-empty string`);
+        });
+    }
+    else {
+        validator.assertIsNonEmptyString(memoryGetResultData.id, 'memoryGetResultData.id must be a non-empty string or a non-empty array of non-empty strings');
+    }
+    // memoryGetResultData.memory can be null/undefined if not found, so no strict check on its presence unless error is also absent.
+    if (!memoryGetResultData.error && memoryGetResultData.memory === undefined) {
+        // MemoryGetResultEventData created without memory or error - this is allowed for empty results
+    }
+    return createBaseEventPayload(eventType, agentId, channelId, memoryGetResultData, options);
+}
+/**
+ * Creates a MemoryUpdateEventPayload.
+ * @param eventType - Usually Events.Memory.UPDATE.
+ * @param agentId - Agent requesting or involved in the memory update.
+ * @param channelId - Channel context for the memory update.
+ * @param memoryUpdateData - Specific data for the memory update request.
+ * @param options - Optional base event payload options.
+ * @returns A MemoryUpdateEventPayload.
+ */
+export function createMemoryUpdateEventPayload(eventType, agentId, channelId, memoryUpdateData, options = {}) {
+    const validator = createStrictValidator('createMemoryUpdateEventPayload');
+    validator.assertIsNonEmptyString(memoryUpdateData.operationId, 'memoryUpdateData.operationId');
+    validator.assert(Object.values(MemoryScope).includes(memoryUpdateData.scope), `memoryUpdateData.scope must be a valid MemoryScope value. Received: ${memoryUpdateData.scope}`);
+    // Validate 'id' which is string | string[]
+    if (Array.isArray(memoryUpdateData.id)) {
+        validator.assert(memoryUpdateData.id.length > 0, 'memoryUpdateData.id array must not be empty');
+        memoryUpdateData.id.forEach((item, index) => {
+            validator.assertIsNonEmptyString(item, `memoryUpdateData.id[${index}] must be a non-empty string`);
+        });
+    }
+    else {
+        validator.assertIsNonEmptyString(memoryUpdateData.id, 'memoryUpdateData.id must be a non-empty string or a non-empty array of non-empty strings');
+    }
+    validator.assertIsObject(memoryUpdateData.data, 'memoryUpdateData.data');
+    return createBaseEventPayload(eventType, agentId, channelId, memoryUpdateData, options);
+}
+/**
+ * Creates a MemoryUpdateResultEventPayload.
+ * @param eventType - Usually Events.Memory.UPDATE_RESULT or Events.Memory.UPDATE_ERROR.
+ * @param agentId - Agent involved in the memory update result.
+ * @param channelId - Channel context for the memory update result.
+ * @param memoryUpdateResultData - Specific data for the memory update result.
+ * @param options - Optional base event payload options.
+ * @returns A MemoryUpdateResultEventPayload.
+ */
+export function createMemoryUpdateResultEventPayload(eventType, agentId, channelId, memoryUpdateResultData, options = {}) {
+    const validator = createStrictValidator('createMemoryUpdateResultEventPayload');
+    validator.assertIsNonEmptyString(memoryUpdateResultData.operationId, 'memoryUpdateResultData.operationId');
+    validator.assert(Object.values(MemoryScope).includes(memoryUpdateResultData.scope), `memoryUpdateResultData.scope must be a valid MemoryScope value. Received: ${memoryUpdateResultData.scope}`);
+    // Validate 'id' which is string | string[]
+    if (Array.isArray(memoryUpdateResultData.id)) {
+        validator.assert(memoryUpdateResultData.id.length > 0, 'memoryUpdateResultData.id array must not be empty');
+        memoryUpdateResultData.id.forEach((item, index) => {
+            validator.assertIsNonEmptyString(item, `memoryUpdateResultData.id[${index}] must be a non-empty string`);
+        });
+    }
+    else {
+        validator.assertIsNonEmptyString(memoryUpdateResultData.id, 'memoryUpdateResultData.id must be a non-empty string or a non-empty array of non-empty strings');
+    }
+    // memoryUpdateResultData.memory might not be strictly an object if e.g. indicating success only
+    if (!memoryUpdateResultData.error && memoryUpdateResultData.memory === undefined) {
+        // MemoryUpdateResultEventData created without memory or error - this is allowed for success indicators
+    }
+    return createBaseEventPayload(eventType, agentId, channelId, memoryUpdateResultData, options);
+}
+/**
+ * Creates a MemoryDeleteEventPayload.
+ * @param eventType - Usually Events.Memory.DELETE.
+ * @param agentId - Agent requesting or involved in the memory deletion.
+ * @param channelId - Channel context for the memory deletion.
+ * @param memoryDeleteData - Specific data for the memory delete request.
+ * @param options - Optional base event payload options.
+ * @returns A MemoryDeleteEventPayload.
+ */
+export function createMemoryDeleteEventPayload(eventType, agentId, channelId, memoryDeleteData, options = {}) {
+    const validator = createStrictValidator('createMemoryDeleteEventPayload');
+    validator.assertIsNonEmptyString(memoryDeleteData.operationId, 'memoryDeleteData.operationId');
+    validator.assert(Object.values(MemoryScope).includes(memoryDeleteData.scope), `memoryDeleteData.scope must be a valid MemoryScope value. Received: ${memoryDeleteData.scope}`);
+    // Validate 'id' which is string | string[]
+    if (Array.isArray(memoryDeleteData.id)) {
+        validator.assert(memoryDeleteData.id.length > 0, 'memoryDeleteData.id array must not be empty');
+        memoryDeleteData.id.forEach((item, index) => {
+            validator.assertIsNonEmptyString(item, `memoryDeleteData.id[${index}] must be a non-empty string`);
+        });
+    }
+    else {
+        validator.assertIsNonEmptyString(memoryDeleteData.id, 'memoryDeleteData.id must be a non-empty string or a non-empty array of non-empty strings');
+    }
+    return createBaseEventPayload(eventType, agentId, channelId, memoryDeleteData, options);
+}
+/**
+ * Creates a MemoryDeleteResultEventPayload.
+ * @param eventType - Usually Events.Memory.DELETE_RESULT or Events.Memory.DELETE_ERROR.
+ * @param agentId - Agent involved in the memory deletion result.
+ * @param channelId - Channel context for the memory deletion result.
+ * @param memoryDeleteResultData - Specific data for the memory delete result.
+ * @param options - Optional base event payload options.
+ * @returns A MemoryDeleteResultEventPayload.
+ */
+export function createMemoryDeleteResultEventPayload(eventType, agentId, channelId, memoryDeleteResultData, options = {}) {
+    const validator = createStrictValidator('createMemoryDeleteResultEventPayload');
+    validator.assertIsNonEmptyString(memoryDeleteResultData.operationId, 'memoryDeleteResultData.operationId');
+    validator.assert(Object.values(MemoryScope).includes(memoryDeleteResultData.scope), `memoryDeleteResultData.scope must be a valid MemoryScope value. Received: ${memoryDeleteResultData.scope}`);
+    // Validate 'id' which is string | string[]
+    if (Array.isArray(memoryDeleteResultData.id)) {
+        validator.assert(memoryDeleteResultData.id.length > 0, 'memoryDeleteResultData.id array must not be empty');
+        memoryDeleteResultData.id.forEach((item, index) => {
+            validator.assertIsNonEmptyString(item, `memoryDeleteResultData.id[${index}] must be a non-empty string`);
+        });
+    }
+    else {
+        validator.assertIsNonEmptyString(memoryDeleteResultData.id, 'memoryDeleteResultData.id must be a non-empty string or a non-empty array of non-empty strings');
+    }
+    if (!memoryDeleteResultData.error && typeof memoryDeleteResultData.success !== 'boolean') {
+        throw new Error('MemoryDeleteResultEventData requires a success flag if no error is provided.');
+    }
+    return createBaseEventPayload(eventType, agentId, channelId, memoryDeleteResultData, options);
+}
+/**
+ * Creates a MemorySyncCompleteEventPayload.
+ * @param eventType - Usually Events.Memory.SYNC_COMPLETE.
+ * @param agentId - Agent involved in the memory sync operation.
+ * @param channelId - Channel context for the memory sync operation.
+ * @param memorySyncCompleteData - Specific data for the memory sync complete.
+ * @param options - Optional base event payload options.
+ * @returns A MemorySyncCompleteEventPayload.
+ */
+export function createMemorySyncCompleteEventPayload(eventType, agentId, channelId, memorySyncCompleteData, options = {}) {
+    const validator = createStrictValidator('createMemorySyncCompleteEventPayload');
+    validator.assertIsNonEmptyString(memorySyncCompleteData.operationId, 'memorySyncCompleteData.operationId');
+    validator.assert(Object.values(MemoryScope).includes(memorySyncCompleteData.scope), `memorySyncCompleteData.scope must be a valid MemoryScope value. Received: ${memorySyncCompleteData.scope}`);
+    return createBaseEventPayload(eventType, agentId, channelId, memorySyncCompleteData, options);
+}
+/**
+ * Creates a MemorySyncErrorEventPayload.
+ * @param eventType - Usually Events.Memory.SYNC_ERROR.
+ * @param agentId - Agent involved in the memory sync error.
+ * @param channelId - Channel context for the memory sync error.
+ * @param memorySyncErrorData - Specific data for the memory sync error.
+ * @param options - Optional base event payload options.
+ * @returns A MemorySyncErrorEventPayload.
+ */
+export function createMemorySyncErrorEventPayload(eventType, agentId, channelId, memorySyncErrorData, options = {}) {
+    const validator = createStrictValidator('createMemorySyncErrorEventPayload');
+    validator.assertIsNonEmptyString(memorySyncErrorData.operationId, 'memorySyncErrorData.operationId');
+    validator.assert(Object.values(MemoryScope).includes(memorySyncErrorData.scope), `memorySyncErrorData.scope must be a valid MemoryScope value. Received: ${memorySyncErrorData.scope}`);
+    validator.assertIsNonEmptyString(memorySyncErrorData.error, 'memorySyncErrorData.error');
+    return createBaseEventPayload(eventType, agentId, channelId, memorySyncErrorData, options);
+}
+// --- Message Event Payload Creator Helpers ---
+/**
+ * Creates an event payload that carries a standard ChannelMessage.
+ * @param eventType - The specific event type, e.g., Events.Message.CHANNEL_MESSAGE.
+ * @param agentId - The Agent ID involved in processing or relaying this message event.
+ * @param channelMessage - The ChannelMessage object itself.
+ * @param options - Optional base event payload options.
+ * @returns A ChannelMessageEventPayload.
+ */
+export function createChannelMessageEventPayload(eventType, agentId, channelMessage, options = {}) {
+    const validator = createStrictValidator('createChannelMessageEventPayload');
+    validator.assertIsObject(channelMessage, 'channelMessage');
+    validator.assertIsNonEmptyString(channelMessage?.context?.channelId, 'channelMessage.context.channelId');
+    return createBaseEventPayload(eventType, agentId, channelMessage.context.channelId, // Deriving channelId for BaseEventPayload from the message's context
+    channelMessage, options);
+}
+/**
+ * Creates an event payload that carries a standard AgentMessage.
+ * @param eventType - The specific event type, e.g., Events.Message.AGENT_MESSAGE.
+ * @param agentId - The Agent ID involved in this agent message event (e.g., sender or receiver based on context).
+ * @param channelId - The Channel ID providing context for this agent message event.
+ * @param agentMessage - The AgentMessage object itself.
+ * @param options - Optional base event payload options.
+ * @returns A AgentMessageEventPayload.
+ */
+export function createAgentMessageEventPayload(eventType, agentId, channelId, agentMessage, options = {}) {
+    const validator = createStrictValidator('createAgentMessageEventPayload');
+    validator.assertIsObject(agentMessage, 'agentMessage');
+    // agentMessage.receiverId is validated by its own creator typically
+    return createBaseEventPayload(eventType, agentId, channelId, // Agent messages can still occur within a channel context for the event logging/tracing
+    agentMessage, options);
+}
+/**
+ * Creates a MessageEventPayload for message persistence events.
+ * @param eventType - The specific event type (e.g., Events.Message.PERSIST_CHANNEL_MESSAGE_REQUEST).
+ * @param agentId - The ID of the agent initiating or responsible for the event.
+ * @param channelId - The ID of the channel associated with the event.
+ * @param data - The specific data for the message event.
+ * @param options - Optional overrides for eventId and timestamp.
+ * @returns The complete event payload.
+ */
+export const createMessageEventPayload = (eventType, agentId, channelId, data, options) => ({
+    eventId: options?.eventId || uuidv4(),
+    eventType,
+    timestamp: options?.timestamp || Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data,
+});
+/**
+ * Creates a MessagePersistFailedPayload event payload.
+ * @param eventType - The specific event type (e.g., Events.Message.MESSAGE_PERSIST_FAILED).
+ * @param agentId - The ID of the agent initiating or responsible for the event.
+ * @param channelId - The ID of the channel associated with the event.
+ * @param data - The specific data for the message persist failed event.
+ * @param options - Optional overrides for eventId and timestamp.
+ * @returns The complete event payload.
+ */
+export const createMessagePersistFailedEventPayload = (eventType, agentId, channelId, data, options) => ({
+    eventId: options?.eventId || uuidv4(),
+    eventType,
+    timestamp: options?.timestamp || Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data,
+});
+/**
+ * Creates a MessageSendFailedPayload event payload.
+ * @param eventType - The specific event type (e.g., Events.Message.MESSAGE_SEND_FAILED).
+ * @param agentId - The ID of the agent initiating or responsible for the event.
+ * @param channelId - The ID of the channel associated with the event.
+ * @param data - The specific data for the message send failed event.
+ * @param options - Optional overrides for eventId and timestamp.
+ * @returns The complete event payload.
+ */
+export const createMessageSendFailedEventPayload = (eventType, agentId, channelId, data, options) => ({
+    eventId: options?.eventId || uuidv4(),
+    eventType,
+    timestamp: options?.timestamp || Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data,
+});
+/**
+ * Creates a payload for an LLM instruction started event.
+ * @param eventType - The specific event type.
+ * @param agentId - The ID of the agent initiating or responsible for the event.
+ * @param channelId - The ID of the channel associated with the event.
+ * @param data - The specific data for the LLM instruction started event.
+ * @returns The complete event payload.
+ */
+export const createLlmInstructionStartedPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data,
+});
+/**
+ * Creates a payload for an LLM instruction completed event.
+ * @param eventType - The specific event type.
+ * @param agentId - The ID of the agent initiating or responsible for the event.
+ * @param channelId - The ID of the channel associated with the event.
+ * @param data - The specific data for the LLM instruction completed event.
+ * @returns The complete event payload.
+ */
+export const createLlmInstructionCompletedPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data,
+});
+/**
+ * Creates a payload for an LLM instruction error event.
+ * @param eventType - The specific event type.
+ * @param agentId - The ID of the agent initiating or responsible for the event.
+ * @param channelId - The ID of the channel associated with the event.
+ * @param data - The specific data for the LLM instruction error event.
+ * @returns The complete event payload.
+ */
+export const createLlmInstructionErrorPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data,
+});
+/**
+ * Creates a payload for an MCP tool register event.
+ * @param eventType - The specific event type.
+ * @param agentId - The ID of the agent initiating or responsible for the event.
+ * @param channelId - The ID of the channel associated with the event.
+ * @param data - The specific data for the MCP tool register event.
+ * @returns The complete event payload.
+ */
+export const createMcpToolRegisterPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data,
+});
+/**
+ * Creates a payload for an MCP tool registered response event.
+ * @param eventType - The specific event type.
+ * @param agentId - The ID of the agent initiating or responsible for the event.
+ * @param channelId - The ID of the channel associated with the event.
+ * @param data - The specific data for the MCP tool registered response event.
+ * @returns The complete event payload.
+ */
+export const createMcpToolRegisteredPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data: {
+        ...data,
+        registrationDetails: { success: data.success, error: data.error }
+    },
+});
+/**
+ * Creates a payload for an MCP tool unregister event.
+ * @param eventType - The specific event type.
+ * @param agentId - The ID of the agent initiating or responsible for the event.
+ * @param channelId - The ID of the channel associated with the event.
+ * @param data - The specific data for the MCP tool unregister event.
+ * @returns The complete event payload.
+ */
+export const createMcpToolUnregisterPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data,
+});
+/**
+ * Creates a payload for an MCP tool call event.
+ * @param eventType - The specific event type.
+ * @param agentId - The ID of the agent initiating or responsible for the event.
+ * @param channelId - The ID of the channel associated with the event.
+ * @param data - The specific data for the MCP tool call event.
+ * @returns The complete event payload.
+ */
+export const createMcpToolCallPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data,
+});
+/**
+ * Creates a payload for an MCP tool result event.
+ * @param eventType - The specific event type.
+ * @param agentId - The ID of the agent initiating or responsible for the event.
+ * @param channelId - The ID of the channel associated with the event.
+ * @param data - The specific data for the MCP tool result event.
+ * @returns The complete event payload.
+ */
+export const createMcpToolResultPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data,
+});
+/**
+ * Creates a payload for an MCP tool error event.
+ * @param eventType - The specific event type.
+ * @param agentId - The ID of the agent initiating or responsible for the event.
+ * @param channelId - The ID of the channel associated with the event.
+ * @param data - The specific data for the MCP tool error event.
+ * @returns The complete event payload.
+ */
+export const createMcpToolErrorPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data,
+});
+/**
+ * Creates a payload for a client-side tool call event (local observability).
+ */
+export const createMcpToolCallLocalPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data,
+});
+/**
+ * Creates a payload for a client-side tool result event (local observability).
+ */
+export const createMcpToolResultLocalPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data,
+});
+/**
+ * Creates a payload for a client-side tool error event (local observability).
+ */
+export const createMcpToolErrorLocalPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data,
+});
+/**
+ * Creates a payload for the fire-and-forget notification to server
+ * after a tool has been executed client-side. Used for DB history recording.
+ */
+export const createMcpToolCallCompletedLocalPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data,
+});
+/**
+ * Creates a payload for an MCP resource get event.
+ * @param eventType - The specific event type.
+ * @param agentId - The ID of the agent initiating or responsible for the event.
+ * @param channelId - The ID of the channel associated with the event.
+ * @param data - The specific data for the MCP resource get event.
+ * @returns The complete event payload.
+ */
+export const createMcpResourceGetPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data,
+});
+/**
+ * Creates a payload for an MCP resource list event.
+ * @param eventType - The specific event type.
+ * @param agentId - The ID of the agent initiating or responsible for the event.
+ * @param channelId - The ID of the channel associated with the event.
+ * @param data - The specific data for the MCP resource list event.
+ * @returns The complete event payload.
+ */
+export const createMcpResourceListPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data,
+});
+/**
+ * Creates a payload for an MCP resource result event.
+ * @param eventType - The specific event type.
+ * @param agentId - The ID of the agent initiating or responsible for the event.
+ * @param channelId - The ID of the channel associated with the event.
+ * @param data - The specific data for the MCP resource result event.
+ * @returns The complete event payload.
+ */
+export const createMcpResourceResultPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data,
+});
+/**
+ * Creates a payload for an MCP resource error event.
+ * @param eventType - The specific event type.
+ * @param agentId - The ID of the agent initiating or responsible for the event.
+ * @param channelId - The ID of the channel associated with the event.
+ * @param data - The specific data for the MCP resource error event.
+ * @returns The complete event payload.
+ */
+export const createMcpResourceErrorPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data,
+});
+/**
+ * Creates a payload for an external MCP server event (global or channel-scoped).
+ * @param eventType - The specific event type.
+ * @param agentId - The ID of the agent initiating or responsible for the event.
+ * @param channelId - The ID of the channel associated with the event.
+ * @param serverData - The specific data for the external MCP server event.
+ * @param options - Optional base event payload options.
+ * @returns The complete event payload.
+ */
+export function createExternalMcpServerEventPayload(eventType, agentId, channelId, serverData, options = {}) {
+    return createBaseEventPayload(eventType, agentId, channelId, serverData, options);
+}
+/**
+ * Creates a payload for an MCP tool registry changed event.
+ * @param eventType - The specific event type.
+ * @param agentId - The ID of the agent initiating or responsible for the event.
+ * @param channelId - The ID of the channel associated with the event.
+ * @param data - The specific data for the MCP tool registry changed event.
+ * @returns The complete event payload.
+ */
+export const createMcpToolRegistryChangedPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data,
+});
+/**
+ * Creates a payload for an agent message delivered event.
+ * @param eventType - The specific event type.
+ * @param agentId - The ID of the agent initiating or responsible for the event.
+ * @param channelId - The ID of the channel associated with the event.
+ * @param data - The specific data for the agent message delivered event.
+ * @returns The complete event payload.
+ */
+export const createAgentMessageDeliveredPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data,
+});
+/**
+ * Creates a payload for an agent message forward event (used server-side).
+ * @param eventType - The specific event type.
+ * @param agentId - The ID of the agent initiating or responsible for the event.
+ * @param channelId - The ID of the channel associated with the event.
+ * @param data - The original agent message event payload being forwarded.
+ * @returns The complete event payload.
+ */
+export const createAgentMessageForwardPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data,
+});
+/**
+ * Creates a ChannelCreationEventPayload.
+ * @param eventType - The specific event type.
+ * @param agentId - The ID of the agent initiating or responsible for the event.
+ * @param channelId - The ID of the channel associated with the event.
+ * @param data - The specific data for the channel creation event.
+ * @returns The complete event payload.
+ */
+export const createChannelCreationEventPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data,
+});
+/**
+ * Creates a ContextGetEventPayload.
+ * @param eventType - The specific event type.
+ * @param agentId - The ID of the agent initiating or responsible for the event.
+ * @param channelId - The ID of the channel associated with the event.
+ * @param data - The specific data for the context get event.
+ * @returns The complete event payload.
+ */
+export const createContextGetEventPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data,
+});
+/**
+ * Creates a ContextGotEventPayload.
+ * @param eventType - The specific event type.
+ * @param agentId - The ID of the agent initiating or responsible for the event.
+ * @param channelId - The ID of the channel associated with the event.
+ * @param data - The specific data for the context got event.
+ * @returns The complete event payload.
+ */
+export const createContextGotEventPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data,
+});
+/**
+ * Creates a ContextUpdateEventPayload.
+ * @param eventType - The specific event type.
+ * @param agentId - The ID of the agent initiating or responsible for the event.
+ * @param channelId - The ID of the channel associated with the event.
+ * @param data - The specific data for the context update event.
+ * @returns The complete event payload.
+ */
+export const createContextUpdateEventPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data,
+});
+/**
+ * Creates a MetadataSetEventPayload.
+ * @param eventType - The specific event type.
+ * @param agentId - The ID of the agent initiating or responsible for the event.
+ * @param channelId - The ID of the channel associated with the event.
+ * @param data - The specific data for the metadata set event.
+ * @returns The complete event payload.
+ */
+export const createMetadataSetEventPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'SYSTEM',
+    data,
+});
+/**
+ * Creates a TopicsExtractEventPayload.
+ * @param eventType - The specific event type.
+ * @param agentId - The ID of the agent initiating or responsible for the event.
+ * @param channelId - The ID of the channel associated with the event.
+ * @param data - The specific data for the topics extract event.
+ * @param options - Optional parameters like source, recursion protection flag, or overrides for eventId and timestamp.
+ * @returns The complete event payload.
+ */
+export const createTopicsExtractEventPayload = (eventType, agentId, channelId, data, options = {}) => ({
+    eventId: options.eventId || uuidv4(),
+    eventType,
+    timestamp: options.timestamp || Date.now(),
+    agentId,
+    channelId,
+    source: options.source || 'SYSTEM',
+    isRecursionProtection: options.isRecursionProtection,
+    data,
+});
+/**
+ * Creates a SummaryGenerateEventPayload.
+ * @param eventType - The specific event type.
+ * @param agentId - The ID of the agent initiating or responsible for the event.
+ * @param channelId - The ID of the channel associated with the event.
+ * @param data - The specific data for the summary generate event.
+ * @param options - Optional parameters like source, recursion protection flag, or overrides for eventId and timestamp.
+ * @returns The complete event payload.
+ */
+export const createSummaryGenerateEventPayload = (eventType, agentId, channelId, data, options = {}) => ({
+    eventId: options.eventId || uuidv4(),
+    eventType,
+    timestamp: options.timestamp || Date.now(),
+    agentId,
+    channelId,
+    source: options.source || 'SYSTEM',
+    isRecursionProtection: options.isRecursionProtection,
+    data,
+});
+/**
+ * Creates an external MCP server error event payload.
+ */
+export const createExternalMcpServerErrorEventPayload = (eventType, agentId, channelId, data, options = {}) => ({
+    eventId: options.eventId || uuidv4(),
+    eventType,
+    timestamp: options.timestamp || Date.now(),
+    agentId,
+    channelId,
+    source: options.source || 'ExternalMcpServerManager',
+    isRecursionProtection: options.isRecursionProtection,
+    data,
+});
+/**
+ * Creates an external MCP server health status event payload.
+ */
+export const createExternalMcpServerHealthStatusEventPayload = (eventType, agentId, channelId, data, options = {}) => ({
+    eventId: options.eventId || uuidv4(),
+    eventType,
+    timestamp: options.timestamp || Date.now(),
+    agentId,
+    channelId,
+    source: options.source || 'ExternalMcpServerManager',
+    isRecursionProtection: options.isRecursionProtection,
+    data,
+});
+/**
+ * Creates an external MCP server tools discovered event payload.
+ */
+export const createExternalMcpServerToolsDiscoveredEventPayload = (eventType, agentId, channelId, data, options = {}) => ({
+    eventId: options.eventId || uuidv4(),
+    eventType,
+    timestamp: options.timestamp || Date.now(),
+    agentId,
+    channelId,
+    source: options.source || 'ExternalMcpServerManager',
+    isRecursionProtection: options.isRecursionProtection,
+    data,
+});
+// === System Event Payload Creation Helpers ===
+/**
+ * Creates a system ephemeral event payload for intelligent context injection
+ */
+export const createSystemEphemeralEventPayload = (eventType, agentId, channelId, eventData, coordinationContext, options = {}) => ({
+    eventId: options.eventId || uuidv4(),
+    eventType,
+    timestamp: options.timestamp || Date.now(),
+    agentId,
+    channelId,
+    source: options.source || 'SystemLlmService',
+    isRecursionProtection: options.isRecursionProtection,
+    data: {
+        eventData,
+        coordinationContext,
+        systemMetadata: {
+            systemConfidence: options.systemConfidence || 0.8,
+            processingTime: Date.now(),
+            systemVersion: '1.0.0',
+            analysisMethod: options.analysisMethod || 'coordination_detection'
+        }
+    },
+});
+/**
+ * Creates a system coordination event payload for coordination analysis
+ */
+export const createSystemCoordinationEventPayload = (eventType, agentId, channelId, coordinationAnalysis, recommendedActions, temporalContext, options = {}) => ({
+    eventId: options.eventId || uuidv4(),
+    eventType,
+    timestamp: options.timestamp || Date.now(),
+    agentId,
+    channelId,
+    source: options.source || 'SystemLlmService',
+    isRecursionProtection: options.isRecursionProtection,
+    data: {
+        coordinationAnalysis,
+        recommendedActions,
+        priority: options.priority || 5,
+        temporalContext,
+        recommendationConfidence: options.recommendationConfidence || 0.75
+    },
+});
+/**
+ * Creates a system temporal pattern event payload for pattern detection
+ */
+export const createSystemTemporalPatternEventPayload = (eventType, agentId, channelId, pattern, impactAssessment, options = {}) => ({
+    eventId: options.eventId || uuidv4(),
+    eventType,
+    timestamp: options.timestamp || Date.now(),
+    agentId,
+    channelId,
+    source: options.source || 'SystemLlmService',
+    isRecursionProtection: options.isRecursionProtection,
+    data: {
+        pattern,
+        impactAssessment
+    },
+});
+/**
+ * Creates a system context analysis event payload for rich context awareness
+ */
+export const createSystemContextAnalysisEventPayload = (eventType, agentId, channelId, contextAnalysis, options = {}) => ({
+    eventId: options.eventId || uuidv4(),
+    eventType,
+    timestamp: options.timestamp || Date.now(),
+    agentId,
+    channelId,
+    source: options.source || 'SystemLlmService',
+    isRecursionProtection: options.isRecursionProtection,
+    data: {
+        contextAnalysis,
+        analysisConfidence: options.analysisConfidence || 0.8,
+        nextAnalysisTime: options.nextAnalysisTime || new Date(Date.now() + 300000).toISOString() // 5 minutes default
+    },
+});
+/**
+ * Validation helper for system event payloads
+ * Ensures system events meet quality and security standards
+ */
+export const validateSystemEventPayload = (payload) => {
+    const validator = createStrictValidator('SystemEventPayload');
+    try {
+        // Validate base payload structure
+        validator.assertIsNonEmptyString(payload.eventId, 'Event ID is required');
+        validator.assertIsNonEmptyString(payload.eventType, 'Event type is required');
+        validator.assertIsNumber(payload.timestamp, 'Timestamp is required');
+        validator.assertIsNonEmptyString(payload.agentId, 'Agent ID is required');
+        validator.assertIsNonEmptyString(payload.channelId, 'Channel ID is required');
+        // Validate system event data
+        validator.assertIsObject(payload.data, 'Event data is required');
+        validator.assertIsObject(payload.data.eventData, 'Event data content is required');
+        validator.assertIsNonEmptyString(payload.data.eventData.content, 'Event content is required');
+        validator.assertIsObject(payload.data.eventData.temporalContext, 'Temporal context is required');
+        // Validate confidence scores
+        const confidence = payload.data.eventData.metadata.confidence;
+        validator.assert(confidence >= 0 && confidence <= 1, 'Confidence must be between 0 and 1');
+        const relevance = payload.data.eventData.metadata.relevance;
+        validator.assert(relevance >= 0 && relevance <= 1, 'Relevance must be between 0 and 1');
+        // Validate TTL
+        validator.assert(payload.data.eventData.ttl > 0, 'TTL must be positive');
+        return true;
+    }
+    catch (error) {
+        logger.warn(`System event payload validation failed: ${error}`);
+        return false;
+    }
+};
+/**
+ * Create a TemporalContext object from Time MCP server data
+ * @param timeData - Raw data from Time MCP server
+ * @param options - Optional configuration for temporal context
+ * @returns Properly formatted TemporalContext object
+ */
+export const createTemporalContext = (timeData = {}, options = {}) => {
+    const validator = createStrictValidator('TemporalContext');
+    const now = new Date();
+    const hour = now.getHours();
+    const dayOfWeek = now.getDay();
+    const isWeekend = dayOfWeek === 0 || dayOfWeek === 6;
+    const businessStart = parseInt(options.businessHoursStart?.split(':')[0] || '9');
+    const businessEnd = parseInt(options.businessHoursEnd?.split(':')[0] || '17');
+    const isBusinessHours = hour >= businessStart && hour <= businessEnd && !isWeekend;
+    // Generate contextual timing
+    let contextualTiming = 'Standard operating period';
+    if (isWeekend) {
+        contextualTiming = 'Weekend period - reduced activity expected';
+    }
+    else if (hour >= businessStart && hour <= businessEnd) {
+        contextualTiming = 'Peak collaboration hours - high agent activity';
+    }
+    else if (hour >= 18 && hour <= 22) {
+        contextualTiming = 'Evening period - moderate activity';
+    }
+    else {
+        contextualTiming = 'Off-peak hours - limited activity expected';
+    }
+    return {
+        currentTime: timeData.current_time || now.toISOString(),
+        localTime: timeData.local_time || now.toLocaleString(),
+        relativeTime: timeData.relative_time || 'now',
+        workingHours: timeData.business_hours ?? isBusinessHours,
+        timeZone: timeData.timezone || options.timezone || 'UTC',
+        dayOfWeek: timeData.day_of_week || now.toLocaleDateString('en-US', { weekday: 'long' }),
+        contextualTiming,
+        metadata: {
+            timestamp: Date.now(),
+            businessHours: {
+                start: options.businessHoursStart || '09:00',
+                end: options.businessHoursEnd || '17:00'
+            },
+            utcOffset: timeData.utc_offset || 0,
+            isWeekend: timeData.is_weekend ?? isWeekend
+        }
+    };
+};
+/**
+ * Create a basic CoordinationAnalysis object
+ * @param channelId - Channel identifier
+ * @param options - Optional configuration for analysis
+ * @returns Basic CoordinationAnalysis structure
+ */
+export const createBasicCoordinationAnalysis = (channelId, options = {}) => {
+    const validator = createStrictValidator('CoordinationAnalysis');
+    validator.assertIsNonEmptyString(channelId, 'Channel ID is required for coordination analysis');
+    return {
+        channelId,
+        activeAgents: options.activeAgents || [],
+        opportunities: [
+            {
+                type: 'collaboration',
+                involvedAgents: options.activeAgents || [],
+                description: 'Detected potential for agent collaboration based on activity patterns',
+                confidence: 0.7,
+                suggestedAction: 'Consider coordinating on shared objectives'
+            }
+        ],
+        activityMetrics: {
+            messageCount: options.messageCount || 0,
+            toolUsage: options.toolUsage || 0,
+            interactionDensity: 0,
+            timePeriod: options.timePeriod || 'last 10 minutes'
+        },
+        temporalPatterns: [],
+        analysisTime: new Date().toISOString()
+    };
+};
+/**
+ * Creates a payload for MXF tool list request events
+ */
+export const createMxfToolListPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'MXF_CLIENT',
+    data,
+});
+/**
+ * Creates a payload for MXF tool list result events
+ */
+export const createMxfToolListResultPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'MXF_SERVICE',
+    data,
+});
+/**
+ * Creates a payload for MXF tool list error events
+ */
+export const createMxfToolListErrorPayload = (eventType, agentId, channelId, data) => ({
+    eventId: uuidv4(),
+    eventType,
+    timestamp: Date.now(),
+    agentId,
+    channelId,
+    source: 'MXF_SERVICE',
+    data,
+});
+/**
+ * Creates an MXP token optimization event payload
+ */
+export function createMxpTokenOptimizationEventPayload(eventType, agentId, channelId, data, options = {}) {
+    const validator = createStrictValidator('createMxpTokenOptimizationEventPayload');
+    validator.assertIsNonEmptyString(data.operationId, 'operationId');
+    validator.assertIsNumber(data.originalTokens, 'originalTokens must be a number');
+    validator.assertIsNumber(data.optimizedTokens, 'optimizedTokens must be a number');
+    validator.assertIsNumber(data.compressionRatio, 'compressionRatio must be a number');
+    return createBaseEventPayload(eventType, agentId, channelId, data, options);
+}
+/**
+ * Creates an MXP bandwidth optimization event payload
+ */
+export function createMxpBandwidthOptimizationEventPayload(eventType, agentId, channelId, data, options = {}) {
+    const validator = createStrictValidator('createMxpBandwidthOptimizationEventPayload');
+    validator.assertIsNonEmptyString(data.operationId, 'operationId');
+    validator.assertIsNumber(data.originalSize, 'originalSize must be a number');
+    validator.assertIsNumber(data.compressedSize, 'compressedSize must be a number');
+    validator.assertIsNumber(data.compressionRatio, 'compressionRatio must be a number');
+    return createBaseEventPayload(eventType, agentId, channelId, data, options);
+}
+/**
+ * Creates an MXP security event payload
+ */
+export function createMxpSecurityEventPayload(eventType, agentId, channelId, data, options = {}) {
+    const validator = createStrictValidator('createMxpSecurityEventPayload');
+    validator.assertIsNonEmptyString(data.newLevel, 'newLevel');
+    validator.assertIsNumber(data.timestamp, 'timestamp must be a number');
+    return createBaseEventPayload(eventType, agentId, channelId, data, options);
+}
+/**
+ * Creates an MXP analytics event payload
+ */
+export function createMxpAnalyticsEventPayload(eventType, agentId, channelId, data, options = {}) {
+    const validator = createStrictValidator('createMxpAnalyticsEventPayload');
+    validator.assertIsNonEmptyString(data.metricType, 'metricType');
+    validator.assertIsNumber(data.value, 'value must be a number');
+    validator.assertIsNonEmptyString(data.unit, 'unit');
+    validator.assertIsNumber(data.timestamp, 'timestamp must be a number');
+    return createBaseEventPayload(eventType, agentId, channelId, data, options);
+}
+/**
+ * Creates a Meilisearch indexing event payload
+ */
+export function createMeilisearchIndexEventPayload(eventType, agentId, channelId, data, options = {}) {
+    const validator = createStrictValidator('createMeilisearchIndexEventPayload');
+    validator.assertIsNonEmptyString(data.operationId, 'operationId');
+    validator.assertIsNonEmptyString(data.indexName, 'indexName');
+    validator.assertIsNonEmptyString(data.documentId, 'documentId');
+    validator.assertIsNonEmptyString(data.documentType, 'documentType');
+    validator.assertIsBoolean(data.success);
+    return createBaseEventPayload(eventType, agentId, channelId, data, options);
+}
+/**
+ * Creates a Meilisearch search event payload
+ */
+export function createMeilisearchSearchEventPayload(eventType, agentId, channelId, data, options = {}) {
+    const validator = createStrictValidator('createMeilisearchSearchEventPayload');
+    validator.assertIsNonEmptyString(data.operationId, 'operationId');
+    validator.assertIsNonEmptyString(data.indexName, 'indexName');
+    validator.assertIsNonEmptyString(data.query, 'query');
+    validator.assertIsNumber(data.resultCount, 'resultCount must be a number');
+    validator.assertIsNumber(data.duration, 'duration must be a number');
+    validator.assertIsBoolean(data.success);
+    return createBaseEventPayload(eventType, agentId, channelId, data, options);
+}
+/**
+ * Creates a Meilisearch backfill event payload
+ */
+export function createMeilisearchBackfillEventPayload(eventType, agentId, channelId, data, options = {}) {
+    const validator = createStrictValidator('createMeilisearchBackfillEventPayload');
+    validator.assertIsNonEmptyString(data.operationId, 'operationId');
+    validator.assertIsNonEmptyString(data.indexName, 'indexName');
+    validator.assertIsNumber(data.totalDocuments, 'totalDocuments must be a number');
+    validator.assertIsNumber(data.indexedDocuments, 'indexedDocuments must be a number');
+    validator.assertIsNumber(data.failedDocuments, 'failedDocuments must be a number');
+    validator.assertIsNumber(data.duration, 'duration must be a number');
+    validator.assertIsBoolean(data.success);
+    validator.assertIsNonEmptyString(data.source, 'source');
+    return createBaseEventPayload(eventType, agentId, channelId, data, options);
+}
+// --- Plan Event Payload Creator Helpers ---
+/**
+ * Creates a PlanStepCompletedEventPayload.
+ * Used when a plan step is marked as completed.
+ *
+ * @param eventType - The specific event type (e.g., Events.Plan.PLAN_STEP_COMPLETED).
+ * @param agentId - The Agent ID that completed the step.
+ * @param channelId - The Channel ID context for this plan event.
+ * @param planStepData - The specific data for the plan step completion.
+ * @param options - Optional base event payload options.
+ * @returns A BaseEventPayload with PlanStepCompletedEventData.
+ */
+export function createPlanStepCompletedEventPayload(eventType, agentId, channelId, planStepData, options = {}) {
+    const validator = createStrictValidator('createPlanStepCompletedEventPayload');
+    validator.assertIsObject(planStepData, 'planStepData');
+    validator.assertIsNonEmptyString(planStepData.planId, 'planStepData.planId');
+    validator.assertIsNonEmptyString(planStepData.stepId, 'planStepData.stepId');
+    validator.assertIsNonEmptyString(planStepData.completedBy, 'planStepData.completedBy');
+    return createBaseEventPayload(eventType, agentId, channelId, planStepData, options);
+}
+/**
+ * Creates a MemoryQValueUpdatedEventPayload.
+ * Used when a single Q-value is updated in the MULS system.
+ *
+ * @param agentId - The Agent ID context for this update (or 'system' if no agent context).
+ * @param channelId - The Channel ID context for this update (or 'global' if no channel context).
+ * @param data - The specific data for the Q-value update event.
+ * @param options - Optional base event payload options.
+ * @returns A BaseEventPayload with MemoryQValueUpdatedEventData.
+ */
+export function createMemoryQValueUpdatedPayload(agentId, channelId, data, options = {}) {
+    const validator = createStrictValidator('createMemoryQValueUpdatedPayload');
+    validator.assertIsNonEmptyString(agentId, 'agentId is required');
+    validator.assertIsNonEmptyString(channelId, 'channelId is required');
+    validator.assertIsNonEmptyString(data.memoryId, 'data.memoryId is required');
+    return createBaseEventPayload('memory:qvalue_updated', agentId, channelId, data, options);
+}
+/**
+ * Creates a MemoryQValueBatchUpdatedEventPayload.
+ * Used when multiple Q-values are updated in a batch.
+ *
+ * @param agentId - The Agent ID context for this batch update (or 'system' if no agent context).
+ * @param channelId - The Channel ID context for this batch update (or 'global' if no channel context).
+ * @param data - The specific data for the batch Q-value update event.
+ * @param options - Optional base event payload options.
+ * @returns A BaseEventPayload with MemoryQValueBatchUpdatedEventData.
+ */
+export function createMemoryQValueBatchUpdatedPayload(agentId, channelId, data, options = {}) {
+    const validator = createStrictValidator('createMemoryQValueBatchUpdatedPayload');
+    validator.assertIsNonEmptyString(agentId, 'agentId is required');
+    validator.assertIsNonEmptyString(channelId, 'channelId is required');
+    return createBaseEventPayload('memory:qvalue_batch_updated', agentId, channelId, data, options);
+}
+/**
+ * Creates a MemoryRewardAttributedEventPayload.
+ * Used when rewards are attributed to memories after task completion.
+ *
+ * @param agentId - The Agent ID context for this reward attribution (or 'system' if no agent context).
+ * @param channelId - The Channel ID context for this reward attribution (or 'global' if no channel context).
+ * @param data - The specific data for the reward attribution event.
+ * @param options - Optional base event payload options.
+ * @returns A BaseEventPayload with MemoryRewardAttributedEventData.
+ */
+export function createMemoryRewardAttributedPayload(agentId, channelId, data, options = {}) {
+    const validator = createStrictValidator('createMemoryRewardAttributedPayload');
+    validator.assertIsNonEmptyString(agentId, 'agentId is required');
+    validator.assertIsNonEmptyString(channelId, 'channelId is required');
+    return createBaseEventPayload('memory:reward_attributed', agentId, channelId, data, options);
+}
+// ============================================================================
+// ORPAR-Memory Integration Event Payload Helpers
+// ============================================================================
+/**
+ * Creates an ORPAR-Memory Cycle Started event payload.
+ * Emitted when a new ORPAR cycle begins with memory integration enabled.
+ *
+ * @param agentId - The Agent ID starting the cycle.
+ * @param channelId - The Channel ID context for this cycle.
+ * @param data - The cycle started event data.
+ * @param options - Optional base event payload options.
+ * @returns A BaseEventPayload with CycleStartedEventData.
+ */
+export function createOrparMemoryCycleStartedPayload(agentId, channelId, data, options = {}) {
+    const validator = createStrictValidator('createOrparMemoryCycleStartedPayload');
+    validator.assertIsNonEmptyString(agentId, 'agentId is required');
+    validator.assertIsNonEmptyString(channelId, 'channelId is required');
+    validator.assertIsNonEmptyString(data.cycleId, 'data.cycleId is required');
+    validator.assertIsNonEmptyString(data.initialPhase, 'data.initialPhase is required');
+    return createBaseEventPayload(OrparMemoryEvents.CYCLE_STARTED, agentId, channelId, data, options);
+}
+/**
+ * Creates an ORPAR-Memory Phase Changed event payload.
+ * Emitted when an ORPAR cycle transitions to a new phase.
+ *
+ * @param agentId - The Agent ID in the cycle.
+ * @param channelId - The Channel ID context for this cycle.
+ * @param data - The phase changed event data.
+ * @param options - Optional base event payload options.
+ * @returns A BaseEventPayload with PhaseChangedEventData.
+ */
+export function createOrparMemoryPhaseChangedPayload(agentId, channelId, data, options = {}) {
+    const validator = createStrictValidator('createOrparMemoryPhaseChangedPayload');
+    validator.assertIsNonEmptyString(agentId, 'agentId is required');
+    validator.assertIsNonEmptyString(channelId, 'channelId is required');
+    validator.assertIsNonEmptyString(data.cycleId, 'data.cycleId is required');
+    validator.assertIsNonEmptyString(data.newPhase, 'data.newPhase is required');
+    return createBaseEventPayload(OrparMemoryEvents.PHASE_CHANGED, agentId, channelId, data, options);
+}
+/**
+ * Creates an ORPAR-Memory Cycle Completed event payload.
+ * Emitted when an ORPAR cycle finishes and triggers reward attribution/consolidation.
+ *
+ * @param agentId - The Agent ID that completed the cycle.
+ * @param channelId - The Channel ID context for this cycle.
+ * @param data - The cycle completed event data.
+ * @param options - Optional base event payload options.
+ * @returns A BaseEventPayload with CycleCompletedEventData.
+ */
+export function createOrparMemoryCycleCompletedPayload(agentId, channelId, data, options = {}) {
+    const validator = createStrictValidator('createOrparMemoryCycleCompletedPayload');
+    validator.assertIsNonEmptyString(agentId, 'agentId is required');
+    validator.assertIsNonEmptyString(channelId, 'channelId is required');
+    validator.assertIsNonEmptyString(data.cycleId, 'data.cycleId is required');
+    return createBaseEventPayload(OrparMemoryEvents.CYCLE_COMPLETED, agentId, channelId, data, options);
+}
+// ============================================================================
+// Task DAG Event Payload Helpers
+// ============================================================================
+/**
+ * Creates a DAG Task Dependencies Resolved event payload.
+ * Emitted when all dependencies for a task have been completed.
+ *
+ * @param channelId - The Channel ID context.
+ * @param agentId - The Agent ID context (or 'system').
+ * @param taskId - The task that is now unblocked.
+ * @param resolvedDependencies - IDs of the dependencies that were resolved.
+ * @param options - Optional base event payload options.
+ * @returns A BaseEventPayload with TaskDependenciesResolvedEventData.
+ */
+export function createDagTaskDependenciesResolvedPayload(channelId, agentId, taskId, resolvedDependencies, options = {}) {
+    const validator = createStrictValidator('createDagTaskDependenciesResolvedPayload');
+    validator.assertIsNonEmptyString(channelId, 'channelId is required');
+    validator.assertIsNonEmptyString(taskId, 'taskId is required');
+    const data = {
+        taskId,
+        channelId,
+        resolvedDependencies,
+        resolvedAt: Date.now(),
+    };
+    return createBaseEventPayload(DagEvents.TASK_DEPENDENCIES_RESOLVED, agentId, channelId, data, options);
+}
+/**
+ * Creates a DAG Task Blocked event payload.
+ * Emitted when a task cannot proceed due to unresolved dependencies.
+ *
+ * @param channelId - The Channel ID context.
+ * @param agentId - The Agent ID context (or 'system').
+ * @param taskId - The task that is blocked.
+ * @param blockingTasks - IDs of the tasks blocking this one.
+ * @param attemptedStatus - The status transition that was attempted.
+ * @param reason - Reason for the block.
+ * @param options - Optional base event payload options.
+ * @returns A BaseEventPayload with TaskBlockedEventData.
+ */
+export function createDagTaskBlockedPayload(channelId, agentId, taskId, blockingTasks, attemptedStatus, reason, options = {}) {
+    const validator = createStrictValidator('createDagTaskBlockedPayload');
+    validator.assertIsNonEmptyString(channelId, 'channelId is required');
+    validator.assertIsNonEmptyString(taskId, 'taskId is required');
+    const data = {
+        taskId,
+        channelId,
+        blockingTasks,
+        attemptedStatus,
+        reason,
+    };
+    return createBaseEventPayload(DagEvents.TASK_BLOCKED, agentId, channelId, data, options);
+}
+/**
+ * Creates a DAG Task Unblocked event payload.
+ * Emitted when a blocking dependency is resolved.
+ *
+ * @param channelId - The Channel ID context.
+ * @param agentId - The Agent ID context (or 'system').
+ * @param taskId - The task that was unblocked.
+ * @param resolvedDependency - The dependency that was resolved.
+ * @param remainingBlockers - Remaining blocking tasks (if any).
+ * @param isReady - Whether the task is now fully ready.
+ * @param options - Optional base event payload options.
+ * @returns A BaseEventPayload with TaskUnblockedEventData.
+ */
+export function createDagTaskUnblockedPayload(channelId, agentId, taskId, resolvedDependency, remainingBlockers, isReady, options = {}) {
+    const validator = createStrictValidator('createDagTaskUnblockedPayload');
+    validator.assertIsNonEmptyString(channelId, 'channelId is required');
+    validator.assertIsNonEmptyString(taskId, 'taskId is required');
+    const data = {
+        taskId,
+        channelId,
+        resolvedDependency,
+        remainingBlockers,
+        isReady,
+    };
+    return createBaseEventPayload(DagEvents.TASK_UNBLOCKED, agentId, channelId, data, options);
+}
+/**
+ * Creates a DAG Cycle Detected event payload.
+ * Emitted when a dependency would create a cycle.
+ *
+ * @param channelId - The Channel ID where the cycle was detected.
+ * @param agentId - The Agent ID context (or 'system').
+ * @param dependentTaskId - The dependency that would create the cycle.
+ * @param dependencyTaskId - The dependency task that would complete the cycle.
+ * @param cyclePath - The full cycle path.
+ * @param cycleDescription - Human-readable description of the cycle.
+ * @param options - Optional base event payload options.
+ * @returns A BaseEventPayload with CycleDetectedEventData.
+ */
+export function createDagCycleDetectedPayload(channelId, agentId, dependentTaskId, dependencyTaskId, cyclePath, cycleDescription, options = {}) {
+    const validator = createStrictValidator('createDagCycleDetectedPayload');
+    validator.assertIsNonEmptyString(channelId, 'channelId is required');
+    const data = {
+        channelId,
+        dependentTaskId,
+        dependencyTaskId,
+        cyclePath,
+        cycleDescription,
+    };
+    return createBaseEventPayload(DagEvents.CYCLE_DETECTED, agentId, channelId, data, options);
+}
+/**
+ * Creates a DAG Updated event payload.
+ * Emitted when the DAG structure changes.
+ *
+ * @param channelId - The Channel ID whose DAG was updated.
+ * @param agentId - The Agent ID context (or 'system').
+ * @param updateType - Type of update.
+ * @param affectedTaskIds - Affected task IDs.
+ * @param version - New DAG version.
+ * @param options - Optional base event payload options.
+ * @returns A BaseEventPayload with DagUpdatedEventData.
+ */
+export function createDagUpdatedPayload(channelId, agentId, updateType, affectedTaskIds, version, options = {}) {
+    const validator = createStrictValidator('createDagUpdatedPayload');
+    validator.assertIsNonEmptyString(channelId, 'channelId is required');
+    const data = {
+        channelId,
+        updateType,
+        affectedTaskIds,
+        version,
+    };
+    return createBaseEventPayload(DagEvents.DAG_UPDATED, agentId, channelId, data, options);
+}
+/**
+ * Creates a DAG Dependency Added event payload.
+ * Emitted when a dependency is added to the DAG.
+ *
+ * @param channelId - The Channel ID context.
+ * @param agentId - The Agent ID context (or 'system').
+ * @param edgeId - The edge ID.
+ * @param dependentTaskId - The dependent task.
+ * @param dependencyTaskId - The dependency task.
+ * @param label - Optional label for the dependency.
+ * @param options - Optional base event payload options.
+ * @returns A BaseEventPayload with DependencyAddedEventData.
+ */
+export function createDagDependencyAddedPayload(channelId, agentId, edgeId, dependentTaskId, dependencyTaskId, label, options = {}) {
+    const validator = createStrictValidator('createDagDependencyAddedPayload');
+    validator.assertIsNonEmptyString(channelId, 'channelId is required');
+    const data = {
+        edgeId,
+        dependentTaskId,
+        dependencyTaskId,
+        channelId,
+        label,
+    };
+    return createBaseEventPayload(DagEvents.DEPENDENCY_ADDED, agentId, channelId, data, options);
+}
+/**
+ * Creates a DAG Dependency Removed event payload.
+ * Emitted when a dependency is removed from the DAG.
+ *
+ * @param channelId - The Channel ID context.
+ * @param agentId - The Agent ID context (or 'system').
+ * @param edgeId - The edge ID.
+ * @param dependentTaskId - The dependent task.
+ * @param dependencyTaskId - The dependency task.
+ * @param options - Optional base event payload options.
+ * @returns A BaseEventPayload with DependencyRemovedEventData.
+ */
+export function createDagDependencyRemovedPayload(channelId, agentId, edgeId, dependentTaskId, dependencyTaskId, options = {}) {
+    const validator = createStrictValidator('createDagDependencyRemovedPayload');
+    validator.assertIsNonEmptyString(channelId, 'channelId is required');
+    const data = {
+        edgeId,
+        dependentTaskId,
+        dependencyTaskId,
+        channelId,
+    };
+    return createBaseEventPayload(DagEvents.DEPENDENCY_REMOVED, agentId, channelId, data, options);
+}
+// ─── TensorFlow.js Event Payload Helpers ────────────────────────────────────
+/**
+ * Create a model registered event payload.
+ *
+ * @param channelId - Channel context (use 'system' for server-level events)
+ * @param agentId - Agent context (use 'system' for server-level events)
+ * @param modelId - The registered model ID
+ * @param type - Model architecture type
+ * @param inputShape - Model input shape
+ * @param outputShape - Model output shape
+ * @param options - Optional base event payload options
+ * @returns A BaseEventPayload with ModelRegisteredEventData
+ */
+export function createTfModelRegisteredPayload(channelId, agentId, modelId, type, inputShape, outputShape, options = {}) {
+    const validator = createStrictValidator('createTfModelRegisteredPayload');
+    validator.assertIsNonEmptyString(modelId, 'modelId is required');
+    const data = {
+        modelId,
+        type,
+        inputShape,
+        outputShape,
+    };
+    return createBaseEventPayload(TensorFlowEvents.MODEL_REGISTERED, agentId, channelId, data, options);
+}
+/**
+ * Create a model training started event payload.
+ *
+ * @param channelId - Channel context
+ * @param agentId - Agent context
+ * @param modelId - The model being trained
+ * @param trainingSamples - Number of training samples
+ * @param epochs - Number of training epochs
+ * @param options - Optional base event payload options
+ * @returns A BaseEventPayload with ModelTrainingStartedEventData
+ */
+export function createTfModelTrainingStartedPayload(channelId, agentId, modelId, trainingSamples, epochs, options = {}) {
+    const validator = createStrictValidator('createTfModelTrainingStartedPayload');
+    validator.assertIsNonEmptyString(modelId, 'modelId is required');
+    const data = {
+        modelId,
+        trainingSamples,
+        epochs,
+    };
+    return createBaseEventPayload(TensorFlowEvents.MODEL_TRAINING_STARTED, agentId, channelId, data, options);
+}
+/**
+ * Create a model training completed event payload.
+ *
+ * @param channelId - Channel context
+ * @param agentId - Agent context
+ * @param modelId - The model that completed training
+ * @param loss - Final training loss
+ * @param durationMs - Training duration in milliseconds
+ * @param samplesUsed - Number of training samples used
+ * @param extras - Optional valLoss and accuracy
+ * @param options - Optional base event payload options
+ * @returns A BaseEventPayload with ModelTrainingCompletedEventData
+ */
+export function createTfModelTrainingCompletedPayload(channelId, agentId, modelId, loss, durationMs, samplesUsed, extras = {}, options = {}) {
+    const validator = createStrictValidator('createTfModelTrainingCompletedPayload');
+    validator.assertIsNonEmptyString(modelId, 'modelId is required');
+    const data = {
+        modelId,
+        loss,
+        valLoss: extras.valLoss,
+        accuracy: extras.accuracy,
+        durationMs,
+        samplesUsed,
+    };
+    return createBaseEventPayload(TensorFlowEvents.MODEL_TRAINING_COMPLETED, agentId, channelId, data, options);
+}
+/**
+ * Create a model training failed event payload.
+ *
+ * @param channelId - Channel context
+ * @param agentId - Agent context
+ * @param modelId - The model that failed training
+ * @param error - Error message
+ * @param trainingSamples - Number of training samples attempted
+ * @param options - Optional base event payload options
+ * @returns A BaseEventPayload with ModelTrainingFailedEventData
+ */
+export function createTfModelTrainingFailedPayload(channelId, agentId, modelId, error, trainingSamples, options = {}) {
+    const validator = createStrictValidator('createTfModelTrainingFailedPayload');
+    validator.assertIsNonEmptyString(modelId, 'modelId is required');
+    const data = {
+        modelId,
+        error,
+        trainingSamples,
+    };
+    return createBaseEventPayload(TensorFlowEvents.MODEL_TRAINING_FAILED, agentId, channelId, data, options);
+}
+/**
+ * Create a model loaded event payload.
+ *
+ * @param channelId - Channel context
+ * @param agentId - Agent context
+ * @param modelId - The loaded model ID
+ * @param source - Storage source (e.g., 'gridfs://model_id' or 'file://path')
+ * @param options - Optional base event payload options
+ * @returns A BaseEventPayload with ModelLoadedEventData
+ */
+export function createTfModelLoadedPayload(channelId, agentId, modelId, source, options = {}) {
+    const validator = createStrictValidator('createTfModelLoadedPayload');
+    validator.assertIsNonEmptyString(modelId, 'modelId is required');
+    const data = {
+        modelId,
+        source,
+    };
+    return createBaseEventPayload(TensorFlowEvents.MODEL_LOADED, agentId, channelId, data, options);
+}
+/**
+ * Create a model saved event payload.
+ *
+ * @param channelId - Channel context
+ * @param agentId - Agent context
+ * @param modelId - The saved model ID
+ * @param destination - Storage destination
+ * @param sizeBytes - Optional model size in bytes
+ * @param options - Optional base event payload options
+ * @returns A BaseEventPayload with ModelSavedEventData
+ */
+export function createTfModelSavedPayload(channelId, agentId, modelId, destination, sizeBytes, options = {}) {
+    const validator = createStrictValidator('createTfModelSavedPayload');
+    validator.assertIsNonEmptyString(modelId, 'modelId is required');
+    const data = {
+        modelId,
+        destination,
+        sizeBytes,
+    };
+    return createBaseEventPayload(TensorFlowEvents.MODEL_SAVED, agentId, channelId, data, options);
+}
+/**
+ * Create an inference completed event payload.
+ *
+ * @param channelId - Channel context
+ * @param agentId - Agent context
+ * @param modelId - The model used for inference
+ * @param latencyMs - Inference latency in milliseconds
+ * @param inferenceSource - Whether result came from 'model' or 'heuristic'
+ * @param options - Optional base event payload options
+ * @returns A BaseEventPayload with InferenceCompletedEventData
+ */
+export function createTfInferenceCompletedPayload(channelId, agentId, modelId, latencyMs, inferenceSource, options = {}) {
+    const validator = createStrictValidator('createTfInferenceCompletedPayload');
+    validator.assertIsNonEmptyString(modelId, 'modelId is required');
+    const data = {
+        modelId,
+        latencyMs,
+        source: inferenceSource,
+    };
+    return createBaseEventPayload(TensorFlowEvents.INFERENCE_COMPLETED, agentId, channelId, data, options);
+}
+/**
+ * Create an inference fallback event payload.
+ *
+ * @param channelId - Channel context
+ * @param agentId - Agent context
+ * @param modelId - The model that was unavailable
+ * @param reason - Why the fallback was used
+ * @param error - Optional error message
+ * @param options - Optional base event payload options
+ * @returns A BaseEventPayload with InferenceFallbackEventData
+ */
+export function createTfInferenceFallbackPayload(channelId, agentId, modelId, reason, error, options = {}) {
+    const validator = createStrictValidator('createTfInferenceFallbackPayload');
+    validator.assertIsNonEmptyString(modelId, 'modelId is required');
+    const data = {
+        modelId,
+        reason,
+        error,
+    };
+    return createBaseEventPayload(TensorFlowEvents.INFERENCE_FALLBACK, agentId, channelId, data, options);
+}
+/**
+ * Create a memory warning event payload.
+ *
+ * @param channelId - Channel context
+ * @param agentId - Agent context
+ * @param numTensors - Number of tensors currently allocated
+ * @param numBytes - Total bytes used
+ * @param maxBytes - Configured memory threshold
+ * @param utilizationPercent - Memory utilization percentage
+ * @param options - Optional base event payload options
+ * @returns A BaseEventPayload with MemoryWarningEventData
+ */
+export function createTfMemoryWarningPayload(channelId, agentId, numTensors, numBytes, maxBytes, utilizationPercent, options = {}) {
+    const data = {
+        numTensors,
+        numBytes,
+        maxBytes,
+        utilizationPercent,
+    };
+    return createBaseEventPayload(TensorFlowEvents.MEMORY_WARNING, agentId, channelId, data, options);
+}
+/**
+ * Create a memory stats event payload.
+ *
+ * @param channelId - Channel context
+ * @param agentId - Agent context
+ * @param numTensors - Number of tensors
+ * @param numDataBuffers - Number of data buffers
+ * @param numBytes - Total bytes used
+ * @param timestamp - When stats were collected
+ * @param options - Optional base event payload options
+ * @returns A BaseEventPayload with MemoryStatsEventData
+ */
+export function createTfMemoryStatsPayload(channelId, agentId, numTensors, numDataBuffers, numBytes, timestamp, options = {}) {
+    const data = {
+        numTensors,
+        numDataBuffers,
+        numBytes,
+        timestamp,
+    };
+    return createBaseEventPayload(TensorFlowEvents.MEMORY_STATS, agentId, channelId, data, options);
+}
+/**
+ * Creates a UserInputRequestEventPayload for prompting a user for input.
+ *
+ * @param agentId - Agent that initiated the request
+ * @param channelId - Channel context for the request
+ * @param requestData - The full user input request definition
+ * @param options - Optional base event payload options
+ * @returns A UserInputRequestEventPayload
+ */
+export function createUserInputRequestPayload(agentId, channelId, requestData, options = {}) {
+    const validator = createStrictValidator('UserInputRequestPayload');
+    validator.assertIsNonEmptyString(requestData.requestId, 'requestId is required');
+    validator.assertIsNonEmptyString(requestData.title, 'title is required');
+    validator.assertIsNonEmptyString(requestData.inputType, 'inputType is required');
+    return createBaseEventPayload(UserInputEvents.REQUEST, agentId, channelId, requestData, options);
+}
+/**
+ * Creates a UserInputResponseEventPayload for a user's response to an input request.
+ *
+ * @param agentId - Agent context for the response
+ * @param channelId - Channel context for the response
+ * @param responseData - The user's response data
+ * @param options - Optional base event payload options
+ * @returns A UserInputResponseEventPayload
+ */
+export function createUserInputResponsePayload(agentId, channelId, responseData, options = {}) {
+    const validator = createStrictValidator('UserInputResponsePayload');
+    validator.assertIsNonEmptyString(responseData.requestId, 'requestId is required');
+    return createBaseEventPayload(UserInputEvents.RESPONSE, agentId, channelId, responseData, options);
+}
+/**
+ * Creates a UserInputCancelledEventPayload for notifying clients that a request was cancelled.
+ *
+ * @param agentId - Agent that initiated the original request
+ * @param channelId - Channel context for the request
+ * @param cancelledData - The cancellation details
+ * @param options - Optional base event payload options
+ * @returns A UserInputCancelledEventPayload
+ */
+export function createUserInputCancelledPayload(agentId, channelId, cancelledData, options = {}) {
+    const validator = createStrictValidator('UserInputCancelledPayload');
+    validator.assertIsNonEmptyString(cancelledData.requestId, 'requestId is required');
+    validator.assertIsNonEmptyString(cancelledData.reason, 'reason is required');
+    return createBaseEventPayload(UserInputEvents.CANCELLED, agentId, channelId, cancelledData, options);
+}
+/**
+ * Creates a UserInputTimeoutEventPayload for notifying clients that a request timed out.
+ *
+ * @param agentId - Agent that initiated the original request
+ * @param channelId - Channel context for the request
+ * @param timeoutData - The timeout details
+ * @param options - Optional base event payload options
+ * @returns A UserInputTimeoutEventPayload
+ */
+export function createUserInputTimeoutPayload(agentId, channelId, timeoutData, options = {}) {
+    const validator = createStrictValidator('UserInputTimeoutPayload');
+    validator.assertIsNonEmptyString(timeoutData.requestId, 'requestId is required');
+    return createBaseEventPayload(UserInputEvents.TIMEOUT, agentId, channelId, timeoutData, options);
+}
+/**
+ * Creates a MicrocompactionAppliedEventPayload for tool result stripping events.
+ *
+ * @param agentId - Agent whose context was microcompacted
+ * @param channelId - Channel context
+ * @param data - Microcompaction details (tool results stripped, tokens removed)
+ * @param options - Optional base event payload options
+ * @returns A MicrocompactionAppliedEventPayload
+ */
+export function createMicrocompactionAppliedPayload(agentId, channelId, data, options = {}) {
+    return createBaseEventPayload(CompactionEvents.MICROCOMPACTION_APPLIED, agentId, channelId, {
+        eventType: CompactionEvents.MICROCOMPACTION_APPLIED,
+        agentId,
+        channelId,
+        timestamp: options.timestamp || Date.now(),
+        ...data,
+    }, options);
+}
+/**
+ * Creates an AutoCompactionTriggeredEventPayload for threshold-based compaction events.
+ *
+ * @param agentId - Agent whose context was compacted
+ * @param channelId - Channel context
+ * @param data - Auto-compaction details (usage percent, message/token counts)
+ * @param options - Optional base event payload options
+ * @returns An AutoCompactionTriggeredEventPayload
+ */
+export function createAutoCompactionTriggeredPayload(agentId, channelId, data, options = {}) {
+    return createBaseEventPayload(CompactionEvents.AUTO_COMPACTION_TRIGGERED, agentId, channelId, {
+        eventType: CompactionEvents.AUTO_COMPACTION_TRIGGERED,
+        agentId,
+        channelId,
+        timestamp: options.timestamp || Date.now(),
+        ...data,
+    }, options);
+}
+/**
+ * Creates a ReactiveCompactionTriggeredEventPayload for 413 error recovery events.
+ *
+ * @param agentId - Agent whose context overflowed
+ * @param channelId - Channel context
+ * @param data - Reactive compaction details (status code, strategy, token counts)
+ * @param options - Optional base event payload options
+ * @returns A ReactiveCompactionTriggeredEventPayload
+ */
+export function createReactiveCompactionTriggeredPayload(agentId, channelId, data, options = {}) {
+    return createBaseEventPayload(CompactionEvents.REACTIVE_COMPACTION_TRIGGERED, agentId, channelId, {
+        eventType: CompactionEvents.REACTIVE_COMPACTION_TRIGGERED,
+        agentId,
+        channelId,
+        timestamp: options.timestamp || Date.now(),
+        ...data,
+    }, options);
+}
+/**
+ * Creates a PostCompactionRestoredEventPayload for artifact restoration events.
+ *
+ * @param agentId - Agent whose context was restored
+ * @param channelId - Channel context
+ * @param data - Restoration details (artifact count, names, tokens added)
+ * @param options - Optional base event payload options
+ * @returns A PostCompactionRestoredEventPayload
+ */
+export function createPostCompactionRestoredPayload(agentId, channelId, data, options = {}) {
+    return createBaseEventPayload(CompactionEvents.POST_COMPACTION_RESTORED, agentId, channelId, {
+        eventType: CompactionEvents.POST_COMPACTION_RESTORED,
+        agentId,
+        channelId,
+        timestamp: options.timestamp || Date.now(),
+        ...data,
+    }, options);
+}
+/**
+ * Creates a CompactionSummaryGeneratedEventPayload for summary generation events.
+ *
+ * @param agentId - Agent whose context was summarized
+ * @param channelId - Channel context
+ * @param data - Summary details (method, messages summarized, sections, tokens)
+ * @param options - Optional base event payload options
+ * @returns A CompactionSummaryGeneratedEventPayload
+ */
+export function createCompactionSummaryGeneratedPayload(agentId, channelId, data, options = {}) {
+    return createBaseEventPayload(CompactionEvents.COMPACTION_SUMMARY_GENERATED, agentId, channelId, {
+        eventType: CompactionEvents.COMPACTION_SUMMARY_GENERATED,
+        agentId,
+        channelId,
+        timestamp: options.timestamp || Date.now(),
+        ...data,
+    }, options);
+}
+//# sourceMappingURL=EventPayloadSchema.js.map