@mxf-dev/core 1.0.0

package/dist/events/event-definitions/TaskEvents.d.ts

@@ -0,0 +1,239 @@
+/**
+ * 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/
+ */
+/**
+ * Task Management Events for MXF Framework
+ *
+ * Comprehensive event definitions for task creation, assignment, orchestration
+ * and SystemLLM-powered intelligent agent assignment
+ */
+import { ChannelTask, AgentAssignmentAnalysis, ChannelWorkloadAnalysis } from '../../types/TaskTypes.js';
+import { AgentId } from '../../types/Agent.js';
+import { ChannelId } from '../../types/ChannelContext.js';
+/**
+ * Interface for task request events (legacy - kept for backward compatibility)
+ */
+export interface TaskRequestEvent {
+    taskId: string;
+    fromAgentId: string;
+    toAgentId: string;
+    task: string;
+    timestamp: number;
+}
+/**
+ * Interface for task response events (legacy - kept for backward compatibility)
+ */
+export interface TaskResponseEvent {
+    taskId: string;
+    fromAgentId: string;
+    toAgentId: string;
+    response: string;
+    timestamp: number;
+}
+/**
+ * Standard task event payload structure.
+ *
+ * Re-exported from EventPayloadSchema so there is exactly ONE TaskEventPayload
+ * in the framework — a local duplicate here drifted from the envelope type and
+ * made the typed EventBus double-wrap task entries.
+ */
+import type { TaskEventPayload } from '../../schemas/EventPayloadSchema.js';
+export type { TaskEventPayload };
+/**
+ * Task creation event payload
+ */
+export type TaskCreatedEvent = TaskEventPayload & {
+    data: {
+        task: ChannelTask;
+    };
+};
+/**
+ * Task assignment event payload
+ */
+export type TaskAssignedEvent = TaskEventPayload & {
+    data: {
+        task: ChannelTask;
+        previousAgentId?: AgentId;
+        assignmentAnalysis?: AgentAssignmentAnalysis;
+    };
+};
+/**
+ * Task progress update event payload
+ */
+export type TaskProgressEvent = TaskEventPayload & {
+    data: {
+        task: ChannelTask;
+        previousProgress: number;
+        progressDelta: number;
+    };
+};
+/**
+ * Task completion event payload
+ */
+export type TaskCompletedEvent = TaskEventPayload & {
+    data: {
+        task: ChannelTask;
+        result: any;
+        duration: number;
+    };
+};
+/**
+ * Agent workload analysis event payload
+ */
+export type AgentWorkloadEvent = TaskEventPayload & {
+    data: {
+        workloadAnalysis: ChannelWorkloadAnalysis;
+        trigger: 'periodic' | 'task_created' | 'task_completed' | 'agent_joined';
+    };
+};
+/**
+ * Enhanced TaskEvents with comprehensive task management
+ */
+export declare const TaskEvents: {
+    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";
+};
+/**
+ * Enhanced payload types for all task events
+ */
+export interface TaskPayloads {
+    'task:request': TaskEventPayload;
+    'task:response': TaskEventPayload;
+    'task:create_request': TaskEventPayload & {
+        data: {
+            task: Partial<ChannelTask> & Pick<ChannelTask, 'title'>;
+        };
+    };
+    'task:start_request': TaskEventPayload & {
+        data: {
+            task: ChannelTask;
+        };
+    };
+    'task:complete_request': TaskEventPayload;
+    'task:fail_request': TaskEventPayload & {
+        data: {
+            task: ChannelTask;
+            error: string;
+        };
+    };
+    'task:cancel_request': TaskEventPayload & {
+        data: {
+            task: ChannelTask;
+            reason?: string;
+        };
+    };
+    'task:assign_request': TaskEventPayload & {
+        data: {
+            task: ChannelTask;
+            agentId: AgentId;
+        };
+    };
+    'task:update_request': TaskEventPayload & {
+        data: {
+            task: ChannelTask;
+            updates: Record<string, any>;
+        };
+    };
+    'task:workload_analyze_request': TaskEventPayload & {
+        data: {
+            channelId: ChannelId;
+        };
+    };
+    'task:created': TaskCreatedEvent;
+    'task:assigned': TaskAssignedEvent;
+    'task:started': TaskEventPayload & {
+        data: {
+            task: ChannelTask;
+        };
+    };
+    'task:progress_updated': TaskEventPayload;
+    'task:completed': TaskEventPayload;
+    'task:failed': TaskEventPayload;
+    'task:cancelled': TaskEventPayload & {
+        data: {
+            task: ChannelTask;
+            reason?: string;
+        };
+    };
+    'task:reassigned': TaskAssignedEvent;
+    'task:assignment_requested': TaskEventPayload & {
+        data: {
+            task: ChannelTask;
+        };
+    };
+    'task:assignment_analyzed': TaskEventPayload & {
+        data: {
+            task: ChannelTask;
+            analysis: AgentAssignmentAnalysis;
+        };
+    };
+    'task:workload_analyzed': TaskEventPayload;
+    'task:agent_overloaded': TaskEventPayload & {
+        data: {
+            agentId: AgentId;
+            currentTasks: number;
+            threshold: number;
+        };
+    };
+    'task:dependency_resolved': TaskEventPayload & {
+        data: {
+            task: ChannelTask;
+            resolvedDependency: string;
+        };
+    };
+    'task:blocking_cleared': TaskEventPayload & {
+        data: {
+            task: ChannelTask;
+            clearedBlocker: string;
+        };
+    };
+    'task:late_agent_joined': TaskEventPayload & {
+        data: {
+            task: ChannelTask;
+            joinedAgentId: AgentId;
+        };
+    };
+    'task:orchestration_config_updated': TaskEventPayload;
+}
+//# sourceMappingURL=TaskEvents.d.ts.map

