@mxf-dev/core 1.0.0

package/dist/schemas/MessageSchemas.js

@@ -0,0 +1,282 @@
+/**
+ * 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/
+ */
+/**
+ * MessageSchemas.ts
+ *
+ * Defines standardized message schemas used throughout the Model Exchange Framework.
+ * These schemas provide a consistent structure for all messages exchanged between
+ * components, whether they're channel messages, agent messages, or binary data.
+ */
+/**
+ * Data format options for message content
+ */
+import { v4 as uuidv4 } from 'uuid';
+export var ContentFormat;
+(function (ContentFormat) {
+    ContentFormat["JSON"] = "json";
+    ContentFormat["BINARY"] = "binary";
+    ContentFormat["BASE64"] = "base64";
+    ContentFormat["TEXT"] = "text";
+})(ContentFormat || (ContentFormat = {}));
+/**
+ * Asserts that the provided value is a non-empty string.
+ * This function provides both runtime validation and TypeScript type narrowing.
+ *
+ * @param value - The value to check
+ * @param paramName - The name of the parameter (for error message)
+ * @throws Error if validation fails
+ */
+const assertNonEmptyString = (value, paramName) => {
+    if (!value || typeof value !== 'string' || value.trim() === '') {
+        throw new Error(`${paramName} is required and must be a non-empty string`);
+    }
+};
+/**
+ * Asserts that a value is a valid content format.
+ *
+ * @param value - The value to check
+ * @param paramName - The name of the parameter (for error message)
+ * @throws Error if validation fails
+ */
+const assertValidContentFormat = (value, paramName) => {
+    if (value !== ContentFormat.JSON &&
+        value !== ContentFormat.BINARY &&
+        value !== ContentFormat.BASE64 &&
+        value !== ContentFormat.TEXT) {
+        throw new Error(`${paramName} must be a valid ContentFormat (json, binary, base64, or text)`);
+    }
+};
+/**
+ * Helper function to create a standard message metadata object
+ * @param overrides - Optional fields to override defaults
+ * @returns A MessageMetadata object with defaults and any overrides
+ */
+export const createMessageMetadata = (overrides = {}) => {
+    // Generate a random message ID if not provided
+    const randomId = () => {
+        return uuidv4() +
+            uuidv4();
+    };
+    return {
+        messageId: overrides.messageId || randomId(),
+        timestamp: overrides.timestamp || Date.now(),
+        correlationId: overrides.correlationId,
+        priority: overrides.priority,
+        ttl: overrides.ttl
+    };
+};
+/**
+ * Helper function to create a standard channel message
+ * @param channelId - ID of the channel
+ * @param senderId - ID of the sending agent/entity
+ * @param content - Message content (will be wrapped in ContentWrapper)
+ * @param options - Additional options for the message
+ * @returns A fully formed ChannelMessage
+ */
+export const createChannelMessage = (channelId, senderId, content, options = {}) => {
+    // Validate critical parameters
+    assertNonEmptyString(channelId, 'channelId');
+    assertNonEmptyString(senderId, 'senderId');
+    // Ensure content is provided
+    if (content === undefined || content === null) {
+        throw new Error('Message content cannot be null or undefined');
+    }
+    // Determine content format - if explicit format provided, verify it's valid
+    let format;
+    if (options.format) {
+        assertValidContentFormat(options.format, 'format');
+        format = options.format;
+    }
+    else {
+        // Auto-detect format based on content type
+        format = typeof content === 'string' ? ContentFormat.TEXT : ContentFormat.JSON;
+    }
+    // Build the channel message
+    const message = {
+        toolType: 'channelMessage',
+        senderId,
+        receiverId: options.receiverId,
+        metadata: createMessageMetadata(options.metadata),
+        security: options.encrypted ? { encrypted: true } : undefined,
+        content: {
+            format,
+            data: content,
+        },
+        context: {
+            channelId,
+            ...(options.context || {}),
+        }
+    };
+    return message;
+};
+/**
+ * Helper function to create a standard agent-to-agent message
+ * @param senderId - ID of the sending agent
+ * @param receiverId - ID of the receiving agent
+ * @param content - Message content (will be wrapped in ContentWrapper)
+ * @param options - Additional options for the message
+ * @returns A fully formed AgentMessage
+ */
+export const createAgentMessage = (senderId, receiverId, content, options = {}) => {
+    // Validate critical parameters
+    assertNonEmptyString(senderId, 'senderId');
+    assertNonEmptyString(receiverId, 'receiverId');
+    // Ensure content is provided
+    if (content === undefined || content === null) {
+        throw new Error('Message content cannot be null or undefined');
+    }
+    // Determine content format
+    let format;
+    if (options.format) {
+        assertValidContentFormat(options.format, 'format');
+        format = options.format;
+    }
+    else {
+        // Auto-detect format based on content type
+        format = typeof content === 'string' ? ContentFormat.TEXT : ContentFormat.JSON;
+    }
+    // Build the agent message
+    const message = {
+        toolType: 'agentMessage',
+        senderId,
+        receiverId,
+        metadata: createMessageMetadata(options.metadata),
+        security: options.encrypted ? { encrypted: true } : undefined,
+        content: {
+            format,
+            data: content,
+        },
+        context: options.context
+    };
+    return message;
+};
+/**
+ * Helper function to convert an existing message to the standard schema
+ * @param message - Message content in any format
+ * @param senderId - ID of the sending agent/entity
+ * @param options - Additional options for standardization
+ * @returns A standardized message
+ */
+export const standardizeMessage = (message, senderId, options = {}) => {
+    // Validate critical parameters
+    assertNonEmptyString(senderId, 'senderId');
+    // Ensure message is provided
+    if (message === undefined || message === null) {
+        throw new Error('Message content cannot be null or undefined');
+    }
+    // Determine the tool type based on the message category and options
+    const toolType = options.toolType || (options.channelId ? 'channelMessage' : 'agentMessage');
+    // Content format defaults based on message type
+    let format;
+    if (options.format) {
+        assertValidContentFormat(options.format, 'format');
+        format = options.format;
+    }
+    else {
+        // Auto-detect format based on content type
+        format = Buffer.isBuffer(message)
+            ? ContentFormat.BINARY
+            : typeof message === 'string'
+                ? ContentFormat.TEXT
+                : ContentFormat.JSON;
+    }
+    // Build a standardized message
+    const standardMessage = {
+        toolType,
+        senderId,
+        receiverId: options.receiverId,
+        metadata: createMessageMetadata(),
+        content: {
+            format,
+            data: message,
+            compression: false
+        },
+        context: {}
+    };
+    // Channel messages must include channelId in context and fromAgentId
+    if (toolType === 'channelMessage') {
+        if (!options.channelId) {
+            throw new Error('Channel message requires channelId');
+        }
+        assertNonEmptyString(options.channelId, 'channelId');
+        standardMessage.context = {
+            channelId: options.channelId
+        };
+        // Ensure fromAgentId is explicitly set for channel messages
+        standardMessage.fromAgentId = senderId;
+    }
+    return standardMessage;
+};
+/**
+ * Helper function to determine the content format based on the content type
+ * @param content - Content to determine format for
+ * @returns The appropriate ContentFormat enum value
+ */
+export const determineContentFormat = (content) => {
+    if (Buffer.isBuffer(content)) {
+        return ContentFormat.BINARY;
+    }
+    else if (typeof content === 'string') {
+        // Try to parse as JSON, if it fails, treat as text
+        try {
+            JSON.parse(content);
+            return ContentFormat.JSON;
+        }
+        catch (e) {
+            return ContentFormat.TEXT;
+        }
+    }
+    else if (typeof content === 'object') {
+        return ContentFormat.JSON;
+    }
+    else {
+        // Default to TEXT for anything else
+        return ContentFormat.TEXT;
+    }
+};
+/**
+ * Helper function to create a content wrapper
+ * @param content - Content to be wrapped
+ * @returns A ContentWrapper
+ */
+export const createContentWrapper = (content) => ({
+    format: determineContentFormat(content),
+    data: content
+});
+/**
+ * Helper function to wrap binary data in a JSON-compatible format
+ * @param content - Binary content as Buffer or string
+ * @param format - Explicitly specify the format (will auto-detect if not provided)
+ * @returns A ContentWrapper with properly formatted binary data
+ */
+export const wrapBinaryContent = (content, format) => {
+    // Default to binary for Buffer, base64 for string
+    const contentFormat = format || (Buffer.isBuffer(content) ? ContentFormat.BINARY : ContentFormat.BASE64);
+    // If content is a Buffer and format is base64, convert to base64 string
+    const formattedContent = Buffer.isBuffer(content) && contentFormat === ContentFormat.BASE64
+        ? content.toString('base64')
+        : content;
+    return {
+        format: contentFormat,
+        data: formattedContent,
+        compression: false
+    };
+};
+//# sourceMappingURL=MessageSchemas.js.map

