@mxf-dev/core 1.0.0

package/dist/events/EventNames.d.ts

@@ -0,0 +1,747 @@
+/**
+ * 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/
+ */
+/**
+ * Event Names and Payload Types
+ *
+ * This file centralizes all event names and their associated payload types used in the framework
+ * to avoid string literals and prevent mismatches between emitters and listeners.
+ *
+ * THIS IS THE SINGLE SOURCE OF TRUTH for all event names and payload types in the framework.
+ * Both the server and SDK import from this file.
+ */
+/**
+ * Core Socket.IO events that are part of the Socket.IO library itself
+ */
+export declare const CoreSocketEvents: {
+    CONNECT: string;
+    DISCONNECT: string;
+    CONNECT_ERROR: string;
+    RECONNECT: string;
+    RECONNECT_ATTEMPT: string;
+    RECONNECT_ERROR: string;
+    RECONNECT_FAILED: string;
+    ERROR: string;
+    CONNECTION: string;
+    PING: string;
+    PONG: string;
+};
+/**
+ * Reserved socket.io events that should not be re-emitted to prevent loops and conflicts
+ */
+export declare const SOCKET_RESERVED_EVENTS: string[];
+export type SocketReservedEventType = typeof SOCKET_RESERVED_EVENTS[number];
+/**
+ * Payload types for Core Socket.IO events
+ */
+export interface CoreSocketPayloads {
+    'connect': void;
+    'disconnect': {
+        reason: string;
+    };
+    'connect_error': Error;
+    'reconnect': number;
+    'reconnect_attempt': number;
+    'reconnect_error': Error;
+    'reconnect_failed': void;
+    'error': Error;
+    'connection': {
+        socketId: string;
+    };
+    'ping': any;
+    'pong': any;
+}
+import { AgentEvents } from './event-definitions/AgentEvents.js';
+import type { AgentPayloads, AgentRegistrationEvent, AgentConnectionEvent } from './event-definitions/AgentEvents.js';
+export { AgentEvents };
+export type { AgentPayloads, AgentRegistrationEvent, AgentConnectionEvent };
+import { MessageEvents } from './event-definitions/MessageEvents.js';
+import type { MessagePayloads, AgentMessageEvent } from './event-definitions/MessageEvents.js';
+export { MessageEvents };
+export type { MessagePayloads, AgentMessageEvent };
+import { Events as ChannelEventsInternal, ChannelActionTypes } from './event-definitions/ChannelEvents.js';
+import type { ChannelPayloads, ChannelActionType, ChannelCreationEvent } from './event-definitions/ChannelEvents.js';
+export { ChannelEventsInternal as ChannelEvents, ChannelActionTypes };
+export type { ChannelPayloads, ChannelActionType, ChannelCreationEvent };
+import { MemoryEvents } from './event-definitions/MemoryEvents.js';
+import type { MemoryPayloads, MemoryUpdateEvent, MemoryCreateEvent, MemoryScope, MemoryGetEvent, MemoryDeleteEvent, MemorySyncEvent } from './event-definitions/MemoryEvents.js';
+export { MemoryEvents };
+export type { MemoryPayloads, MemoryUpdateEvent, MemoryCreateEvent, MemoryScope, MemoryGetEvent, MemoryDeleteEvent, MemorySyncEvent };
+import { TaskEvents } from './event-definitions/TaskEvents.js';
+import type { TaskPayloads, TaskRequestEvent, TaskResponseEvent } from './event-definitions/TaskEvents.js';
+export { TaskEvents };
+export type { TaskPayloads, TaskRequestEvent, TaskResponseEvent };
+import { LlmServiceEvents } from './event-definitions/LlmEvents.js';
+import type { LlmServicePayloads } from './event-definitions/LlmEvents.js';
+export { LlmServiceEvents };
+export type { LlmServicePayloads };
+import { HeartbeatEvents } from './event-definitions/HeartbeatEvents.js';
+import type { HeartbeatPayloads } from './event-definitions/HeartbeatEvents.js';
+export { HeartbeatEvents };
+export type { HeartbeatPayloads };
+import { McpEvents } from './event-definitions/McpEvents.js';
+import type { McpPayloads } from './event-definitions/McpEvents.js';
+export { McpEvents };
+export type { McpPayloads };
+import { ControlLoopEvents } from './event-definitions/ControlLoopEvents.js';
+import type { ControlLoopPayloads } from './event-definitions/ControlLoopEvents.js';
+export { ControlLoopEvents };
+export type { ControlLoopPayloads };
+import { OrparEvents } from './event-definitions/OrparEvents.js';
+import type { OrparPayloads } from './event-definitions/OrparEvents.js';
+export { OrparEvents };
+export type { OrparPayloads };
+import { SystemEvents } from './event-definitions/SystemEvents.js';
+export { SystemEvents };
+import { AnalyticsEvents } from './event-definitions/AnalyticsEvents.js';
+import type { AnalyticsPayloads } from './event-definitions/AnalyticsEvents.js';
+export { AnalyticsEvents };
+export type { AnalyticsPayloads };
+import { ConfigEvents } from './event-definitions/ConfigEvents.js';
+import type { ConfigPayloads } from './event-definitions/ConfigEvents.js';
+export { ConfigEvents };
+export type { ConfigPayloads };
+import { BulkEvents } from './event-definitions/BulkEvents.js';
+import type { BulkPayloads } from './event-definitions/BulkEvents.js';
+export { BulkEvents };
+export type { BulkPayloads };
+import { MxpEvents } from './event-definitions/MxpEvents.js';
+import type { MxpPayloads } from './event-definitions/MxpEvents.js';
+export { MxpEvents };
+export type { MxpPayloads };
+import { KeyEvents } from './event-definitions/KeyEvents.js';
+import type { KeyPayloads } from './event-definitions/KeyEvents.js';
+export { KeyEvents };
+export type { KeyPayloads };
+import { MeilisearchEvents } from './event-definitions/MeilisearchEvents.js';
+import type { MeilisearchPayloads } from './event-definitions/MeilisearchEvents.js';
+export { MeilisearchEvents };
+export type { MeilisearchPayloads };
+import { CodeExecutionEvents } from './event-definitions/CodeExecutionEvents.js';
+import type { CodeExecutionPayloads } from './event-definitions/CodeExecutionEvents.js';
+export { CodeExecutionEvents };
+export type { CodeExecutionPayloads };
+import { ShellExecutionEvents } from './event-definitions/ShellExecutionEvents.js';
+import type { ShellExecutionPayloads } from './event-definitions/ShellExecutionEvents.js';
+export { ShellExecutionEvents };
+export type { ShellExecutionPayloads };
+import { WorkflowEvents } from './event-definitions/WorkflowEvents.js';
+import type { WorkflowPayloads } from './event-definitions/WorkflowEvents.js';
+export { WorkflowEvents };
+export type { WorkflowPayloads };
+import { InferenceParameterEvents } from './event-definitions/InferenceParameterEvents.js';
+import type { InferenceParameterPayloads } from './event-definitions/InferenceParameterEvents.js';
+export { InferenceParameterEvents };
+export type { InferenceParameterPayloads };
+import { PlanEvents } from './event-definitions/PlanEvents.js';
+import type { PlanPayloads, PlanStepCompletedEventData } from './event-definitions/PlanEvents.js';
+export { PlanEvents };
+export type { PlanPayloads, PlanStepCompletedEventData };
+import { MemoryUtilityEvents } from './event-definitions/MemoryUtilityEvents.js';
+import type { MemoryUtilityPayloads } from './event-definitions/MemoryUtilityEvents.js';
+export { MemoryUtilityEvents };
+export type { MemoryUtilityPayloads };
+import { OrparMemoryEvents } from './event-definitions/OrparMemoryEvents.js';
+import type { OrparMemoryPayloads } from './event-definitions/OrparMemoryEvents.js';
+export { OrparMemoryEvents };
+export type { OrparMemoryPayloads };
+import { DagEvents } from './event-definitions/DagEvents.js';
+import type { DagPayloads } from './event-definitions/DagEvents.js';
+export { DagEvents };
+export type { DagPayloads };
+import { KnowledgeGraphEvents } from './event-definitions/KnowledgeGraphEvents.js';
+import type { KnowledgeGraphPayloads } from './event-definitions/KnowledgeGraphEvents.js';
+export { KnowledgeGraphEvents };
+export type { KnowledgeGraphPayloads };
+import { TensorFlowEvents } from './event-definitions/TensorFlowEvents.js';
+import type { TensorFlowPayloads } from './event-definitions/TensorFlowEvents.js';
+export { TensorFlowEvents };
+export type { TensorFlowPayloads };
+import { UserInputEvents } from './event-definitions/UserInputEvents.js';
+import type { UserInputPayloads } from './event-definitions/UserInputEvents.js';
+export { UserInputEvents };
+export type { UserInputPayloads };
+import { CompactionEvents } from './event-definitions/CompactionEvents.js';
+import type { CompactionPayloads } from './event-definitions/CompactionEvents.js';
+export { CompactionEvents };
+export type { CompactionPayloads };
+import { ProgressEvents } from './event-definitions/ProgressEvents.js';
+import type { ProgressPayloads } from './event-definitions/ProgressEvents.js';
+export { ProgressEvents };
+export type { ProgressPayloads };
+/**
+ * Socket Authentication Events
+ * Used for socket authentication success/failure communication
+ */
+export declare const AuthEvents: {
+    readonly SUCCESS: "auth:success";
+    readonly ERROR: "auth:error";
+};
+/**
+ * Unified export of all events for convenience
+ */
+export declare namespace Events {
+    const Core: {
+        CONNECT: string;
+        DISCONNECT: string;
+        CONNECT_ERROR: string;
+        RECONNECT: string;
+        RECONNECT_ATTEMPT: string;
+        RECONNECT_ERROR: string;
+        RECONNECT_FAILED: string;
+        ERROR: string;
+        CONNECTION: string;
+        PING: string;
+        PONG: string;
+    };
+    const Agent: {
+        REGISTER: string;
+        REGISTERED: string;
+        REGISTRATION_FAILED: string;
+        CONNECT: string;
+        CONNECTED: string;
+        DISCONNECT: string;
+        DISCONNECTED: string;
+        CONNECTION_ERROR: string;
+        CONNECTION_STATUS: string;
+        STATUS_CHANGE: string;
+        ERROR: string;
+        AGENT_MESSAGE: string;
+        TOOL_CALL: string;
+        TOOL_RESULT: string;
+        CONTEXT_UPDATE: string;
+        LLM_RESPONSE: string;
+        LLM_REASONING: string;
+        LLM_REASONING_PARSED: string;
+        LLM_REASONING_TOOLS_SYNTHESIZED: string;
+        LLM_USAGE: string;
+        LLM_STREAM_CHUNK: string;
+        TASK_ASSIGNED: string;
+        JOIN_CHANNEL: string;
+        JOINED_CHANNEL: string;
+        JOIN_CHANNEL_FAILED: string;
+        LEAVE_CHANNEL: string;
+        LEFT_CHANNEL: string;
+        LEAVE_CHANNEL_FAILED: string;
+        DISCOVERY_REQUEST: string;
+        DISCOVERY_RESPONSE: string;
+        RESTART_REQUEST: string;
+        RESTART_RESPONSE: string;
+        SHUTDOWN_REQUEST: string;
+        SHUTDOWN_RESPONSE: string;
+        PAUSE_REQUEST: string;
+        PAUSE_RESPONSE: string;
+        RESUME_REQUEST: string;
+        RESUME_RESPONSE: string;
+        METRICS_REQUEST: string;
+        METRICS_RESPONSE: string;
+        ALLOWED_TOOLS_UPDATE: string;
+        ALLOWED_TOOLS_UPDATED: string;
+        CONTEXT_COMPACT_NEEDED: string;
+        CONTEXT_COMPACTED: string;
+    };
+    const Message: {
+        AGENT_MESSAGE: string;
+        AGENT_MESSAGE_DELIVERED: string;
+        CHANNEL_MESSAGE: string;
+        CHANNEL_MESSAGE_DELIVERED: string;
+        MESSAGE_ERROR: string;
+        SYSTEM_MESSAGE: string;
+        SYSTEM_MESSAGE_DELIVERED: string;
+        LLM_MESSAGE: string;
+        PERSIST_CHANNEL_MESSAGE_REQUEST: string;
+        MESSAGE_PERSIST_FAILED: string;
+        MESSAGE_SEND_FAILED: string;
+    };
+    const Channel: {
+        CREATE: string;
+        CREATED: string;
+        CREATION_FAILED: string;
+        UPDATE: string;
+        UPDATED: string;
+        UPDATE_FAILED: string;
+        DELETE: string;
+        DELETED: string;
+        DELETE_FAILED: string;
+        ARCHIVE: string;
+        ARCHIVED: string;
+        ARCHIVE_FAILED: string;
+        AGENT_JOINED: string;
+        AGENT_LEFT: string;
+        CONTEXT: {
+            GET: string;
+            GOT: string;
+            GET_FAILED: string;
+            UPDATE: string;
+            UPDATED: string;
+            UPDATE_FAILED: string;
+            METADATA_SET: string;
+            METADATA_SET_SUCCESS: string;
+            METADATA_SET_FAILED: string;
+            METADATA_GET: string;
+            METADATA_GOT: string;
+            METADATA_GET_FAILED: string;
+            TOPICS_EXTRACT: string;
+            TOPICS_EXTRACTED: string;
+            TOPICS_EXTRACT_FAILED: string;
+            SUMMARY_GENERATE: string;
+            SUMMARY_GENERATED: string;
+            SUMMARY_GENERATE_FAILED: string;
+        };
+        BULK_MESSAGES_PERSISTED: string;
+    };
+    const Key: {
+        GENERATE: string;
+        GENERATED: string;
+        GENERATION_FAILED: string;
+        VALIDATE: string;
+        VALIDATED: string;
+        VALIDATION_FAILED: string;
+        ROTATE: string;
+        ROTATED: string;
+        ROTATION_FAILED: string;
+        DEACTIVATE: string;
+        DEACTIVATED: string;
+        DEACTIVATION_FAILED: string;
+        LIST: string;
+        LISTED: string;
+        LIST_FAILED: string;
+    };
+    const Task: {
+        readonly REQUEST: "task:request";
+        readonly RESPONSE: "task:response";
+        readonly CREATE_REQUEST: "task:create_request";
+        readonly START_REQUEST: "task:start_request";
+        readonly COMPLETE_REQUEST: "task:complete_request";
+        readonly FAIL_REQUEST: "task:fail_request";
+        readonly CANCEL_REQUEST: "task:cancel_request";
+        readonly ASSIGN_REQUEST: "task:assign_request";
+        readonly UPDATE_REQUEST: "task:update_request";
+        readonly WORKLOAD_ANALYZE_REQUEST: "task:workload_analyze_request";
+        readonly CREATED: "task:created";
+        readonly ASSIGNED: "task:assigned";
+        readonly STARTED: "task:started";
+        readonly PROGRESS_UPDATED: "task:progress_updated";
+        readonly COMPLETED: "task:completed";
+        readonly FAILED: "task:failed";
+        readonly ERROR: "task:error";
+        readonly CANCELLED: "task:cancelled";
+        readonly REASSIGNED: "task:reassigned";
+        readonly ASSIGNMENT_REQUESTED: "task:assignment_requested";
+        readonly ASSIGNMENT_ANALYZED: "task:assignment_analyzed";
+        readonly WORKLOAD_ANALYZED: "task:workload_analyzed";
+        readonly AGENT_OVERLOADED: "task:agent_overloaded";
+        readonly DEPENDENCY_RESOLVED: "task:dependency_resolved";
+        readonly BLOCKING_CLEARED: "task:blocking_cleared";
+        readonly LATE_AGENT_JOINED: "task:late_agent_joined";
+        readonly ORCHESTRATION_CONFIG_UPDATED: "task:orchestration_config_updated";
+    };
+    const LlmService: {
+        INSTRUCTION_STARTED: string;
+        INSTRUCTION_COMPLETED: string;
+        INSTRUCTION_ERROR: string;
+    };
+    const ControlLoop: {
+        INITIALIZE: string;
+        INITIALIZED: string;
+        STARTED: string;
+        OBSERVATION: string;
+        REASONING: string;
+        PLAN: string;
+        EXECUTION: string;
+        REFLECTION: string;
+        ACTION: string;
+        STOPPED: string;
+        ERROR: string;
+        SYSTEM_LLM_REASONING: string;
+        SYSTEM_LLM_REASONING_COMPLETED: string;
+        SYSTEM_LLM_REASONING_FAILED: string;
+    };
+    const Orpar: {
+        readonly OBSERVE: "orpar:observe";
+        readonly REASON: "orpar:reason";
+        readonly PLAN: "orpar:plan";
+        readonly ACT: "orpar:act";
+        readonly REFLECT: "orpar:reflect";
+        readonly STATUS: "orpar:status";
+        readonly ERROR: "orpar:error";
+        readonly CLEAR_STATE: "orpar:clearState";
+    };
+    const Heartbeat: {
+        HEARTBEAT: string;
+        HEARTBEAT_RESPONSE: string;
+        HEARTBEAT_TIMEOUT: string;
+    };
+    const Mcp: {
+        SERVER_START: string;
+        SERVER_STOP: string;
+        SERVER_ERROR: string;
+        SERVER_STATUS: string;
+        EXTERNAL_SERVER_REGISTER: string;
+        EXTERNAL_SERVER_REGISTERED: string;
+        EXTERNAL_SERVER_UNREGISTER: string;
+        EXTERNAL_SERVER_UNREGISTERED: string;
+        EXTERNAL_SERVER_REGISTRATION_FAILED: string;
+        CHANNEL_SERVER_REGISTER: string;
+        CHANNEL_SERVER_REGISTERED: string;
+        CHANNEL_SERVER_UNREGISTER: string;
+        CHANNEL_SERVER_UNREGISTERED: string;
+        CHANNEL_SERVER_REGISTRATION_FAILED: string;
+        EXTERNAL_SERVER_SPAWN: string;
+        EXTERNAL_SERVER_STARTED: string;
+        EXTERNAL_SERVER_STOP: string;
+        EXTERNAL_SERVER_STOPPED: string;
+        EXTERNAL_SERVER_ERROR: string;
+        EXTERNAL_SERVER_HEALTH_CHECK: string;
+        EXTERNAL_SERVER_HEALTH_STATUS: string;
+        EXTERNAL_SERVER_RESTART: string;
+        EXTERNAL_SERVER_DISCOVERY: string;
+        EXTERNAL_SERVER_TOOLS_DISCOVERED: string;
+        TOOL_REGISTER: string;
+        TOOL_REGISTERED: string;
+        TOOL_UNREGISTER: string;
+        TOOL_UNREGISTERED: string;
+        TOOL_REGISTRY_CHANGED: string;
+        TOOL_LIST: string;
+        TOOL_LIST_RESULT: string;
+        TOOL_LIST_ERROR: string;
+        TOOL_CALL: string;
+        TOOL_RESULT: string;
+        TOOL_ERROR: string;
+        TOOL_EXECUTION: string;
+        TOOL_CALL_LOCAL: string;
+        TOOL_RESULT_LOCAL: string;
+        TOOL_ERROR_LOCAL: string;
+        TOOL_CALL_COMPLETED_LOCAL: string;
+        TOOL_VALIDATION_STARTED: string;
+        TOOL_VALIDATION_COMPLETED: string;
+        TOOL_VALIDATION_ERROR: string;
+        MXF_TOOL_LIST: string;
+        MXF_TOOL_LIST_RESULT: string;
+        MXF_TOOL_LIST_ERROR: string;
+        RESOURCE_GET: string;
+        RESOURCE_RESULT: string;
+        RESOURCE_ERROR: string;
+        RESOURCE_LIST: string;
+        RESOURCE_LIST_RESULT: string;
+    };
+    const Memory: {
+        GET: string;
+        GET_RESULT: string;
+        GET_ERROR: string;
+        UPDATE: string;
+        UPDATE_RESULT: string;
+        UPDATE_ERROR: string;
+        CREATE: string;
+        CREATE_RESULT: string;
+        CREATE_ERROR: string;
+        DELETE: string;
+        DELETE_RESULT: string;
+        DELETE_ERROR: string;
+        CLEAR: string;
+        CLEAR_RESULT: string;
+        CLEAR_ERROR: string;
+        CLEAR_ALL: string;
+        CLEAR_ALL_RESULT: string;
+        CLEAR_ALL_ERROR: string;
+        RECALL: string;
+        STORE: string;
+        FORGET: string;
+        SYNC: string;
+        SYNC_COMPLETE: string;
+        SYNC_ERROR: string;
+        EXPIRE: string;
+        EXPIRE_COMPLETE: string;
+        EXPIRE_ERROR: string;
+    };
+    const System: {
+        readonly EPHEMERAL_INJECTION: "system:ephemeral:injection";
+        readonly CONTEXT_ANALYSIS: "system:context:analysis";
+        readonly COORDINATION_HINT: "system:coordination:hint";
+        readonly ACTIVITY_ALERT: "system:activity:alert";
+        readonly INTERPRETATION: "system:interpretation";
+        readonly TEMPORAL_CONTEXT_UPDATE: "system:temporal:context:update";
+        readonly TEMPORAL_PATTERN_DETECTED: "system:temporal:pattern:detected";
+        readonly PRE_REASONING_HINT: "system:orpar:pre:reasoning:hint";
+        readonly POST_ACTION_ANALYSIS: "system:orpar:post:action:analysis";
+        readonly COORDINATION_OPPORTUNITY: "system:coordination:opportunity";
+        readonly PATTERN_RECOGNITION: "system:pattern:recognition";
+        readonly MAINTENANCE_MODE: "system:maintenance:mode";
+    };
+    const Analytics: {
+        readonly AGENT_PERFORMANCE_UPDATED: "analytics:agent:performance:updated";
+        readonly CHANNEL_ACTIVITY_UPDATED: "analytics:channel:activity:updated";
+        readonly TASK_COMPLETION_ANALYTICS: "analytics:task:completion:updated";
+        readonly SYSTEM_HEALTH_UPDATED: "analytics:system:health:updated";
+        readonly REPORT_REQUESTED: "analytics:report:requested";
+        readonly REPORT_GENERATED: "analytics:report:generated";
+        readonly REPORT_FAILED: "analytics:report:failed";
+        readonly PERFORMANCE_ALERT: "analytics:performance:alert";
+        readonly HEALTH_ALERT: "analytics:health:alert";
+        readonly THRESHOLD_EXCEEDED: "analytics:threshold:exceeded";
+        readonly METRIC_UPDATE: "analytics:metric:update";
+        readonly AB_TEST_STARTED: "analytics:ab:test:started";
+        readonly AB_TEST_COMPLETED: "analytics:ab:test:completed";
+        readonly ANOMALY_DETECTED: "analytics:anomaly:detected";
+        readonly PERFORMANCE_PROFILE_COMPLETED: "analytics:performance:profile:completed";
+        readonly HIGH_ERROR_RISK_PREDICTED: "analytics:high:error:risk:predicted";
+        readonly TASK_STARTED: "analytics:task:started";
+        readonly TASK_COMPLETED: "analytics:task:completed";
+        readonly TASK_EFFECTIVENESS_EVENT: "analytics:task:effectiveness:event";
+        readonly TASK_EFFECTIVENESS_QUALITY_UPDATE: "analytics:task:effectiveness:quality:update";
+    };
+    const Config: {
+        readonly TEMPLATE_CREATED: "config:template:created";
+        readonly TEMPLATE_UPDATED: "config:template:updated";
+        readonly TEMPLATE_DELETED: "config:template:deleted";
+        readonly TEMPLATE_DEPLOYED: "config:template:deployed";
+        readonly DEPLOYMENT_CONFIG_UPDATED: "config:deployment:updated";
+        readonly DEPLOYMENT_CONFIG_VALIDATED: "config:deployment:validated";
+        readonly DEPLOYMENT_CONFIG_FAILED: "config:deployment:failed";
+        readonly ENVIRONMENT_UPDATED: "config:environment:updated";
+        readonly ENVIRONMENT_VALIDATED: "config:environment:validated";
+        readonly CONFIG_SYNC_REQUESTED: "config:sync:requested";
+        readonly CONFIG_SYNC_COMPLETED: "config:sync:completed";
+        readonly CONFIG_SYNC_FAILED: "config:sync:failed";
+        readonly CHANNEL_SYSTEM_LLM_CHANGED: "config:channel_system_llm_changed";
+    };
+    const Bulk: {
+        readonly AGENTS_BULK_CREATE_STARTED: "bulk:agents:create:started";
+        readonly AGENTS_BULK_CREATE_COMPLETED: "bulk:agents:create:completed";
+        readonly AGENTS_BULK_CREATE_FAILED: "bulk:agents:create:failed";
+        readonly AGENTS_BULK_UPDATE_STARTED: "bulk:agents:update:started";
+        readonly AGENTS_BULK_UPDATE_COMPLETED: "bulk:agents:update:completed";
+        readonly AGENTS_BULK_UPDATE_FAILED: "bulk:agents:update:failed";
+        readonly AGENTS_BULK_DELETE_STARTED: "bulk:agents:delete:started";
+        readonly AGENTS_BULK_DELETE_COMPLETED: "bulk:agents:delete:completed";
+        readonly AGENTS_BULK_DELETE_FAILED: "bulk:agents:delete:failed";
+        readonly CHANNELS_BULK_CREATE_STARTED: "bulk:channels:create:started";
+        readonly CHANNELS_BULK_CREATE_COMPLETED: "bulk:channels:create:completed";
+        readonly CHANNELS_BULK_CREATE_FAILED: "bulk:channels:create:failed";
+        readonly CHANNELS_BULK_UPDATE_STARTED: "bulk:channels:update:started";
+        readonly CHANNELS_BULK_UPDATE_COMPLETED: "bulk:channels:update:completed";
+        readonly CHANNELS_BULK_UPDATE_FAILED: "bulk:channels:update:failed";
+        readonly CHANNELS_BULK_DELETE_STARTED: "bulk:channels:delete:started";
+        readonly CHANNELS_BULK_DELETE_COMPLETED: "bulk:channels:delete:completed";
+        readonly CHANNELS_BULK_DELETE_FAILED: "bulk:channels:delete:failed";
+        readonly TASKS_BULK_CREATE_STARTED: "bulk:tasks:create:started";
+        readonly TASKS_BULK_CREATE_COMPLETED: "bulk:tasks:create:completed";
+        readonly TASKS_BULK_CREATE_FAILED: "bulk:tasks:create:failed";
+        readonly TASKS_BULK_ASSIGN_STARTED: "bulk:tasks:assign:started";
+        readonly TASKS_BULK_ASSIGN_COMPLETED: "bulk:tasks:assign:completed";
+        readonly TASKS_BULK_ASSIGN_FAILED: "bulk:tasks:assign:failed";
+        readonly TASKS_BULK_UPDATE_STARTED: "bulk:tasks:update:started";
+        readonly TASKS_BULK_UPDATE_COMPLETED: "bulk:tasks:update:completed";
+        readonly TASKS_BULK_UPDATE_FAILED: "bulk:tasks:update:failed";
+        readonly BULK_OPERATION_PROGRESS: "bulk:operation:progress";
+        readonly PROGRESS_UPDATE: "bulk:operation:progress:update";
+        readonly BULK_OPERATION_CANCELLED: "bulk:operation:cancelled";
+    };
+    const Auth: {
+        readonly SUCCESS: "auth:success";
+        readonly ERROR: "auth:error";
+    };
+    const Mxp: {
+        readonly TOKEN_OPTIMIZATION_START: "mxp:token:optimization:start";
+        readonly TOKEN_OPTIMIZATION_COMPLETE: "mxp:token:optimization:complete";
+        readonly CONTEXT_COMPRESSED: "mxp:token:context:compressed";
+        readonly PROMPT_OPTIMIZED: "mxp:token:prompt:optimized";
+        readonly TEMPLATE_GENERATED: "mxp:token:template:generated";
+        readonly TEMPLATE_APPLIED: "mxp:token:template:applied";
+        readonly BANDWIDTH_OPTIMIZATION_START: "mxp:bandwidth:optimization:start";
+        readonly BANDWIDTH_OPTIMIZATION_COMPLETE: "mxp:bandwidth:optimization:complete";
+        readonly MESSAGE_COMPRESSED: "mxp:bandwidth:message:compressed";
+        readonly BATCH_CREATED: "mxp:bandwidth:batch:created";
+        readonly BINARY_ENCODED: "mxp:bandwidth:binary:encoded";
+        readonly SECURITY_LEVEL_CHANGED: "mxp:security:level:changed";
+        readonly KEY_ROTATED: "mxp:security:key:rotated";
+        readonly ENCRYPTION_ENHANCED: "mxp:security:encryption:enhanced";
+        readonly OPTIMIZATION_METRICS: "mxp:analytics:metrics";
+        readonly PERFORMANCE_REPORT: "mxp:analytics:performance";
+        readonly COST_SAVINGS_CALCULATED: "mxp:analytics:cost:savings";
+    };
+    const Meilisearch: {
+        readonly INDEX_REQUEST: "meilisearch:index:request";
+        readonly BACKFILL_REQUEST: "meilisearch:backfill:request";
+        readonly INDEX: "meilisearch:index";
+        readonly INDEX_ERROR: "meilisearch:index:error";
+        readonly BACKFILL_COMPLETE: "meilisearch:backfill:complete";
+        readonly BACKFILL_PARTIAL: "meilisearch:backfill:partial";
+        readonly BACKFILL_ERROR: "meilisearch:backfill:error";
+    };
+    const CodeExecution: {
+        readonly CODE_EXECUTION_STARTED: "code:execution:started";
+        readonly CODE_EXECUTION_COMPLETED: "code:execution:completed";
+        readonly CODE_EXECUTION_FAILED: "code:execution:failed";
+        readonly CODE_VALIDATION_STARTED: "code:validation:started";
+        readonly CODE_VALIDATION_COMPLETED: "code:validation:completed";
+        readonly CODE_SECURITY_ISSUE: "code:security:issue";
+        readonly CODE_RESOURCE_LIMIT_EXCEEDED: "code:resource:limit:exceeded";
+        readonly CODE_EXECUTION_TIMEOUT: "code:execution:timeout";
+    };
+    const Shell: {
+        readonly SHELL_EXECUTION_STARTED: "shell:execution:started";
+        readonly SHELL_EXECUTION_COMPLETED: "shell:execution:completed";
+        readonly SHELL_EXECUTION_FAILED: "shell:execution:failed";
+        readonly SHELL_EXECUTION_PROGRESS: "shell:execution:progress";
+        readonly SHELL_DESTRUCTIVE_WARNING: "shell:destructive:warning";
+        readonly SHELL_BACKGROUND_STARTED: "shell:background:started";
+        readonly SHELL_BACKGROUND_COMPLETED: "shell:background:completed";
+        readonly SHELL_OUTPUT_PERSISTED: "shell:output:persisted";
+    };
+    const Workflow: {
+        readonly WORKFLOW_REGISTERED: "workflow:registered";
+        readonly WORKFLOW_UNREGISTERED: "workflow:unregistered";
+        readonly WORKFLOW_STARTED: "workflow:started";
+        readonly WORKFLOW_COMPLETED: "workflow:completed";
+        readonly WORKFLOW_FAILED: "workflow:failed";
+        readonly WORKFLOW_CANCELLED: "workflow:cancelled";
+        readonly WORKFLOW_STATE_UPDATED: "workflow:state_updated";
+        readonly WORKFLOW_STEP_STARTED: "workflow:step_started";
+        readonly WORKFLOW_STEP_COMPLETED: "workflow:step_completed";
+        readonly WORKFLOW_STEP_FAILED: "workflow:step_failed";
+        readonly WORKFLOW_TEMPLATE_REGISTERED: "workflow:template_registered";
+        readonly WORKFLOW_TEMPLATE_UNREGISTERED: "workflow:template_unregistered";
+        readonly WORKFLOW_EXECUTION_CREATED: "workflow:execution_created";
+        readonly WORKFLOW_EXECUTION_COMPLETED: "workflow:execution_completed";
+    };
+    const InferenceParameter: {
+        readonly PARAMETER_REQUESTED: "inference:parameter_requested";
+        readonly PARAMETER_APPROVED: "inference:parameter_approved";
+        readonly PARAMETER_MODIFIED: "inference:parameter_modified";
+        readonly PARAMETER_DENIED: "inference:parameter_denied";
+        readonly PARAMETER_RESET: "inference:parameter_reset";
+        readonly PARAMETER_USAGE_RECORDED: "inference:usage_recorded";
+        readonly OVERRIDE_CREATED: "inference:override_created";
+        readonly OVERRIDE_CONSUMED: "inference:override_consumed";
+        readonly OVERRIDE_EXPIRED: "inference:override_expired";
+    };
+    const Plan: {
+        readonly PLAN_CREATED: "plan:created";
+        readonly PLAN_UPDATED: "plan:updated";
+        readonly PLAN_DELETED: "plan:deleted";
+        readonly PLAN_STEP_COMPLETED: "plan:step_completed";
+        readonly PLAN_STEP_STARTED: "plan:step_started";
+        readonly PLAN_STEP_BLOCKED: "plan:step_blocked";
+        readonly PLAN_SHARED: "plan:shared";
+    };
+    const MemoryUtility: {
+        readonly QVALUE_UPDATED: "memory:qvalue_updated";
+        readonly QVALUE_BATCH_UPDATED: "memory:qvalue_batch_updated";
+        readonly UTILITY_RETRIEVAL_COMPLETED: "memory:utility_retrieval_completed";
+        readonly REWARD_ATTRIBUTED: "memory:reward_attributed";
+        readonly MEMORY_TRACKED: "memory:tracked";
+        readonly CONFIG_UPDATED: "memory:utility_config_updated";
+    };
+    const OrparMemory: {
+        readonly PHASE_MEMORY_RETRIEVED: "orparMemory:phase:memory:retrieved";
+        readonly PHASE_MEMORY_STORED: "orparMemory:phase:memory:stored";
+        readonly PHASE_STRATA_CONFIG_UPDATED: "orparMemory:phase:strata:config:updated";
+        readonly SURPRISE_DETECTED: "orparMemory:surprise:detected";
+        readonly SURPRISE_DECISION_MADE: "orparMemory:surprise:decision:made";
+        readonly ADDITIONAL_OBSERVATION_QUEUED: "orparMemory:surprise:observation:queued";
+        readonly SURPRISE_CONTEXT_INJECTED: "orparMemory:surprise:context:injected";
+        readonly PLAN_RECONSIDERATION_TRIGGERED: "orparMemory:surprise:plan:reconsider";
+        readonly PHASE_REWARD_CALCULATED: "orparMemory:reward:calculated";
+        readonly PHASE_REWARD_ATTRIBUTED: "orparMemory:reward:attributed";
+        readonly PHASE_REWARDS_BATCH_APPLIED: "orparMemory:reward:batch:applied";
+        readonly CONSOLIDATION_TRIGGERED: "orparMemory:consolidation:triggered";
+        readonly MEMORY_PROMOTED: "orparMemory:consolidation:promoted";
+        readonly MEMORY_DEMOTED: "orparMemory:consolidation:demoted";
+        readonly MEMORY_ARCHIVED: "orparMemory:consolidation:archived";
+        readonly MEMORY_ABSTRACTED: "orparMemory:consolidation:abstracted";
+        readonly CYCLE_STARTED: "orparMemory:cycle:started";
+        readonly PHASE_CHANGED: "orparMemory:cycle:phase:changed";
+        readonly CYCLE_COMPLETED: "orparMemory:cycle:completed";
+        readonly CYCLE_MEMORY_USAGE_RECORDED: "orparMemory:cycle:memory:recorded";
+        readonly PHASE_ROUTING_ERROR: "orparMemory:error:phase:routing";
+        readonly SURPRISE_PROCESSING_ERROR: "orparMemory:error:surprise";
+        readonly REWARD_ATTRIBUTION_ERROR: "orparMemory:error:reward";
+        readonly CONSOLIDATION_ERROR: "orparMemory:error:consolidation";
+    };
+    const Dag: {
+        readonly TASK_DEPENDENCIES_RESOLVED: "dag:task_dependencies_resolved";
+        readonly TASK_BLOCKED: "dag:task_blocked";
+        readonly TASK_UNBLOCKED: "dag:task_unblocked";
+        readonly DEPENDENCY_ADDED: "dag:dependency_added";
+        readonly DEPENDENCY_REMOVED: "dag:dependency_removed";
+        readonly DAG_UPDATED: "dag:updated";
+        readonly CYCLE_DETECTED: "dag:cycle_detected";
+        readonly VALIDATION_FAILED: "dag:validation_failed";
+        readonly VALIDATION_WARNING: "dag:validation_warning";
+        readonly EXECUTION_ORDER_COMPUTED: "dag:execution_order_computed";
+        readonly CRITICAL_PATH_COMPUTED: "dag:critical_path_computed";
+    };
+    const KnowledgeGraph: {
+        readonly ENTITY_CREATED: "kg:entity_created";
+        readonly ENTITY_UPDATED: "kg:entity_updated";
+        readonly ENTITY_DELETED: "kg:entity_deleted";
+        readonly ENTITY_MERGED: "kg:entity_merged";
+        readonly RELATIONSHIP_CREATED: "kg:relationship_created";
+        readonly RELATIONSHIP_UPDATED: "kg:relationship_updated";
+        readonly RELATIONSHIP_DELETED: "kg:relationship_deleted";
+        readonly EXTRACTION_STARTED: "kg:extraction_started";
+        readonly EXTRACTION_COMPLETED: "kg:extraction_completed";
+        readonly EXTRACTION_FAILED: "kg:extraction_failed";
+        readonly ENTITY_QVALUE_UPDATED: "kg:entity_qvalue_updated";
+        readonly ENTITY_QVALUE_BATCH_UPDATED: "kg:entity_qvalue_batch_updated";
+        readonly HIGH_SURPRISE_RELATIONSHIP: "kg:high_surprise_relationship";
+        readonly CONFLICTING_RELATIONSHIP: "kg:conflicting_relationship";
+        readonly GRAPH_QUERY_EXECUTED: "kg:graph_query_executed";
+        readonly CONTEXT_RETRIEVED: "kg:context_retrieved";
+        readonly GRAPH_UPDATED: "kg:graph_updated";
+    };
+    const TensorFlow: {
+        readonly MODEL_REGISTERED: "tf:model_registered";
+        readonly MODEL_TRAINING_STARTED: "tf:model_training_started";
+        readonly MODEL_TRAINING_COMPLETED: "tf:model_training_completed";
+        readonly MODEL_TRAINING_FAILED: "tf:model_training_failed";
+        readonly MODEL_LOADED: "tf:model_loaded";
+        readonly MODEL_SAVED: "tf:model_saved";
+        readonly INFERENCE_COMPLETED: "tf:inference_completed";
+        readonly INFERENCE_FALLBACK: "tf:inference_fallback";
+        readonly MEMORY_WARNING: "tf:memory_warning";
+        readonly MEMORY_STATS: "tf:memory_stats";
+    };
+    const UserInput: {
+        readonly REQUEST: "user_input:request";
+        readonly RESPONSE: "user_input:response";
+        readonly CANCELLED: "user_input:cancelled";
+        readonly TIMEOUT: "user_input:timeout";
+    };
+    const Compaction: {
+        readonly MICROCOMPACTION_APPLIED: "compaction:micro:applied";
+        readonly AUTO_COMPACTION_TRIGGERED: "compaction:auto:triggered";
+        readonly REACTIVE_COMPACTION_TRIGGERED: "compaction:reactive:triggered";
+        readonly POST_COMPACTION_RESTORED: "compaction:restoration:completed";
+        readonly COMPACTION_SUMMARY_GENERATED: "compaction:summary:generated";
+    };
+    const Progress: {
+        readonly PROGRESS_UPDATE: "progress:update";
+    };
+}
+/**
+ * Complete event map combining all event payloads
+ */
+export type EventMap = CoreSocketPayloads & AgentPayloads & MessagePayloads & ChannelPayloads & KeyPayloads & TaskPayloads & LlmServicePayloads & ControlLoopPayloads & OrparPayloads & HeartbeatPayloads & McpPayloads & MemoryPayloads & AnalyticsPayloads & ConfigPayloads & BulkPayloads & MxpPayloads & MeilisearchPayloads & CodeExecutionPayloads & ShellExecutionPayloads & WorkflowPayloads & InferenceParameterPayloads & PlanPayloads & MemoryUtilityPayloads & OrparMemoryPayloads & DagPayloads & KnowledgeGraphPayloads & TensorFlowPayloads & UserInputPayloads & CompactionPayloads & ProgressPayloads;
+/**
+ * Event name type - any valid event name
+ */
+export type EventName = keyof EventMap;
+//# sourceMappingURL=EventNames.d.ts.map