package/dist/events/event-definitions/TaskEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TaskEvents.d.ts","sourceRoot":"","sources":["../../../src/events/event-definitions/TaskEvents.ts"],"names":[],"mappings":"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"}

package/dist/events/event-definitions/TaskEvents.js

@@ -0,0 +1,58 @@
+/**
+ * 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/
+ */
+/**
+ * Enhanced TaskEvents with comprehensive task management
+ */
+export const TaskEvents = {
+    // Legacy events (backward compatibility)
+    REQUEST: 'task:request',
+    RESPONSE: 'task:response',
+    // Task request events (from clients to server)
+    CREATE_REQUEST: 'task:create_request',
+    START_REQUEST: 'task:start_request',
+    COMPLETE_REQUEST: 'task:complete_request',
+    FAIL_REQUEST: 'task:fail_request',
+    CANCEL_REQUEST: 'task:cancel_request',
+    ASSIGN_REQUEST: 'task:assign_request',
+    UPDATE_REQUEST: 'task:update_request',
+    WORKLOAD_ANALYZE_REQUEST: 'task:workload_analyze_request',
+    // Core task lifecycle events (server responses/notifications)
+    CREATED: 'task:created',
+    ASSIGNED: 'task:assigned',
+    STARTED: 'task:started',
+    PROGRESS_UPDATED: 'task:progress_updated',
+    COMPLETED: 'task:completed',
+    FAILED: 'task:failed',
+    ERROR: 'task:error', // Task execution error
+    CANCELLED: 'task:cancelled',
+    REASSIGNED: 'task:reassigned',
+    // Task orchestration events
+    ASSIGNMENT_REQUESTED: 'task:assignment_requested',
+    ASSIGNMENT_ANALYZED: 'task:assignment_analyzed',
+    WORKLOAD_ANALYZED: 'task:workload_analyzed',
+    AGENT_OVERLOADED: 'task:agent_overloaded',
+    // Coordination events
+    DEPENDENCY_RESOLVED: 'task:dependency_resolved',
+    BLOCKING_CLEARED: 'task:blocking_cleared',
+    LATE_AGENT_JOINED: 'task:late_agent_joined',
+    // System events
+    ORCHESTRATION_CONFIG_UPDATED: 'task:orchestration_config_updated'
+};
+//# sourceMappingURL=TaskEvents.js.map

package/dist/events/event-definitions/TaskEvents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TaskEvents.js","sourceRoot":"","sources":["../../../src/events/event-definitions/TaskEvents.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAiGH;;GAEG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG;IACtB,yCAAyC;IACzC,OAAO,EAAE,cAAc;IACvB,QAAQ,EAAE,eAAe;IAEzB,+CAA+C;IAC/C,cAAc,EAAE,qBAAqB;IACrC,aAAa,EAAE,oBAAoB;IACnC,gBAAgB,EAAE,uBAAuB;IACzC,YAAY,EAAE,mBAAmB;IACjC,cAAc,EAAE,qBAAqB;IACrC,cAAc,EAAE,qBAAqB;IACrC,cAAc,EAAE,qBAAqB;IACrC,wBAAwB,EAAE,+BAA+B;IAEzD,8DAA8D;IAC9D,OAAO,EAAE,cAAc;IACvB,QAAQ,EAAE,eAAe;IACzB,OAAO,EAAE,cAAc;IACvB,gBAAgB,EAAE,uBAAuB;IACzC,SAAS,EAAE,gBAAgB;IAC3B,MAAM,EAAE,aAAa;IACrB,KAAK,EAAE,YAAY,EAAE,uBAAuB;IAC5C,SAAS,EAAE,gBAAgB;IAC3B,UAAU,EAAE,iBAAiB;IAE7B,4BAA4B;IAC5B,oBAAoB,EAAE,2BAA2B;IACjD,mBAAmB,EAAE,0BAA0B;IAC/C,iBAAiB,EAAE,wBAAwB;IAC3C,gBAAgB,EAAE,uBAAuB;IAEzC,sBAAsB;IACtB,mBAAmB,EAAE,0BAA0B;IAC/C,gBAAgB,EAAE,uBAAuB;IACzC,iBAAiB,EAAE,wBAAwB;IAE3C,gBAAgB;IAChB,4BAA4B,EAAE,mCAAmC;CAC3D,CAAC"}

