@mxf-dev/core 1.0.0

package/dist/schemas/EventPayloadSchema.d.ts

@@ -0,0 +1,2467 @@
+/**
+ * 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/
+ */
+/**
+ * EventPayloadSchema.ts
+ *
+ * Defines standardized event payload schemas used throughout the Model Exchange Framework.
+ * These schemas provide a consistent structure for all events exchanged between components.
+ */
+import type { IAgentMemory, IChannelMemory, IRelationshipMemory } from '../types/MemoryTypes.js';
+import type { Observation, Reasoning, Plan, PlanAction } from '../types/ControlLoopTypes.js';
+import type { ChannelActionType, EventName, Events, PlanStepCompletedEventData } from '../events/EventNames.js';
+import { AgentId, ChannelId } from '../types/ChannelContext.js';
+import { MemoryScope } from '../types/MemoryTypes.js';
+import { ChannelMessage, AgentMessage } from './MessageSchemas.js';
+import { CycleStartedEventData, PhaseChangedEventData, CycleCompletedEventData } from '../events/event-definitions/OrparMemoryEvents.js';
+import { TaskDependenciesResolvedEventData, TaskBlockedEventData, TaskUnblockedEventData, CycleDetectedEventData, DagUpdatedEventData, DependencyAddedEventData, DependencyRemovedEventData } from '../events/event-definitions/DagEvents.js';
+import { ModelRegisteredEventData, ModelTrainingStartedEventData, ModelTrainingCompletedEventData, ModelTrainingFailedEventData, ModelLoadedEventData, ModelSavedEventData, InferenceCompletedEventData, InferenceFallbackEventData, MemoryWarningEventData, MemoryStatsEventData } from '../events/event-definitions/TensorFlowEvents.js';
+import { UserInputRequestData, UserInputResponseData, UserInputCancelledData, UserInputTimeoutData } from '../events/event-definitions/UserInputEvents.js';
+import { MicrocompactionAppliedPayload, AutoCompactionTriggeredPayload, ReactiveCompactionTriggeredPayload, PostCompactionRestoredPayload, CompactionSummaryGeneratedPayload } from '../events/event-definitions/CompactionEvents.js';
+/** Agent ID for system-level events not tied to a specific agent (e.g., MxfMLService, PredictiveAnalyticsService) */
+export declare const SYSTEM_AGENT_ID: AgentId;
+/** Channel ID for system-level events not tied to a specific channel */
+export declare const SYSTEM_CHANNEL_ID: ChannelId;
+/**
+ * Base interface for all event payloads.
+ * Enforces mandatory fields for all events in the system.
+ */
+export interface BaseEventPayload<TData = any> {
+    eventId: string;
+    eventType: EventName | string;
+    timestamp: number;
+    agentId: AgentId;
+    channelId: ChannelId;
+    source?: string;
+    isRecursionProtection?: boolean;
+    data: TData;
+}
+/**
+ * Data for connection-related events.
+ */
+export interface ConnectionEventData {
+    connectionId: string;
+    status: 'connected' | 'disconnected' | 'error';
+    error?: string;
+}
+export type ConnectionEventPayload = BaseEventPayload<ConnectionEventData>;
+/**
+ * Data for agent-related events (e.g., registration, status changes not covered by simple connection status).
+ */
+export interface AgentEventData {
+    name?: string;
+    type?: string;
+    capabilities?: string[];
+    status?: string;
+    metadata?: Record<string, any>;
+    [key: string]: any;
+}
+export type AgentEventPayload = BaseEventPayload<AgentEventData>;
+/**
+ * Data for LLM reasoning events - captures reasoning tokens from advanced models
+ */
+export interface LlmReasoningEventData {
+    reasoning: string;
+    modelName?: string;
+    reasoningTokens?: number;
+    provider?: string;
+    config?: {
+        effort?: 'low' | 'medium' | 'high';
+        maxTokens?: number;
+        exclude?: boolean;
+    };
+    timestamp?: number;
+    metadata?: Record<string, any>;
+}
+export type LlmReasoningEventPayload = BaseEventPayload<LlmReasoningEventData>;
+/**
+ * Data for LLM reasoning parsed events - when reasoning text is parsed for tool intentions
+ */
+export interface LlmReasoningParsedEventData {
+    reasoning: string;
+    toolIntentions: Array<{
+        toolName: string;
+        arguments: Record<string, any>;
+        confidence: number;
+        reasoning: string;
+    }>;
+    parseMethod: 'structured' | 'heuristic' | 'failed';
+    toolCount: number;
+    parseSuccessful: boolean;
+    metadata?: Record<string, any>;
+}
+export type LlmReasoningParsedEventPayload = BaseEventPayload<LlmReasoningParsedEventData>;
+/**
+ * Data for LLM reasoning tools synthesized events - when tool_calls are created from reasoning
+ */
+export interface LlmReasoningToolsSynthesizedEventData {
+    toolCalls: Array<{
+        type: string;
+        id: string;
+        name: string;
+        input: Record<string, any>;
+    }>;
+    toolIntentions: Array<{
+        toolName: string;
+        arguments: Record<string, any>;
+        confidence: number;
+        reasoning: string;
+    }>;
+    parseMethod: 'structured' | 'heuristic' | 'failed';
+    synthesisSuccessful: boolean;
+    metadata?: Record<string, any>;
+}
+export type LlmReasoningToolsSynthesizedEventPayload = BaseEventPayload<LlmReasoningToolsSynthesizedEventData>;
+/**
+ * Data for LLM streaming chunk events — partial tokens emitted during streaming responses.
+ * Used by the TUI ThinkingIndicator to show live output preview.
+ */
+export interface LlmStreamChunkEventData {
+    /** The partial text content received in this chunk */
+    chunk: string;
+    /** When this chunk was received */
+    timestamp: number;
+}
+export type LlmStreamChunkEventPayload = BaseEventPayload<LlmStreamChunkEventData>;
+/**
+ * Data for LLM usage events — captures token counts for cost tracking.
+ * Emitted after each LLM response alongside LLM_RESPONSE.
+ */
+export interface LlmUsageEventData {
+    /** Model that generated the response */
+    model: string;
+    /** Number of input (prompt) tokens consumed */
+    inputTokens: number;
+    /** Number of output (completion) tokens generated */
+    outputTokens: number;
+    /** Total tokens consumed (input + output) */
+    totalTokens: number;
+    /** When the usage was recorded */
+    timestamp: number;
+}
+export type LlmUsageEventPayload = BaseEventPayload<LlmUsageEventData>;
+/**
+ * Interface for agent registration events
+ */
+export interface AgentRegistrationEventData {
+    agentId: string;
+    socketId: string;
+    timestamp: number;
+    channelId?: string;
+    capabilities?: string[];
+    status: 'pending' | 'registered' | 'error';
+    error?: string;
+}
+/**
+ * Payload type for agent registration events
+ */
+export type AgentRegistrationEventPayload = BaseEventPayload<AgentRegistrationEventData>;
+/**
+ * Interface for agent connection events
+ */
+export interface AgentConnectionEventData {
+    agentId: string;
+    socketId: string;
+    timestamp: number;
+    channelId?: string;
+    status: 'connecting' | 'connected' | 'error';
+    error?: string;
+}
+/**
+ * Payload type for agent connection events
+ */
+export type AgentConnectionEventPayload = BaseEventPayload<AgentConnectionEventData>;
+/**
+ * Interface for agent join events
+ */
+export interface AgentJoinEventData {
+    agentId: string;
+    channelId: string;
+    timestamp: number;
+}
+/**
+ * Payload type for agent join events
+ */
+export type AgentJoinEventPayload = BaseEventPayload<AgentJoinEventData>;
+/**
+ * Interface for agent leave events
+ */
+export interface AgentLeaveEventData {
+    agentId: string;
+    channelId: string;
+    timestamp: number;
+}
+/**
+ * Payload type for agent leave events
+ */
+export type AgentLeaveEventPayload = BaseEventPayload<AgentLeaveEventData>;
+/**
+ * Data for allowed tools update events.
+ * Used when dynamically changing an agent's allowed tools during runtime.
+ */
+export interface AllowedToolsUpdateEventData {
+    allowedTools: string[];
+}
+/**
+ * Payload type for allowed tools update events
+ */
+export type AllowedToolsUpdateEventPayload = BaseEventPayload<AllowedToolsUpdateEventData>;
+/**
+ * Data for channel-related events (e.g., created, joined, left, deleted).
+ */
+export interface ChannelEventData {
+    name?: string;
+    action: ChannelActionType | 'created' | 'deleted' | 'updated' | 'archived';
+    targetAgentId?: AgentId;
+    metadata?: Record<string, any>;
+    [key: string]: any;
+}
+export type ChannelEventPayload = BaseEventPayload<ChannelEventData>;
+/**
+ * Data for subscription-related events within a channel.
+ */
+export interface SubscriptionEventData {
+    action: 'subscribe' | 'unsubscribe';
+    targetEvent?: EventName | string;
+    [key: string]: any;
+}
+export type SubscriptionEventPayload = BaseEventPayload<SubscriptionEventData>;
+/**
+ * Data for task request events.
+ */
+export interface TaskEventData {
+    taskId: string;
+    fromAgentId?: AgentId;
+    toAgentId?: AgentId;
+    task: any;
+}
+export type TaskEventPayload = BaseEventPayload<TaskEventData>;
+/**
+ * Data for task response events.
+ */
+export interface TaskResponseEventData {
+    taskId: string;
+    fromAgentId?: AgentId;
+    toAgentId?: AgentId;
+    response: any;
+    error?: string;
+}
+export type TaskResponseEventPayload = BaseEventPayload<TaskResponseEventData>;
+/**
+ * Data for task assignment events.
+ */
+export interface TaskAssignmentEventData {
+    taskId: string;
+    assignedAgentId: AgentId;
+    strategy: string;
+    confidence: number;
+    reasoning: string;
+    assignedAt: number;
+    estimatedCompletion?: number;
+    task: any;
+}
+export type TaskAssignmentEventPayload = BaseEventPayload<TaskAssignmentEventData>;
+/**
+ * Data specific to control loop operations and lifecycle.
+ */
+export interface ControlLoopSpecificData {
+    loopId: string;
+    status?: string;
+    config?: Record<string, unknown>;
+    observation?: Observation | null;
+    reasoning?: Reasoning | null;
+    plan?: Plan | null;
+    action?: PlanAction | null;
+    error?: string;
+    context?: {
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+export type ControlLoopEventPayload = BaseEventPayload<ControlLoopSpecificData>;
+/**
+ * Base data for all memory operations.
+ */
+export interface BaseMemoryOperationData {
+    operationId: string;
+    scope: MemoryScope;
+    id: string | string[];
+}
+/**
+ * Data for memory GET request events.
+ */
+export interface MemoryGetEventData extends BaseMemoryOperationData {
+    key?: string;
+    filters?: Record<string, any>;
+}
+export type MemoryGetEventPayload = BaseEventPayload<MemoryGetEventData>;
+/**
+ * Data for memory GET result events.
+ */
+export interface MemoryGetResultEventData extends BaseMemoryOperationData {
+    key?: string;
+    memory: IAgentMemory | IChannelMemory | IRelationshipMemory | Record<string, unknown> | null;
+    error?: string;
+}
+export type MemoryGetResultEventPayload = BaseEventPayload<MemoryGetResultEventData>;
+/**
+ * Data for memory UPDATE request events.
+ */
+export interface MemoryUpdateEventData extends BaseMemoryOperationData {
+    data: Record<string, any>;
+    metadata?: Record<string, any>;
+}
+export type MemoryUpdateEventPayload = BaseEventPayload<MemoryUpdateEventData>;
+/**
+ * Data for memory UPDATE result events.
+ */
+export interface MemoryUpdateResultEventData extends BaseMemoryOperationData {
+    memory: IAgentMemory | IChannelMemory | IRelationshipMemory | Record<string, unknown> | null;
+    error?: string;
+}
+export type MemoryUpdateResultEventPayload = BaseEventPayload<MemoryUpdateResultEventData>;
+/**
+ * Data for memory DELETE request events.
+ */
+export interface MemoryDeleteEventData extends BaseMemoryOperationData {
+    key?: string;
+}
+export type MemoryDeleteEventPayload = BaseEventPayload<MemoryDeleteEventData>;
+/**
+ * Data for memory DELETE result events.
+ */
+export interface MemoryDeleteResultEventData extends BaseMemoryOperationData {
+    key?: string;
+    success: boolean;
+    deletedCount?: number;
+    error?: string;
+}
+export type MemoryDeleteResultEventPayload = BaseEventPayload<MemoryDeleteResultEventData>;
+/**
+ * Data for memory SYNC request events.
+ */
+export interface MemorySyncRequestData extends BaseMemoryOperationData {
+    target?: 'local' | 'remote' | 'bidirectional';
+}
+export type MemorySyncRequestPayload = BaseEventPayload<MemorySyncRequestData>;
+/**
+ * Data for memory SYNC COMPLETE events.
+ */
+export interface MemorySyncCompleteData extends BaseMemoryOperationData {
+    itemCount?: number;
+    statusMessage?: string;
+}
+export type MemorySyncCompletePayload = BaseEventPayload<MemorySyncCompleteData>;
+/**
+ * Data for memory SYNC ERROR events.
+ */
+export interface MemorySyncErrorData extends BaseMemoryOperationData {
+    error: string;
+    details?: any;
+}
+export type MemorySyncErrorPayload = BaseEventPayload<MemorySyncErrorData>;
+/**
+ * Base structure for memory operation request payloads before they are wrapped into a full BaseEventPayload.
+ * This is typically what SDK methods like sendMemoryRequest expect as their 'payload' argument.
+ */
+export interface BaseMemoryRequest {
+    scope: MemoryScope;
+    id: string | string[];
+    channelId: string;
+}
+/**
+ * Request payload for getting memory.
+ */
+export interface MemoryGetRequest extends BaseMemoryRequest {
+    key?: string;
+    filters?: Record<string, any>;
+}
+/**
+ * Request payload for creating memory.
+ */
+export interface MemoryCreateRequest<TData = any> extends BaseMemoryRequest {
+    data: TData;
+}
+/**
+ * Request payload for updating memory.
+ */
+export interface MemoryUpdateRequest<TData = any> extends BaseMemoryRequest {
+    data: Partial<TData>;
+    key?: string;
+}
+/**
+ * Request payload for deleting memory.
+ */
+export interface MemoryDeleteRequest extends BaseMemoryRequest {
+    key?: string;
+}
+/**
+ * Union type for all possible memory request payloads that sendMemoryRequest can handle.
+ */
+export type MemoryRequestPayload = MemoryGetRequest | MemoryCreateRequest<any> | MemoryUpdateRequest<any> | MemoryDeleteRequest;
+export interface McpToolEventData {
+    toolName: string;
+    toolVersion?: string;
+    [key: string]: any;
+}
+export type McpToolRegisteredEventPayload = BaseEventPayload<McpToolEventData & {
+    registrationDetails: any;
+}>;
+export type McpToolUnregisteredEventPayload = BaseEventPayload<McpToolEventData>;
+export type McpToolCallEventPayload = BaseEventPayload<McpToolEventData & {
+    callId: string;
+    arguments: any;
+}>;
+export type McpToolResultEventPayload = BaseEventPayload<McpToolEventData & {
+    callId: string;
+    result: any;
+}>;
+export type McpToolErrorEventPayload = BaseEventPayload<McpToolEventData & {
+    callId: string;
+    error: any;
+}>;
+export interface McpToolCallCompletedLocalData {
+    callId: string;
+    toolName: string;
+    input: any;
+    result: any;
+    durationMs: number;
+    source: 'internal' | 'external-mcp';
+    executedOn: 'client';
+}
+export type McpToolCallCompletedLocalEventPayload = BaseEventPayload<McpToolCallCompletedLocalData>;
+export interface McpResourceEventData {
+    resourceUri: string;
+    resourceType?: string;
+    [key: string]: any;
+}
+export type McpResourceGetEventPayload = BaseEventPayload<McpResourceEventData & {
+    requestId: string;
+}>;
+export type McpResourceListEventPayload = BaseEventPayload<McpResourceEventData & {
+    requestId: string;
+    filter?: any;
+}>;
+export type McpResourceResultEventPayload = BaseEventPayload<McpResourceEventData & {
+    requestId: string;
+    data: any;
+}>;
+export type McpResourceErrorEventPayload = BaseEventPayload<McpResourceEventData & {
+    requestId: string;
+    error: any;
+}>;
+/**
+ * Data for external MCP server events (global and channel-scoped)
+ */
+export interface ExternalMcpServerEventData {
+    serverId: string;
+    serverName?: string;
+    scope: 'global' | 'channel' | 'agent';
+    scopeId?: string;
+    success?: boolean;
+    error?: string;
+    message?: string;
+    toolsDiscovered?: string[];
+    status?: 'stopped' | 'starting' | 'running' | 'error';
+    connectedAgents?: number;
+    [key: string]: any;
+}
+export type ExternalMcpServerEventPayload = BaseEventPayload<ExternalMcpServerEventData>;
+/**
+ * Data for generic message-related events.
+ * This is used as the 'data' field in events like Events.Message.CHANNEL_MESSAGE or Events.Message.AGENT_MESSAGE.
+ */
+export interface MessageEventData {
+    /**
+     * The actual message content, which can be a ChannelMessage or AgentMessage.
+     * This reuses the detailed message structures from MessageSchemas.ts.
+     */
+    message: ChannelMessage | AgentMessage;
+    /**
+     * Optional error message if processing or delivery of the message failed.
+     */
+    error?: string;
+    /**
+     * Allows for additional, event-specific properties if needed.
+     */
+    [key: string]: any;
+}
+export type MessageEventPayload = BaseEventPayload<MessageEventData>;
+/**
+ * Event payload for events that carry a standard ChannelMessage.
+ */
+export type ChannelMessageEventPayload = BaseEventPayload<ChannelMessage>;
+/**
+ * Event payload for events that carry a standard AgentMessage.
+ */
+export type AgentMessageEventPayload = BaseEventPayload<AgentMessage>;
+/**
+ * Payload type for message persistence failure.
+ */
+export interface MessagePersistFailedPayload {
+    channelId?: string;
+    messageId?: string;
+    originalMessage?: Partial<ChannelMessage>;
+    error: string;
+    timestamp: number;
+    fromAgentId?: string;
+}
+/**
+ * Payload type for message send failure.
+ */
+export interface MessageSendFailedPayload {
+    channelId?: string;
+    messageId?: string;
+    originalMessage?: Partial<ChannelMessage>;
+    error: string;
+    timestamp: number;
+    fromAgentId?: string;
+}
+/**
+ * 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 declare function createBaseEventPayload<TData>(eventType: EventName | string, agentId: AgentId, channelId: ChannelId, data: TData, options?: {
+    source?: string;
+    isRecursionProtection?: boolean;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<TData>;
+/**
+ * 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 declare function createConnectionEventPayload(eventType: EventName | string, agentId: AgentId, channelId: ChannelId, connectionData: ConnectionEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): ConnectionEventPayload;
+/**
+ * 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 declare function createAgentEventPayload(eventType: EventName | string, agentId: AgentId, channelId: ChannelId, agentData: AgentEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): AgentEventPayload;
+/**
+ * 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 declare function createAllowedToolsUpdateEventPayload(eventType: EventName | string, agentId: AgentId, channelId: ChannelId, allowedTools: string[], options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): AllowedToolsUpdateEventPayload;
+/**
+ * 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 declare function createLlmReasoningEventPayload(eventType: EventName | string, agentId: AgentId, channelId: ChannelId, reasoningData: LlmReasoningEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): LlmReasoningEventPayload;
+/**
+ * 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 declare function createLlmReasoningParsedEventPayload(eventType: EventName | string, agentId: AgentId, channelId: ChannelId, parsedData: LlmReasoningParsedEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): LlmReasoningParsedEventPayload;
+/**
+ * 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 declare function createLlmReasoningToolsSynthesizedEventPayload(eventType: EventName | string, agentId: AgentId, channelId: ChannelId, synthesizedData: LlmReasoningToolsSynthesizedEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): LlmReasoningToolsSynthesizedEventPayload;
+/**
+ * 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 declare function createLlmStreamChunkEventPayload(eventType: EventName | string, agentId: AgentId, channelId: ChannelId, chunkData: LlmStreamChunkEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): LlmStreamChunkEventPayload;
+/**
+ * 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 declare function createLlmUsageEventPayload(eventType: EventName | string, agentId: AgentId, channelId: ChannelId, usageData: LlmUsageEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): LlmUsageEventPayload;
+/**
+ * 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 declare function createChannelEventPayload(eventType: EventName | string, agentId: AgentId, channelId: ChannelId, channelData: ChannelEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): ChannelEventPayload;
+/**
+ * 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 declare function createSubscriptionEventPayload(eventType: EventName | string, agentId: AgentId, channelId: ChannelId, subscriptionData: SubscriptionEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): SubscriptionEventPayload;
+/**
+ * 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 declare function createTaskEventPayload<TData extends TaskEventData>(eventType: EventName | string, emittingAgentId: AgentId, channelId: ChannelId, taskData: TData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): TaskEventPayload & {
+    data: TData;
+};
+/**
+ * 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 declare function createTaskResponseEventPayload(eventType: EventName | string, emittingAgentId: AgentId, channelId: ChannelId, taskResponseData: TaskResponseEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): TaskResponseEventPayload;
+/**
+ * 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 declare function createTaskAssignmentEventPayload(eventType: EventName | string, assignedAgentId: AgentId, channelId: ChannelId, taskAssignmentData: TaskAssignmentEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): TaskAssignmentEventPayload;
+/**
+ * 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 declare function createControlLoopEventPayload(eventType: EventName | string, agentId: AgentId, channelId: ChannelId, controlLoopData: ControlLoopSpecificData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+    isRecursionProtection?: boolean;
+}): ControlLoopEventPayload;
+/**
+ * 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 declare function createMemoryGetEventPayload(eventType: typeof Events.Memory.GET, agentId: AgentId, channelId: ChannelId, memoryGetData: MemoryGetEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): MemoryGetEventPayload;
+/**
+ * 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 declare function createMemoryGetResultEventPayload(eventType: typeof Events.Memory.GET_RESULT, agentId: AgentId, channelId: ChannelId, memoryGetResultData: MemoryGetResultEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): MemoryGetResultEventPayload;
+/**
+ * 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 declare function createMemoryUpdateEventPayload(eventType: typeof Events.Memory.UPDATE, agentId: AgentId, channelId: ChannelId, memoryUpdateData: MemoryUpdateEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): MemoryUpdateEventPayload;
+/**
+ * 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 declare function createMemoryUpdateResultEventPayload(eventType: typeof Events.Memory.UPDATE_RESULT, agentId: AgentId, channelId: ChannelId, memoryUpdateResultData: MemoryUpdateResultEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): MemoryUpdateResultEventPayload;
+/**
+ * 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 declare function createMemoryDeleteEventPayload(eventType: typeof Events.Memory.DELETE, agentId: AgentId, channelId: ChannelId, memoryDeleteData: MemoryDeleteEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): MemoryDeleteEventPayload;
+/**
+ * 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 declare function createMemoryDeleteResultEventPayload(eventType: typeof Events.Memory.DELETE_RESULT, agentId: AgentId, channelId: ChannelId, memoryDeleteResultData: MemoryDeleteResultEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): MemoryDeleteResultEventPayload;
+/**
+ * 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 declare function createMemorySyncCompleteEventPayload(eventType: typeof Events.Memory.SYNC_COMPLETE, agentId: AgentId, channelId: ChannelId, memorySyncCompleteData: MemorySyncCompleteData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): MemorySyncCompletePayload;
+/**
+ * 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 declare function createMemorySyncErrorEventPayload(eventType: typeof Events.Memory.SYNC_ERROR, agentId: AgentId, channelId: ChannelId, memorySyncErrorData: MemorySyncErrorData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): MemorySyncErrorPayload;
+/**
+ * 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 declare function createChannelMessageEventPayload(eventType: EventName | string, agentId: AgentId, channelMessage: ChannelMessage, options?: {
+    source?: string;
+    isRecursionProtection?: boolean;
+    eventId?: string;
+    timestamp?: number;
+}): ChannelMessageEventPayload;
+/**
+ * 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 declare function createAgentMessageEventPayload(eventType: EventName | string, agentId: AgentId, channelId: ChannelId, agentMessage: AgentMessage, options?: {
+    source?: string;
+    isRecursionProtection?: boolean;
+    eventId?: string;
+    timestamp?: number;
+}): AgentMessageEventPayload;
+/**
+ * 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 declare const createMessageEventPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: MessageEventData, options?: {
+    eventId?: string;
+    timestamp?: number;
+}) => MessageEventPayload;
+/**
+ * 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 declare const createMessagePersistFailedEventPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: MessagePersistFailedPayload, options?: {
+    eventId?: string;
+    timestamp?: number;
+}) => BaseEventPayload<MessagePersistFailedPayload>;
+/**
+ * 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 declare const createMessageSendFailedEventPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: MessageSendFailedPayload, options?: {
+    eventId?: string;
+    timestamp?: number;
+}) => BaseEventPayload<MessageSendFailedPayload>;
+/**
+ * Data for LLM instruction started event.
+ */
+export interface LlmInstructionStartedEventData {
+    serviceId: string;
+    instructionId: string;
+    timestamp: number;
+    prompt: string;
+    options?: Record<string, any>;
+}
+/**
+ * Data for LLM instruction completed event.
+ */
+export interface LlmInstructionCompletedEventData {
+    serviceId: string;
+    instructionId: string;
+    timestamp: number;
+    response: string;
+    usage?: {
+        promptTokens?: number;
+        completionTokens?: number;
+        totalTokens?: number;
+        [key: string]: any;
+    };
+}
+/**
+ * Data for LLM instruction error event.
+ */
+export interface LlmInstructionErrorEventData {
+    serviceId: string;
+    instructionId: string;
+    timestamp: number;
+    error: string;
+}
+/**
+ * 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 declare const createLlmInstructionStartedPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: LlmInstructionStartedEventData) => BaseEventPayload<LlmInstructionStartedEventData>;
+/**
+ * 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 declare const createLlmInstructionCompletedPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: LlmInstructionCompletedEventData) => BaseEventPayload<LlmInstructionCompletedEventData>;
+/**
+ * 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 declare const createLlmInstructionErrorPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: LlmInstructionErrorEventData) => BaseEventPayload<LlmInstructionErrorEventData>;
+/**
+ * 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 declare const createMcpToolRegisterPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: McpToolEventData & {
+    registrationDetails: any;
+}) => McpToolRegisteredEventPayload;
+/**
+ * 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 declare const createMcpToolRegisteredPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: McpToolEventData & {
+    success: boolean;
+    error?: string;
+}) => McpToolRegisteredEventPayload;
+/**
+ * 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 declare const createMcpToolUnregisterPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: McpToolEventData) => McpToolUnregisteredEventPayload;
+/**
+ * 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 declare const createMcpToolCallPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: McpToolEventData & {
+    callId: string;
+    arguments: any;
+}) => McpToolCallEventPayload;
+/**
+ * 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 declare const createMcpToolResultPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: McpToolEventData & {
+    callId: string;
+    result: any;
+}) => McpToolResultEventPayload;
+/**
+ * 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 declare const createMcpToolErrorPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: McpToolEventData & {
+    callId: string;
+    error: any;
+}) => McpToolErrorEventPayload;
+/**
+ * Creates a payload for a client-side tool call event (local observability).
+ */
+export declare const createMcpToolCallLocalPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: McpToolEventData & {
+    callId: string;
+    arguments: any;
+}) => McpToolCallEventPayload;
+/**
+ * Creates a payload for a client-side tool result event (local observability).
+ */
+export declare const createMcpToolResultLocalPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: McpToolEventData & {
+    callId: string;
+    result: any;
+    durationMs: number;
+}) => McpToolResultEventPayload;
+/**
+ * Creates a payload for a client-side tool error event (local observability).
+ */
+export declare const createMcpToolErrorLocalPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: McpToolEventData & {
+    callId: string;
+    error: any;
+}) => McpToolErrorEventPayload;
+/**
+ * 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 declare const createMcpToolCallCompletedLocalPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: McpToolCallCompletedLocalData) => McpToolCallCompletedLocalEventPayload;
+/**
+ * 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 declare const createMcpResourceGetPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: McpResourceEventData & {
+    requestId: string;
+}) => McpResourceGetEventPayload;
+/**
+ * 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 declare const createMcpResourceListPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: McpResourceEventData & {
+    requestId: string;
+    filter?: any;
+}) => McpResourceListEventPayload;
+/**
+ * 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 declare const createMcpResourceResultPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: McpResourceEventData & {
+    requestId: string;
+    data: any;
+}) => McpResourceResultEventPayload;
+/**
+ * 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 declare const createMcpResourceErrorPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: McpResourceEventData & {
+    requestId: string;
+    error: any;
+}) => McpResourceErrorEventPayload;
+/**
+ * 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 declare function createExternalMcpServerEventPayload(eventType: EventName | string, agentId: AgentId, channelId: ChannelId, serverData: ExternalMcpServerEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): ExternalMcpServerEventPayload;
+/**
+ * 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 declare const createMcpToolRegistryChangedPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: {
+    tools: Array<{
+        name: string;
+        description: string;
+        inputSchema: Record<string, any>;
+    }>;
+}) => BaseEventPayload<{
+    tools: Array<{
+        name: string;
+        description: string;
+        inputSchema: Record<string, any>;
+    }>;
+}>;
+/**
+ * Data for agent message delivered events.
+ */
+export interface AgentMessageDeliveredEventData {
+    fromAgentId: string;
+    toAgentId: string;
+    content: any;
+    timestamp: number;
+    [key: string]: any;
+}
+/**
+ * Payload type for agent message delivered events.
+ */
+export type AgentMessageDeliveredEventPayload = BaseEventPayload<AgentMessageDeliveredEventData>;
+/**
+ * Data for agent state change events (e.g., agent becoming active/inactive).
+ */
+export interface AgentStateChangeEventData {
+}
+/**
+ * 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 declare const createAgentMessageDeliveredPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: AgentMessageDeliveredEventData) => AgentMessageDeliveredEventPayload;
+/**
+ * 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 declare const createAgentMessageForwardPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: any) => BaseEventPayload<any>;
+/**
+ * Defines the parameters required for creating a new channel.
+ * This is used as the 'data' field in channel creation events.
+ */
+export interface ChannelCreationParams {
+    /**
+     * The unique identifier for the channel to be created.
+     */
+    channelId: string;
+    /**
+     * Optional descriptive name for the channel.
+     * If not provided, it may default to the channelId.
+     */
+    name?: string;
+    /**
+     * The identifier of the agent initiating the channel creation.
+     */
+    agentId: string;
+}
+/**
+ * Interface for channel creation events
+ */
+export interface ChannelCreationEventData {
+    channelId: string;
+    agentId: string;
+    timestamp: number;
+    config?: any;
+    status: 'pending' | 'created' | 'error';
+    error?: string;
+}
+/**
+ * Payload type for channel creation events
+ */
+export type ChannelCreationEventPayload = BaseEventPayload<ChannelCreationEventData>;
+/**
+ * Channel context operation payload types
+ */
+export interface ContextGetEventData {
+    channelId: ChannelId;
+    operationId?: string;
+    timestamp: number;
+}
+export type ContextGetEventPayload = BaseEventPayload<ContextGetEventData>;
+export interface ContextGotEventData {
+    channelId: ChannelId;
+    context: any;
+    operationId?: string;
+    timestamp: number;
+}
+export type ContextGotEventPayload = BaseEventPayload<ContextGotEventData>;
+export interface ContextGetFailedEventData {
+    channelId: ChannelId;
+    error: string;
+    operationId?: string;
+    timestamp: number;
+}
+export type ContextGetFailedEventPayload = BaseEventPayload<ContextGetFailedEventData>;
+export interface ContextUpdateEventData {
+    channelId: ChannelId;
+    agentId: AgentId;
+    updates: any;
+    operationId?: string;
+    timestamp: number;
+}
+export type ContextUpdateEventPayload = BaseEventPayload<ContextUpdateEventData>;
+export interface ContextUpdatedEventData {
+    channelId: ChannelId;
+    context: any;
+    operationId?: string;
+    timestamp: number;
+}
+export type ContextUpdatedEventPayload = BaseEventPayload<ContextUpdatedEventData>;
+export interface ContextUpdateFailedEventData {
+    channelId: ChannelId;
+    error: string;
+    operationId?: string;
+    timestamp: number;
+}
+export type ContextUpdateFailedEventPayload = BaseEventPayload<ContextUpdateFailedEventData>;
+export interface MetadataSetEventData {
+    channelId: ChannelId;
+    agentId: AgentId;
+    key: string;
+    value: any;
+    operationId?: string;
+    timestamp: number;
+}
+export type MetadataSetEventPayload = BaseEventPayload<MetadataSetEventData>;
+export interface MetadataSetSuccessEventData {
+    channelId: ChannelId;
+    key: string;
+    value: any;
+    operationId?: string;
+    timestamp: number;
+}
+export type MetadataSetSuccessEventPayload = BaseEventPayload<MetadataSetSuccessEventData>;
+export interface MetadataSetFailedEventData {
+    channelId: ChannelId;
+    key: string;
+    error: string;
+    operationId?: string;
+    timestamp: number;
+}
+export type MetadataSetFailedEventPayload = BaseEventPayload<MetadataSetFailedEventData>;
+export interface MetadataGetEventData {
+    channelId: ChannelId;
+    key?: string;
+    operationId?: string;
+    timestamp: number;
+}
+export type MetadataGetEventPayload = BaseEventPayload<MetadataGetEventData>;
+export interface MetadataGotEventData {
+    channelId: ChannelId;
+    metadata: Record<string, any> | any;
+    operationId?: string;
+    timestamp: number;
+}
+export type MetadataGotEventPayload = BaseEventPayload<MetadataGotEventData>;
+export interface MetadataGetFailedEventData {
+    channelId: ChannelId;
+    key?: string;
+    error: string;
+    operationId?: string;
+    timestamp: number;
+}
+export type MetadataGetFailedEventPayload = BaseEventPayload<MetadataGetFailedEventData>;
+export interface TopicsExtractEventData {
+    channelId: ChannelId;
+    minRelevance?: number;
+    operationId?: string;
+    timestamp: number;
+}
+export type TopicsExtractEventPayload = BaseEventPayload<TopicsExtractEventData>;
+export interface TopicsExtractedEventData {
+    channelId: ChannelId;
+    topics: Array<{
+        id: string;
+        topic: string;
+        keywords: string[];
+        relevance: number;
+    }>;
+    operationId?: string;
+    timestamp: number;
+}
+export type TopicsExtractedEventPayload = BaseEventPayload<TopicsExtractedEventData>;
+export interface TopicsExtractFailedEventData {
+    channelId: ChannelId;
+    error: string;
+    operationId?: string;
+    timestamp: number;
+}
+export type TopicsExtractFailedEventPayload = BaseEventPayload<TopicsExtractFailedEventData>;
+export interface SummaryGenerateEventData {
+    channelId: ChannelId;
+    messageCount?: number;
+    operationId?: string;
+    timestamp: number;
+}
+export type SummaryGenerateEventPayload = BaseEventPayload<SummaryGenerateEventData>;
+export interface SummaryGeneratedEventData {
+    channelId: ChannelId;
+    summary: string;
+    operationId?: string;
+    timestamp: number;
+}
+export type SummaryGeneratedEventPayload = BaseEventPayload<SummaryGeneratedEventData>;
+export interface SummaryGenerateFailedEventData {
+    channelId: ChannelId;
+    error: string;
+    operationId?: string;
+    timestamp: number;
+}
+export type SummaryGenerateFailedEventPayload = BaseEventPayload<SummaryGenerateFailedEventData>;
+/**
+ * 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 declare const createChannelCreationEventPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: ChannelCreationEventData) => ChannelCreationEventPayload;
+/**
+ * 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 declare const createContextGetEventPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: ContextGetEventData) => ContextGetEventPayload;
+/**
+ * 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 declare const createContextGotEventPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: ContextGotEventData) => ContextGotEventPayload;
+/**
+ * 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 declare const createContextUpdateEventPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: ContextUpdateEventData) => ContextUpdateEventPayload;
+/**
+ * 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 declare const createMetadataSetEventPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: MetadataSetEventData) => MetadataSetEventPayload;
+/**
+ * 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 declare const createTopicsExtractEventPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: TopicsExtractEventData, options?: {
+    source?: string;
+    isRecursionProtection?: boolean;
+    eventId?: string;
+    timestamp?: number;
+}) => TopicsExtractEventPayload;
+/**
+ * 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 declare const createSummaryGenerateEventPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: SummaryGenerateEventData, options?: {
+    source?: string;
+    isRecursionProtection?: boolean;
+    eventId?: string;
+    timestamp?: number;
+}) => SummaryGenerateEventPayload;
+/**
+ * Data for agent state change events (e.g., agent becoming active/inactive).
+ */
+export interface AgentStateChangeEventData {
+}
+export type AgentStateChangeEventPayload = BaseEventPayload<AgentStateChangeEventData>;
+/**
+ * Data for external MCP server error events
+ */
+export interface ExternalMcpServerErrorEventData {
+    error: string;
+    code: string;
+    details: Record<string, any>;
+}
+export type ExternalMcpServerErrorEventPayload = BaseEventPayload<ExternalMcpServerErrorEventData>;
+/**
+ * Data for external MCP server health status events
+ */
+export interface ExternalMcpServerHealthStatusEventData {
+    name: string;
+    version: string;
+    status: string;
+    description?: string;
+}
+export type ExternalMcpServerHealthStatusEventPayload = BaseEventPayload<ExternalMcpServerHealthStatusEventData>;
+/**
+ * Data for external MCP server tools discovered events
+ */
+export interface ExternalMcpServerToolsDiscoveredEventData {
+    name: string;
+    version: string;
+    tools: Array<{
+        name: string;
+        description: string;
+        inputSchema: Record<string, any>;
+    }>;
+}
+export type ExternalMcpServerToolsDiscoveredEventPayload = BaseEventPayload<ExternalMcpServerToolsDiscoveredEventData>;
+/**
+ * Creates an external MCP server error event payload.
+ */
+export declare const createExternalMcpServerErrorEventPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: ExternalMcpServerErrorEventData, options?: {
+    source?: string;
+    isRecursionProtection?: boolean;
+    eventId?: string;
+    timestamp?: number;
+}) => ExternalMcpServerErrorEventPayload;
+/**
+ * Creates an external MCP server health status event payload.
+ */
+export declare const createExternalMcpServerHealthStatusEventPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: ExternalMcpServerHealthStatusEventData, options?: {
+    source?: string;
+    isRecursionProtection?: boolean;
+    eventId?: string;
+    timestamp?: number;
+}) => ExternalMcpServerHealthStatusEventPayload;
+/**
+ * Creates an external MCP server tools discovered event payload.
+ */
+export declare const createExternalMcpServerToolsDiscoveredEventPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: ExternalMcpServerToolsDiscoveredEventData, options?: {
+    source?: string;
+    isRecursionProtection?: boolean;
+    eventId?: string;
+    timestamp?: number;
+}) => ExternalMcpServerToolsDiscoveredEventPayload;
+/**
+ * Import system event types and interfaces
+ */
+import type { SystemEphemeralEventData, CoordinationAnalysis, TemporalContext, SystemEventType } from '../events/event-definitions/SystemEvents.js';
+/**
+ * System ephemeral event payload for EventBus integration
+ * These events provide intelligent context injection without appearing in message history
+ */
+export interface SystemEphemeralEventPayloadData {
+    /** Ephemeral event data with temporal context */
+    eventData: SystemEphemeralEventData;
+    /** Coordination analysis context */
+    coordinationContext?: CoordinationAnalysis;
+    /** Additional system metadata */
+    systemMetadata: {
+        /** System intelligence confidence */
+        systemConfidence: number;
+        /** Processing timestamp */
+        processingTime: number;
+        /** System version */
+        systemVersion: string;
+        /** Analysis method used */
+        analysisMethod: 'pattern_recognition' | 'temporal_analysis' | 'coordination_detection' | 'activity_monitoring';
+    };
+}
+export type SystemEphemeralEventPayload = BaseEventPayload<SystemEphemeralEventPayloadData>;
+/**
+ * System coordination event payload for coordination analysis results
+ */
+export interface SystemCoordinationEventPayloadData {
+    /** Coordination analysis results */
+    coordinationAnalysis: CoordinationAnalysis;
+    /** Recommended actions */
+    recommendedActions: string[];
+    /** Priority level for coordination */
+    priority: number;
+    /** Temporal context */
+    temporalContext: TemporalContext;
+    /** Confidence in recommendations */
+    recommendationConfidence: number;
+}
+export type SystemCoordinationEventPayload = BaseEventPayload<SystemCoordinationEventPayloadData>;
+/**
+ * System temporal pattern event payload for time-based pattern detection
+ */
+export interface SystemTemporalPatternEventPayloadData {
+    /** Detected temporal pattern */
+    pattern: {
+        /** Pattern type */
+        type: string;
+        /** Pattern description */
+        description: string;
+        /** Temporal context */
+        temporalContext: TemporalContext;
+        /** Pattern confidence */
+        confidence: number;
+        /** Affected channels */
+        affectedChannels: ChannelId[];
+        /** Suggested responses */
+        suggestedResponses: string[];
+        /** Pattern frequency */
+        frequency: 'rare' | 'occasional' | 'regular' | 'frequent' | 'constant';
+        /** Pattern duration */
+        duration: number;
+    };
+    /** Pattern impact assessment */
+    impactAssessment: {
+        /** Severity of pattern impact */
+        severity: 'low' | 'medium' | 'high' | 'critical';
+        /** Affected agents */
+        affectedAgents: AgentId[];
+        /** Recommended response time */
+        responseTimeMs: number;
+    };
+}
+export type SystemTemporalPatternEventPayload = BaseEventPayload<SystemTemporalPatternEventPayloadData>;
+/**
+ * System context analysis event payload for rich context awareness
+ */
+export interface SystemContextAnalysisEventPayloadData {
+    /** Context analysis results */
+    contextAnalysis: {
+        /** Channel activity summary */
+        channelActivity: {
+            /** Activity level (0-10) */
+            level: number;
+            /** Recent message count */
+            messageCount: number;
+            /** Active agent count */
+            activeAgents: number;
+            /** Tool usage frequency */
+            toolUsage: number;
+        };
+        /** Agent interaction patterns */
+        interactionPatterns: {
+            /** Collaboration intensity */
+            collaborationIntensity: number;
+            /** Communication frequency */
+            communicationFrequency: number;
+            /** Resource sharing level */
+            resourceSharing: number;
+        };
+        /** System intelligence insights */
+        systemInsights: string[];
+        /** Temporal context */
+        temporalContext: TemporalContext;
+    };
+    /** Analysis confidence */
+    analysisConfidence: number;
+    /** Next analysis scheduled time */
+    nextAnalysisTime: string;
+}
+export type SystemContextAnalysisEventPayload = BaseEventPayload<SystemContextAnalysisEventPayloadData>;
+/**
+ * Creates a system ephemeral event payload for intelligent context injection
+ */
+export declare const createSystemEphemeralEventPayload: (eventType: SystemEventType, agentId: AgentId, channelId: ChannelId, eventData: SystemEphemeralEventData, coordinationContext?: CoordinationAnalysis, options?: {
+    source?: string;
+    isRecursionProtection?: boolean;
+    eventId?: string;
+    timestamp?: number;
+    systemConfidence?: number;
+    analysisMethod?: "pattern_recognition" | "temporal_analysis" | "coordination_detection" | "activity_monitoring";
+}) => SystemEphemeralEventPayload;
+/**
+ * Creates a system coordination event payload for coordination analysis
+ */
+export declare const createSystemCoordinationEventPayload: (eventType: SystemEventType, agentId: AgentId, channelId: ChannelId, coordinationAnalysis: CoordinationAnalysis, recommendedActions: string[], temporalContext: TemporalContext, options?: {
+    source?: string;
+    isRecursionProtection?: boolean;
+    eventId?: string;
+    timestamp?: number;
+    priority?: number;
+    recommendationConfidence?: number;
+}) => SystemCoordinationEventPayload;
+/**
+ * Creates a system temporal pattern event payload for pattern detection
+ */
+export declare const createSystemTemporalPatternEventPayload: (eventType: SystemEventType, agentId: AgentId, channelId: ChannelId, pattern: SystemTemporalPatternEventPayloadData["pattern"], impactAssessment: SystemTemporalPatternEventPayloadData["impactAssessment"], options?: {
+    source?: string;
+    isRecursionProtection?: boolean;
+    eventId?: string;
+    timestamp?: number;
+}) => SystemTemporalPatternEventPayload;
+/**
+ * Creates a system context analysis event payload for rich context awareness
+ */
+export declare const createSystemContextAnalysisEventPayload: (eventType: SystemEventType, agentId: AgentId, channelId: ChannelId, contextAnalysis: SystemContextAnalysisEventPayloadData["contextAnalysis"], options?: {
+    source?: string;
+    isRecursionProtection?: boolean;
+    eventId?: string;
+    timestamp?: number;
+    analysisConfidence?: number;
+    nextAnalysisTime?: string;
+}) => SystemContextAnalysisEventPayload;
+/**
+ * Validation helper for system event payloads
+ * Ensures system events meet quality and security standards
+ */
+export declare const validateSystemEventPayload: (payload: SystemEphemeralEventPayload) => boolean;
+/**
+ * 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 declare const createTemporalContext: (timeData?: any, options?: {
+    businessHoursStart?: string;
+    businessHoursEnd?: string;
+    timezone?: string;
+}) => TemporalContext;
+/**
+ * Create a basic CoordinationAnalysis object
+ * @param channelId - Channel identifier
+ * @param options - Optional configuration for analysis
+ * @returns Basic CoordinationAnalysis structure
+ */
+export declare const createBasicCoordinationAnalysis: (channelId: ChannelId, options?: {
+    activeAgents?: AgentId[];
+    messageCount?: number;
+    toolUsage?: number;
+    timePeriod?: string;
+}) => CoordinationAnalysis;
+/**
+ * Data for MXF tool list request events
+ */
+export interface MxfToolListEventData {
+    filter?: {
+        name?: string;
+        channelId?: string;
+    };
+    allowedTools?: string[];
+    requestId?: string;
+}
+/**
+ * Data for MXF tool list result events
+ */
+export interface MxfToolListResultEventData {
+    tools: Array<{
+        name: string;
+        description: string;
+        inputSchema: Record<string, any>;
+        enabled: boolean;
+        providerId: string;
+        channelId: string;
+        parameters?: any;
+        metadata?: any;
+    }>;
+    count: number;
+    requestId?: string;
+}
+/**
+ * Data for MXF tool list error events
+ */
+export interface MxfToolListErrorEventData {
+    error: string;
+    requestId?: string;
+}
+/**
+ * Creates a payload for MXF tool list request events
+ */
+export declare const createMxfToolListPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: MxfToolListEventData) => BaseEventPayload<MxfToolListEventData>;
+/**
+ * Creates a payload for MXF tool list result events
+ */
+export declare const createMxfToolListResultPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: MxfToolListResultEventData) => BaseEventPayload<MxfToolListResultEventData>;
+/**
+ * Creates a payload for MXF tool list error events
+ */
+export declare const createMxfToolListErrorPayload: (eventType: string, agentId: AgentId, channelId: ChannelId, data: MxfToolListErrorEventData) => BaseEventPayload<MxfToolListErrorEventData>;
+import type { MxpTokenOptimizationEventData, MxpBandwidthOptimizationEventData, MxpSecurityEventData, MxpAnalyticsEventData } from '../events/event-definitions/MxpEvents.js';
+export type { MxpTokenOptimizationEventData, MxpBandwidthOptimizationEventData, MxpSecurityEventData, MxpAnalyticsEventData };
+/**
+ * Creates an MXP token optimization event payload
+ */
+export declare function createMxpTokenOptimizationEventPayload(eventType: string, agentId: AgentId, channelId: ChannelId, data: MxpTokenOptimizationEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<MxpTokenOptimizationEventData>;
+/**
+ * Creates an MXP bandwidth optimization event payload
+ */
+export declare function createMxpBandwidthOptimizationEventPayload(eventType: string, agentId: AgentId, channelId: ChannelId, data: MxpBandwidthOptimizationEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<MxpBandwidthOptimizationEventData>;
+/**
+ * Creates an MXP security event payload
+ */
+export declare function createMxpSecurityEventPayload(eventType: string, agentId: AgentId, channelId: ChannelId, data: MxpSecurityEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<MxpSecurityEventData>;
+/**
+ * Creates an MXP analytics event payload
+ */
+export declare function createMxpAnalyticsEventPayload(eventType: string, agentId: AgentId, channelId: ChannelId, data: MxpAnalyticsEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<MxpAnalyticsEventData>;
+/**
+ * Data for Meilisearch indexing events
+ */
+export interface MeilisearchIndexEventData {
+    operationId: string;
+    indexName: string;
+    documentId: string;
+    documentType: 'conversation' | 'action' | 'pattern' | 'observation';
+    success: boolean;
+    duration?: number;
+    error?: string;
+    metadata?: {
+        messageCount?: number;
+        agentId?: string;
+        channelId?: string;
+        timestamp?: number;
+    };
+}
+export type MeilisearchIndexEventPayload = BaseEventPayload<MeilisearchIndexEventData>;
+/**
+ * Data for Meilisearch search events
+ */
+export interface MeilisearchSearchEventData {
+    operationId: string;
+    indexName: string;
+    query: string;
+    hybridRatio?: number;
+    resultCount: number;
+    duration: number;
+    filters?: Record<string, any>;
+    success: boolean;
+    error?: string;
+    metadata?: {
+        semanticSearch?: boolean;
+        embeddingModel?: string;
+        cacheHit?: boolean;
+    };
+}
+export type MeilisearchSearchEventPayload = BaseEventPayload<MeilisearchSearchEventData>;
+/**
+ * Data for Meilisearch backfill events
+ */
+export interface MeilisearchBackfillEventData {
+    operationId: string;
+    indexName: string;
+    totalDocuments: number;
+    indexedDocuments: number;
+    failedDocuments: number;
+    duration: number;
+    success: boolean;
+    source: 'mongodb' | 'memory' | 'other';
+    error?: string;
+    metadata?: {
+        agentId?: string;
+        channelId?: string;
+        startTimestamp?: number;
+        endTimestamp?: number;
+        batchSize?: number;
+    };
+}
+export type MeilisearchBackfillEventPayload = BaseEventPayload<MeilisearchBackfillEventData>;
+/**
+ * Creates a Meilisearch indexing event payload
+ */
+export declare function createMeilisearchIndexEventPayload(eventType: string, agentId: AgentId, channelId: ChannelId, data: MeilisearchIndexEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<MeilisearchIndexEventData>;
+/**
+ * Creates a Meilisearch search event payload
+ */
+export declare function createMeilisearchSearchEventPayload(eventType: string, agentId: AgentId, channelId: ChannelId, data: MeilisearchSearchEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<MeilisearchSearchEventData>;
+/**
+ * Creates a Meilisearch backfill event payload
+ */
+export declare function createMeilisearchBackfillEventPayload(eventType: string, agentId: AgentId, channelId: ChannelId, data: MeilisearchBackfillEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<MeilisearchBackfillEventData>;
+/**
+ * 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 declare function createPlanStepCompletedEventPayload(eventType: EventName | string, agentId: AgentId, channelId: ChannelId, planStepData: PlanStepCompletedEventData, options?: {
+    source?: string;
+    isRecursionProtection?: boolean;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<PlanStepCompletedEventData>;
+/**
+ * Data for Q-value updated events
+ */
+export interface MemoryQValueUpdatedEventData {
+    memoryId: string;
+    oldValue: number;
+    newValue: number;
+    reward: number;
+    delta: number;
+    taskId?: string;
+    phase?: string;
+}
+/**
+ * Data for Q-value batch updated events
+ */
+export interface MemoryQValueBatchUpdatedEventData {
+    totalUpdates: number;
+    updated: number;
+    failed: number;
+    taskId?: string;
+    errors?: Array<{
+        memoryId: string;
+        error: string;
+    }>;
+}
+/**
+ * Data for reward attributed events
+ */
+export interface MemoryRewardAttributedEventData {
+    taskId?: string;
+    status?: string;
+    reward: number;
+    memoriesUpdated: number;
+    memoriesFailed: number;
+    memoryIds: string[];
+    isManual?: boolean;
+    reason?: string;
+    newQValue?: number;
+    memoryId?: string;
+}
+/**
+ * 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 declare function createMemoryQValueUpdatedPayload(agentId: AgentId, channelId: ChannelId, data: MemoryQValueUpdatedEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<MemoryQValueUpdatedEventData>;
+/**
+ * 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 declare function createMemoryQValueBatchUpdatedPayload(agentId: AgentId, channelId: ChannelId, data: MemoryQValueBatchUpdatedEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<MemoryQValueBatchUpdatedEventData>;
+/**
+ * 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 declare function createMemoryRewardAttributedPayload(agentId: AgentId, channelId: ChannelId, data: MemoryRewardAttributedEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<MemoryRewardAttributedEventData>;
+/**
+ * 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 declare function createOrparMemoryCycleStartedPayload(agentId: AgentId, channelId: ChannelId, data: CycleStartedEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<CycleStartedEventData>;
+/**
+ * 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 declare function createOrparMemoryPhaseChangedPayload(agentId: AgentId, channelId: ChannelId, data: PhaseChangedEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<PhaseChangedEventData>;
+/**
+ * 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 declare function createOrparMemoryCycleCompletedPayload(agentId: AgentId, channelId: ChannelId, data: CycleCompletedEventData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<CycleCompletedEventData>;
+/**
+ * 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 declare function createDagTaskDependenciesResolvedPayload(channelId: ChannelId, agentId: AgentId, taskId: string, resolvedDependencies: string[], options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<TaskDependenciesResolvedEventData>;
+/**
+ * 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 declare function createDagTaskBlockedPayload(channelId: ChannelId, agentId: AgentId, taskId: string, blockingTasks: string[], attemptedStatus: string, reason: string, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<TaskBlockedEventData>;
+/**
+ * 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 declare function createDagTaskUnblockedPayload(channelId: ChannelId, agentId: AgentId, taskId: string, resolvedDependency: string, remainingBlockers: string[], isReady: boolean, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<TaskUnblockedEventData>;
+/**
+ * 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 declare function createDagCycleDetectedPayload(channelId: ChannelId, agentId: AgentId, dependentTaskId: string, dependencyTaskId: string, cyclePath: string[], cycleDescription: string, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<CycleDetectedEventData>;
+/**
+ * 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 declare function createDagUpdatedPayload(channelId: ChannelId, agentId: AgentId, updateType: 'node_added' | 'node_removed' | 'edge_added' | 'edge_removed' | 'status_changed', affectedTaskIds: string[], version: number, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<DagUpdatedEventData>;
+/**
+ * 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 declare function createDagDependencyAddedPayload(channelId: ChannelId, agentId: AgentId, edgeId: string, dependentTaskId: string, dependencyTaskId: string, label?: string, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<DependencyAddedEventData>;
+/**
+ * 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 declare function createDagDependencyRemovedPayload(channelId: ChannelId, agentId: AgentId, edgeId: string, dependentTaskId: string, dependencyTaskId: string, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<DependencyRemovedEventData>;
+/**
+ * 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 declare function createTfModelRegisteredPayload(channelId: ChannelId, agentId: AgentId, modelId: string, type: string, inputShape: number[], outputShape: number[], options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<ModelRegisteredEventData>;
+/**
+ * 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 declare function createTfModelTrainingStartedPayload(channelId: ChannelId, agentId: AgentId, modelId: string, trainingSamples: number, epochs: number, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<ModelTrainingStartedEventData>;
+/**
+ * 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 declare function createTfModelTrainingCompletedPayload(channelId: ChannelId, agentId: AgentId, modelId: string, loss: number, durationMs: number, samplesUsed: number, extras?: {
+    valLoss?: number;
+    accuracy?: number;
+}, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<ModelTrainingCompletedEventData>;
+/**
+ * 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 declare function createTfModelTrainingFailedPayload(channelId: ChannelId, agentId: AgentId, modelId: string, error: string, trainingSamples: number, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<ModelTrainingFailedEventData>;
+/**
+ * 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 declare function createTfModelLoadedPayload(channelId: ChannelId, agentId: AgentId, modelId: string, source: string, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<ModelLoadedEventData>;
+/**
+ * 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 declare function createTfModelSavedPayload(channelId: ChannelId, agentId: AgentId, modelId: string, destination: string, sizeBytes?: number, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<ModelSavedEventData>;
+/**
+ * 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 declare function createTfInferenceCompletedPayload(channelId: ChannelId, agentId: AgentId, modelId: string, latencyMs: number, inferenceSource: 'model' | 'heuristic', options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<InferenceCompletedEventData>;
+/**
+ * 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 declare function createTfInferenceFallbackPayload(channelId: ChannelId, agentId: AgentId, modelId: string, reason: 'disabled' | 'untrained' | 'error', error?: string, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<InferenceFallbackEventData>;
+/**
+ * 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 declare function createTfMemoryWarningPayload(channelId: ChannelId, agentId: AgentId, numTensors: number, numBytes: number, maxBytes: number, utilizationPercent: number, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<MemoryWarningEventData>;
+/**
+ * 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 declare function createTfMemoryStatsPayload(channelId: ChannelId, agentId: AgentId, numTensors: number, numDataBuffers: number, numBytes: number, timestamp: number, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): BaseEventPayload<MemoryStatsEventData>;
+/**
+ * Payload type for user input request events (server → client)
+ */
+export type UserInputRequestEventPayload = BaseEventPayload<UserInputRequestData>;
+/**
+ * Payload type for user input response events (client → server)
+ */
+export type UserInputResponseEventPayload = BaseEventPayload<UserInputResponseData>;
+/**
+ * Payload type for user input cancelled events (server → client)
+ */
+export type UserInputCancelledEventPayload = BaseEventPayload<UserInputCancelledData>;
+/**
+ * Payload type for user input timeout events (server → client)
+ */
+export type UserInputTimeoutEventPayload = BaseEventPayload<UserInputTimeoutData>;
+/**
+ * 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 declare function createUserInputRequestPayload(agentId: AgentId, channelId: ChannelId, requestData: UserInputRequestData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): UserInputRequestEventPayload;
+/**
+ * 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 declare function createUserInputResponsePayload(agentId: AgentId, channelId: ChannelId, responseData: UserInputResponseData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): UserInputResponseEventPayload;
+/**
+ * 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 declare function createUserInputCancelledPayload(agentId: AgentId, channelId: ChannelId | string, cancelledData: UserInputCancelledData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): UserInputCancelledEventPayload;
+/**
+ * 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 declare function createUserInputTimeoutPayload(agentId: AgentId, channelId: ChannelId | string, timeoutData: UserInputTimeoutData, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): UserInputTimeoutEventPayload;
+/** Payload type for microcompaction applied events */
+export type MicrocompactionAppliedEventPayload = BaseEventPayload<MicrocompactionAppliedPayload>;
+/** Payload type for auto-compaction triggered events */
+export type AutoCompactionTriggeredEventPayload = BaseEventPayload<AutoCompactionTriggeredPayload>;
+/** Payload type for reactive compaction triggered events */
+export type ReactiveCompactionTriggeredEventPayload = BaseEventPayload<ReactiveCompactionTriggeredPayload>;
+/** Payload type for post-compaction restoration completed events */
+export type PostCompactionRestoredEventPayload = BaseEventPayload<PostCompactionRestoredPayload>;
+/** Payload type for compaction summary generated events */
+export type CompactionSummaryGeneratedEventPayload = BaseEventPayload<CompactionSummaryGeneratedPayload>;
+/**
+ * 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 declare function createMicrocompactionAppliedPayload(agentId: AgentId, channelId: ChannelId, data: Omit<MicrocompactionAppliedPayload, 'eventType' | 'agentId' | 'channelId' | 'timestamp'>, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): MicrocompactionAppliedEventPayload;
+/**
+ * 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 declare function createAutoCompactionTriggeredPayload(agentId: AgentId, channelId: ChannelId, data: Omit<AutoCompactionTriggeredPayload, 'eventType' | 'agentId' | 'channelId' | 'timestamp'>, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): AutoCompactionTriggeredEventPayload;
+/**
+ * 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 declare function createReactiveCompactionTriggeredPayload(agentId: AgentId, channelId: ChannelId, data: Omit<ReactiveCompactionTriggeredPayload, 'eventType' | 'agentId' | 'channelId' | 'timestamp'>, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): ReactiveCompactionTriggeredEventPayload;
+/**
+ * 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 declare function createPostCompactionRestoredPayload(agentId: AgentId, channelId: ChannelId, data: Omit<PostCompactionRestoredPayload, 'eventType' | 'agentId' | 'channelId' | 'timestamp'>, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): PostCompactionRestoredEventPayload;
+/**
+ * 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 declare function createCompactionSummaryGeneratedPayload(agentId: AgentId, channelId: ChannelId, data: Omit<CompactionSummaryGeneratedPayload, 'eventType' | 'agentId' | 'channelId' | 'timestamp'>, options?: {
+    source?: string;
+    eventId?: string;
+    timestamp?: number;
+}): CompactionSummaryGeneratedEventPayload;
+//# sourceMappingURL=EventPayloadSchema.d.ts.map