package/dist/schemas/MessageSchemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageSchemas.js","sourceRoot":"","sources":["../../src/schemas/MessageSchemas.ts"],"names":[],"mappings":"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"}

package/dist/schemas/MxpProtocolSchemas.d.ts

@@ -0,0 +1,340 @@
+/**
+ * Copyright 2024 Brad Anderson
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @author Brad Anderson <BradA1878@pm.me>
+ * @repository https://github.com/mxf-dev/mxf
+ * @documentation https://mxf-dev.github.io/mxf/
+ */
+import { z } from 'zod';
+/**
+ * MXP Protocol Version
+ */
+export declare const MXP_VERSION: "2.0";
+/**
+ * Supported MXP message types
+ */
+export declare enum MxpMessageType {
+    OPERATION = "operation",// Structured operations (calculations, queries, etc.)
+    REASONING = "reasoning",// Complex reasoning that still needs natural language
+    COORDINATION = "coordination",// Agent coordination messages
+    TASK = "task",// Task assignments and updates
+    RESPONSE = "response"
+}
+/**
+ * Encryption algorithms supported by MXP
+ */
+export declare enum MxpEncryptionAlgorithm {
+    AES_256_GCM = "aes-256-gcm",
+    NONE = "none"
+}
+/**
+ * Common MXP operations
+ */
+export declare enum MxpOperation {
+    CALC_SUM = "calc.sum",
+    CALC_AVERAGE = "calc.average",
+    CALC_COMPARE = "calc.compare",
+    DATA_FETCH = "data.fetch",
+    DATA_STORE = "data.store",
+    DATA_QUERY = "data.query",
+    TOOL_EXECUTE = "tool.execute",
+    TOOL_CHAIN = "tool.chain",
+    COORD_SYNC = "coord.sync",
+    COORD_DELEGATE = "coord.delegate",
+    COORD_STATUS = "coord.status",
+    COLLAB_INIT = "collab.init",
+    COLLAB_PROPOSE = "collab.propose",
+    COLLAB_ACCEPT = "collab.accept",
+    COLLAB_COUNTER = "collab.counter",
+    COLLAB_COMPLETE = "collab.complete",
+    TASK_DELEGATE = "task.delegate",
+    TASK_PROGRESS = "task.progress",
+    TASK_COMPLETE = "task.complete",
+    TASK_REQUEST = "task.request",
+    STATE_UPDATE = "state.update",
+    STATE_REFERENCE = "state.reference",
+    STATE_SYNC = "state.sync",
+    STATE_QUERY = "state.query",
+    DECISION_MADE = "decision.made",
+    DECISION_REQUEST = "decision.request",
+    CUSTOM = "custom"
+}
+/**
+ * MXP Payload Schema - The actual message content
+ */
+export declare const MxpPayloadSchema: z.ZodObject<{
+    op: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    context: z.ZodOptional<z.ZodAny>;
+    reasoning: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        priority: z.ZodDefault<z.ZodNumber>;
+        ttl: z.ZodOptional<z.ZodNumber>;
+        correlationId: z.ZodOptional<z.ZodString>;
+        requestId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        priority: number;
+        correlationId?: string | undefined;
+        ttl?: number | undefined;
+        requestId?: string | undefined;
+    }, {
+        correlationId?: string | undefined;
+        priority?: number | undefined;
+        ttl?: number | undefined;
+        requestId?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    op: string;
+    context?: any;
+    reasoning?: string | undefined;
+    metadata?: {
+        priority: number;
+        correlationId?: string | undefined;
+        ttl?: number | undefined;
+        requestId?: string | undefined;
+    } | undefined;
+    args?: any[] | undefined;
+}, {
+    op: string;
+    context?: any;
+    reasoning?: string | undefined;
+    metadata?: {
+        correlationId?: string | undefined;
+        priority?: number | undefined;
+        ttl?: number | undefined;
+        requestId?: string | undefined;
+    } | undefined;
+    args?: any[] | undefined;
+}>;
+export type MxpPayload = z.infer<typeof MxpPayloadSchema>;
+/**
+ * Encrypted payload wrapper
+ */
+export declare const EncryptedPayloadSchema: z.ZodObject<{
+    algorithm: z.ZodNativeEnum<typeof MxpEncryptionAlgorithm>;
+    data: z.ZodString;
+    iv: z.ZodString;
+    authTag: z.ZodString;
+    keyId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    data: string;
+    algorithm: MxpEncryptionAlgorithm;
+    iv: string;
+    authTag: string;
+    keyId?: string | undefined;
+}, {
+    data: string;
+    algorithm: MxpEncryptionAlgorithm;
+    iv: string;
+    authTag: string;
+    keyId?: string | undefined;
+}>;
+export type EncryptedPayload = z.infer<typeof EncryptedPayloadSchema>;
+/**
+ * Main MXP Message Schema
+ */
+export declare const MxpMessageSchema: z.ZodObject<{
+    version: z.ZodLiteral<"2.0">;
+    type: z.ZodNativeEnum<typeof MxpMessageType>;
+    encrypted: z.ZodBoolean;
+    payload: z.ZodUnion<[z.ZodObject<{
+        op: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+        context: z.ZodOptional<z.ZodAny>;
+        reasoning: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodObject<{
+            priority: z.ZodDefault<z.ZodNumber>;
+            ttl: z.ZodOptional<z.ZodNumber>;
+            correlationId: z.ZodOptional<z.ZodString>;
+            requestId: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            priority: number;
+            correlationId?: string | undefined;
+            ttl?: number | undefined;
+            requestId?: string | undefined;
+        }, {
+            correlationId?: string | undefined;
+            priority?: number | undefined;
+            ttl?: number | undefined;
+            requestId?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        op: string;
+        context?: any;
+        reasoning?: string | undefined;
+        metadata?: {
+            priority: number;
+            correlationId?: string | undefined;
+            ttl?: number | undefined;
+            requestId?: string | undefined;
+        } | undefined;
+        args?: any[] | undefined;
+    }, {
+        op: string;
+        context?: any;
+        reasoning?: string | undefined;
+        metadata?: {
+            correlationId?: string | undefined;
+            priority?: number | undefined;
+            ttl?: number | undefined;
+            requestId?: string | undefined;
+        } | undefined;
+        args?: any[] | undefined;
+    }>, z.ZodObject<{
+        algorithm: z.ZodNativeEnum<typeof MxpEncryptionAlgorithm>;
+        data: z.ZodString;
+        iv: z.ZodString;
+        authTag: z.ZodString;
+        keyId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        data: string;
+        algorithm: MxpEncryptionAlgorithm;
+        iv: string;
+        authTag: string;
+        keyId?: string | undefined;
+    }, {
+        data: string;
+        algorithm: MxpEncryptionAlgorithm;
+        iv: string;
+        authTag: string;
+        keyId?: string | undefined;
+    }>]>;
+    messageId: z.ZodString;
+    timestamp: z.ZodNumber;
+    senderId: z.ZodString;
+    receiverId: z.ZodOptional<z.ZodString>;
+    channelId: z.ZodOptional<z.ZodString>;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    fallbackFormat: z.ZodOptional<z.ZodEnum<["natural-language", "json"]>>;
+}, "strip", z.ZodTypeAny, {
+    messageId: string;
+    timestamp: number;
+    senderId: string;
+    encrypted: boolean;
+    type: MxpMessageType;
+    version: "2.0";
+    payload: {
+        op: string;
+        context?: any;
+        reasoning?: string | undefined;
+        metadata?: {
+            priority: number;
+            correlationId?: string | undefined;
+            ttl?: number | undefined;
+            requestId?: string | undefined;
+        } | undefined;
+        args?: any[] | undefined;
+    } | {
+        data: string;
+        algorithm: MxpEncryptionAlgorithm;
+        iv: string;
+        authTag: string;
+        keyId?: string | undefined;
+    };
+    channelId?: string | undefined;
+    receiverId?: string | undefined;
+    capabilities?: string[] | undefined;
+    fallbackFormat?: "json" | "natural-language" | undefined;
+}, {
+    messageId: string;
+    timestamp: number;
+    senderId: string;
+    encrypted: boolean;
+    type: MxpMessageType;
+    version: "2.0";
+    payload: {
+        op: string;
+        context?: any;
+        reasoning?: string | undefined;
+        metadata?: {
+            correlationId?: string | undefined;
+            priority?: number | undefined;
+            ttl?: number | undefined;
+            requestId?: string | undefined;
+        } | undefined;
+        args?: any[] | undefined;
+    } | {
+        data: string;
+        algorithm: MxpEncryptionAlgorithm;
+        iv: string;
+        authTag: string;
+        keyId?: string | undefined;
+    };
+    channelId?: string | undefined;
+    receiverId?: string | undefined;
+    capabilities?: string[] | undefined;
+    fallbackFormat?: "json" | "natural-language" | undefined;
+}>;
+export type MxpMessage = z.infer<typeof MxpMessageSchema>;
+/**
+ * MXP Capability flags for protocol negotiation
+ */
+export declare enum MxpCapability {
+    ENCRYPTION = "encryption",
+    COMPRESSION = "compression",
+    BATCH_OPERATIONS = "batch-ops",
+    CUSTOM_OPERATIONS = "custom-ops",
+    NATURAL_LANGUAGE_FALLBACK = "nl-fallback"
+}
+/**
+ * Helper to create an MXP message
+ */
+export declare function createMxpMessage(type: MxpMessageType, senderId: string, payload: MxpPayload | EncryptedPayload, options?: {
+    receiverId?: string;
+    channelId?: string;
+    encrypted?: boolean;
+    messageId?: string;
+    capabilities?: MxpCapability[];
+}): MxpMessage;
+/**
+ * Type guard to check if a message is MXP format
+ */
+export declare function isMxpMessage(message: any): message is MxpMessage;
+/**
+ * Type guard to check if payload is encrypted
+ */
+export declare function isEncryptedPayload(payload: any): payload is EncryptedPayload;
+/**
+ * Convert natural language to MXP operation (basic example)
+ */
+export declare function detectOperation(naturalLanguage: string): {
+    op: string;
+    confidence: number;
+} | null;
+/**
+ * Example MXP message creators for common operations
+ */
+export declare const MxpMessageCreators: {
+    /**
+     * Create a calculation operation message
+     */
+    calculation(senderId: string, operation: "sum" | "average" | "compare", args: any[], options?: {
+        receiverId?: string;
+        channelId?: string;
+    }): MxpMessage;
+    /**
+     * Create a tool execution message
+     */
+    toolExecute(senderId: string, toolName: string, toolArgs: any, options?: {
+        receiverId?: string;
+        channelId?: string;
+        reasoning?: string;
+    }): MxpMessage;
+    /**
+     * Create a coordination sync message
+     */
+    coordinationSync(senderId: string, channelId: string, status: any, context?: any): MxpMessage;
+};
+//# sourceMappingURL=MxpProtocolSchemas.d.ts.map

package/dist/schemas/MxpProtocolSchemas.d.ts.map

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