package/dist/events/event-definitions/TensorFlowEvents.d.ts

@@ -0,0 +1,144 @@
+/**
+ * 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/
+ */
+/**
+ * TensorFlow Events
+ *
+ * Event definitions for the TensorFlow.js integration layer.
+ * Covers model lifecycle (registration, training, persistence),
+ * inference (prediction, fallback), and tensor memory monitoring.
+ */
+/**
+ * TensorFlow event names
+ */
+export declare const TensorFlowEvents: {
+    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";
+};
+export type TensorFlowEventName = typeof TensorFlowEvents[keyof typeof TensorFlowEvents];
+/**
+ * Model registered event data
+ */
+export interface ModelRegisteredEventData {
+    modelId: string;
+    type: string;
+    inputShape: number[];
+    outputShape: number[];
+}
+/**
+ * Model training started event data
+ */
+export interface ModelTrainingStartedEventData {
+    modelId: string;
+    trainingSamples: number;
+    epochs: number;
+}
+/**
+ * Model training completed event data
+ */
+export interface ModelTrainingCompletedEventData {
+    modelId: string;
+    loss: number;
+    valLoss?: number;
+    accuracy?: number;
+    durationMs: number;
+    samplesUsed: number;
+}
+/**
+ * Model training failed event data
+ */
+export interface ModelTrainingFailedEventData {
+    modelId: string;
+    error: string;
+    trainingSamples: number;
+}
+/**
+ * Model loaded from storage event data
+ */
+export interface ModelLoadedEventData {
+    modelId: string;
+    source: string;
+}
+/**
+ * Model saved to storage event data
+ */
+export interface ModelSavedEventData {
+    modelId: string;
+    destination: string;
+    sizeBytes?: number;
+}
+/**
+ * Inference completed event data
+ */
+export interface InferenceCompletedEventData {
+    modelId: string;
+    latencyMs: number;
+    source: 'model' | 'heuristic';
+}
+/**
+ * Inference fallback event data — emitted when ML model is unavailable
+ * and the heuristic fallback is used instead
+ */
+export interface InferenceFallbackEventData {
+    modelId: string;
+    reason: 'disabled' | 'untrained' | 'error';
+    error?: string;
+}
+/**
+ * Tensor memory warning event data — emitted when tensor memory exceeds threshold
+ */
+export interface MemoryWarningEventData {
+    numTensors: number;
+    numBytes: number;
+    maxBytes: number;
+    utilizationPercent: number;
+}
+/**
+ * Tensor memory stats event data — periodic snapshot of tf.memory()
+ */
+export interface MemoryStatsEventData {
+    numTensors: number;
+    numDataBuffers: number;
+    numBytes: number;
+    timestamp: number;
+}
+/**
+ * TensorFlow event payloads mapping
+ */
+export interface TensorFlowPayloads {
+    'tf:model_registered': ModelRegisteredEventData;
+    'tf:model_training_started': ModelTrainingStartedEventData;
+    'tf:model_training_completed': ModelTrainingCompletedEventData;
+    'tf:model_training_failed': ModelTrainingFailedEventData;
+    'tf:model_loaded': ModelLoadedEventData;
+    'tf:model_saved': ModelSavedEventData;
+    'tf:inference_completed': InferenceCompletedEventData;
+    'tf:inference_fallback': InferenceFallbackEventData;
+    'tf:memory_warning': MemoryWarningEventData;
+    'tf:memory_stats': MemoryStatsEventData;
+}
+//# sourceMappingURL=TensorFlowEvents.d.ts.map

package/dist/events/event-definitions/TensorFlowEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TensorFlowEvents.d.ts","sourceRoot":"","sources":["../../../src/events/event-definitions/TensorFlowEvents.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;;;GAMG;AAEH;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;CAgBnB,CAAC;AAEX,MAAM,MAAM,mBAAmB,GAAG,OAAO,gBAAgB,CAAC,MAAM,OAAO,gBAAgB,CAAC,CAAC;AAEzF;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,WAAW,EAAE,MAAM,EAAE,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,+BAA+B;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,4BAA4B;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,eAAe,EAAE,MAAM,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,2BAA2B;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,OAAO,GAAG,WAAW,CAAC;CACjC;AAED;;;GAGG;AACH,MAAM,WAAW,0BAA0B;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,UAAU,GAAG,WAAW,GAAG,OAAO,CAAC;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,kBAAkB,EAAE,MAAM,CAAC;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAC/B,qBAAqB,EAAE,wBAAwB,CAAC;IAChD,2BAA2B,EAAE,6BAA6B,CAAC;IAC3D,6BAA6B,EAAE,+BAA+B,CAAC;IAC/D,0BAA0B,EAAE,4BAA4B,CAAC;IACzD,iBAAiB,EAAE,oBAAoB,CAAC;IACxC,gBAAgB,EAAE,mBAAmB,CAAC;IACtC,wBAAwB,EAAE,2BAA2B,CAAC;IACtD,uBAAuB,EAAE,0BAA0B,CAAC;IACpD,mBAAmB,EAAE,sBAAsB,CAAC;IAC5C,iBAAiB,EAAE,oBAAoB,CAAC;CAC3C"}

package/dist/events/event-definitions/TensorFlowEvents.js

@@ -0,0 +1,45 @@
+/**
+ * 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/
+ */
+/**
+ * TensorFlow Events
+ *
+ * Event definitions for the TensorFlow.js integration layer.
+ * Covers model lifecycle (registration, training, persistence),
+ * inference (prediction, fallback), and tensor memory monitoring.
+ */
+/**
+ * TensorFlow event names
+ */
+export const TensorFlowEvents = {
+    // Model lifecycle events
+    MODEL_REGISTERED: 'tf:model_registered',
+    MODEL_TRAINING_STARTED: 'tf:model_training_started',
+    MODEL_TRAINING_COMPLETED: 'tf:model_training_completed',
+    MODEL_TRAINING_FAILED: 'tf:model_training_failed',
+    MODEL_LOADED: 'tf:model_loaded',
+    MODEL_SAVED: 'tf:model_saved',
+    // Inference events
+    INFERENCE_COMPLETED: 'tf:inference_completed',
+    INFERENCE_FALLBACK: 'tf:inference_fallback',
+    // Memory events
+    MEMORY_WARNING: 'tf:memory_warning',
+    MEMORY_STATS: 'tf:memory_stats',
+};
+//# sourceMappingURL=TensorFlowEvents.js.map

package/dist/events/event-definitions/TensorFlowEvents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TensorFlowEvents.js","sourceRoot":"","sources":["../../../src/events/event-definitions/TensorFlowEvents.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;;;GAMG;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC5B,yBAAyB;IACzB,gBAAgB,EAAE,qBAAqB;IACvC,sBAAsB,EAAE,2BAA2B;IACnD,wBAAwB,EAAE,6BAA6B;IACvD,qBAAqB,EAAE,0BAA0B;IACjD,YAAY,EAAE,iBAAiB;IAC/B,WAAW,EAAE,gBAAgB;IAE7B,mBAAmB;IACnB,mBAAmB,EAAE,wBAAwB;IAC7C,kBAAkB,EAAE,uBAAuB;IAE3C,gBAAgB;IAChB,cAAc,EAAE,mBAAmB;IACnC,YAAY,EAAE,iBAAiB;CACzB,CAAC"}

package/dist/events/event-definitions/UserInputEvents.d.ts

@@ -0,0 +1,180 @@
+/**
+ * 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/
+ */
+/**
+ * User Input Events for MXF Framework
+ *
+ * Event definitions for the user input tool system. Enables agents to prompt
+ * users for input during execution and receive responses via Socket.IO events.
+ *
+ * Flow:
+ * 1. Agent calls user_input tool → server emits REQUEST to channel
+ * 2. SDK/client renders prompt → user responds → client emits RESPONSE
+ * 3. Server routes RESPONSE to UserInputRequestManager → tool resolves
+ */
+import { AgentId } from '../../types/ChannelContext.js';
+/**
+ * Configuration for text input type
+ */
+export interface TextInputConfig {
+    multiline?: boolean;
+    placeholder?: string;
+    minLength?: number;
+    maxLength?: number;
+}
+/**
+ * A single option for select/multi_select input types
+ */
+export interface SelectOption {
+    value: string;
+    label: string;
+    description?: string;
+}
+/**
+ * Configuration for select input type (pick one)
+ */
+export interface SelectInputConfig {
+    options: SelectOption[];
+}
+/**
+ * Configuration for multi_select input type (pick multiple)
+ */
+export interface MultiSelectInputConfig {
+    options: SelectOption[];
+    minSelections?: number;
+    maxSelections?: number;
+}
+/**
+ * Configuration for confirm input type (yes/no)
+ */
+export interface ConfirmInputConfig {
+    confirmLabel?: string;
+    denyLabel?: string;
+}
+/**
+ * Union of all input configurations keyed by input type
+ */
+export type InputConfig = TextInputConfig | SelectInputConfig | MultiSelectInputConfig | ConfirmInputConfig;
+/**
+ * Supported input types for user prompts
+ */
+export type UserInputType = 'text' | 'select' | 'multi_select' | 'confirm';
+/**
+ * Urgency level for styling (ignored by terminal clients)
+ */
+export type UserInputUrgency = 'low' | 'normal' | 'high' | 'critical';
+/**
+ * Theme for styling (ignored by terminal clients)
+ */
+export type UserInputTheme = 'default' | 'warning' | 'info' | 'success' | 'error';
+/**
+ * Full user input request definition sent from server to clients
+ */
+export interface UserInputRequestData {
+    /** Unique identifier for this request */
+    requestId: string;
+    /** Agent that initiated the request */
+    agentId: AgentId;
+    /** Channel context */
+    channelId: string;
+    /** Short heading for the prompt */
+    title: string;
+    /** Longer explanation (optional) */
+    description?: string;
+    /** Input type */
+    inputType: UserInputType;
+    /** Type-specific configuration */
+    inputConfig: InputConfig;
+    /** Optional timeout in milliseconds */
+    timeoutMs?: number;
+    /** Urgency level for visual emphasis (optional, ignored by terminal clients) */
+    urgency?: UserInputUrgency;
+    /** Icon identifier (optional, ignored by terminal clients) */
+    icon?: string;
+    /** Visual theme (optional, ignored by terminal clients) */
+    theme?: UserInputTheme;
+    /** Timestamp when request was created */
+    timestamp: number;
+}
+/**
+ * Response value types matching input types
+ */
+export type UserInputResponseValue = string | string[] | boolean;
+/**
+ * Response data sent from client back to server
+ */
+export interface UserInputResponseData {
+    /** Request ID this response corresponds to */
+    requestId: string;
+    /** The user's answer */
+    value: UserInputResponseValue;
+    /** Agent ID of the responder (for multi-client scenarios) */
+    respondedBy?: string;
+    /** Timestamp when user responded */
+    timestamp: number;
+}
+/**
+ * Cancellation data sent from server to clients
+ */
+export interface UserInputCancelledData {
+    /** Request ID that was cancelled */
+    requestId: string;
+    /** Reason for cancellation */
+    reason: string;
+    /** Timestamp of cancellation */
+    timestamp: number;
+}
+/**
+ * Timeout data sent from server to clients
+ */
+export interface UserInputTimeoutData {
+    /** Request ID that timed out */
+    requestId: string;
+    /** Configured timeout in milliseconds */
+    timeoutMs: number;
+    /** Timestamp of timeout */
+    timestamp: number;
+}
+/**
+ * Status of a user input request
+ */
+export type UserInputRequestStatus = 'pending' | 'responded' | 'cancelled' | 'timeout';
+/**
+ * User Input event names for Socket.IO communication
+ */
+export declare const UserInputEvents: {
+    /** Server → Client: prompt the user for input */
+    readonly REQUEST: "user_input:request";
+    /** Client → Server: user responded to a prompt */
+    readonly RESPONSE: "user_input:response";
+    /** Server → Client: request was cancelled (agent or server cancelled) */
+    readonly CANCELLED: "user_input:cancelled";
+    /** Server → Client: request timed out */
+    readonly TIMEOUT: "user_input:timeout";
+};
+/**
+ * Payload types for all user input events
+ */
+export interface UserInputPayloads {
+    'user_input:request': UserInputRequestData;
+    'user_input:response': UserInputResponseData;
+    'user_input:cancelled': UserInputCancelledData;
+    'user_input:timeout': UserInputTimeoutData;
+}
+//# sourceMappingURL=UserInputEvents.d.ts.map