@objectstack/spec 0.2.0 → 0.3.1

package/dist/ai/predictive.zod.d.ts.map

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

package/dist/ai/predictive.zod.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelDriftSchema = exports.PredictionResultSchema = exports.PredictionRequestSchema = exports.PredictiveModelSchema = exports.EvaluationMetricsSchema = exports.TrainingConfigSchema = exports.HyperparametersSchema = exports.ModelFeatureSchema = exports.PredictiveModelTypeSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Predictive Analytics Protocol
+ *
+ * Defines predictive models and machine learning configurations for
+ * data-driven decision making and forecasting in ObjectStack applications.
+ *
+ * Use Cases:
+ * - Lead scoring and conversion prediction
+ * - Customer churn prediction
+ * - Sales forecasting
+ * - Demand forecasting
+ * - Anomaly detection in operational data
+ * - Customer segmentation and clustering
+ * - Price optimization
+ * - Recommendation systems
+ */
+/**
+ * Predictive Model Types
+ */
+exports.PredictiveModelTypeSchema = zod_1.z.enum([
+    'classification', // Binary or multi-class classification
+    'regression', // Numerical prediction
+    'clustering', // Unsupervised grouping
+    'forecasting', // Time-series prediction
+    'anomaly_detection', // Outlier detection
+    'recommendation', // Item or action recommendation
+    'ranking', // Ordering items by relevance
+]);
+/**
+ * Model Feature Definition
+ * Describes an input feature for a predictive model
+ */
+exports.ModelFeatureSchema = zod_1.z.object({
+    /** Feature Identity */
+    name: zod_1.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe('Feature name (snake_case)'),
+    label: zod_1.z.string().optional().describe('Human-readable label'),
+    /** Data Source */
+    field: zod_1.z.string().describe('Source field name'),
+    object: zod_1.z.string().optional().describe('Source object (if different from target)'),
+    /** Feature Type */
+    dataType: zod_1.z.enum(['numeric', 'categorical', 'text', 'datetime', 'boolean']).describe('Feature data type'),
+    /** Feature Engineering */
+    transformation: zod_1.z.enum([
+        'none',
+        'normalize', // Normalize to 0-1 range
+        'standardize', // Z-score standardization
+        'one_hot_encode', // One-hot encoding for categorical
+        'label_encode', // Label encoding for categorical
+        'log_transform', // Logarithmic transformation
+        'binning', // Discretize continuous values
+        'embedding', // Text/categorical embedding
+    ]).optional().default('none'),
+    /** Configuration */
+    required: zod_1.z.boolean().optional().default(true),
+    defaultValue: zod_1.z.any().optional(),
+    /** Metadata */
+    description: zod_1.z.string().optional(),
+    importance: zod_1.z.number().optional().describe('Feature importance score (0-1)'),
+});
+/**
+ * Model Hyperparameters
+ * Configuration specific to model algorithms
+ */
+exports.HyperparametersSchema = zod_1.z.object({
+    /** General Parameters */
+    learningRate: zod_1.z.number().optional().describe('Learning rate for training'),
+    epochs: zod_1.z.number().int().optional().describe('Number of training epochs'),
+    batchSize: zod_1.z.number().int().optional().describe('Training batch size'),
+    /** Tree-based Models (Random Forest, XGBoost, etc.) */
+    maxDepth: zod_1.z.number().int().optional().describe('Maximum tree depth'),
+    numTrees: zod_1.z.number().int().optional().describe('Number of trees in ensemble'),
+    minSamplesSplit: zod_1.z.number().int().optional().describe('Minimum samples to split node'),
+    minSamplesLeaf: zod_1.z.number().int().optional().describe('Minimum samples in leaf node'),
+    /** Neural Networks */
+    hiddenLayers: zod_1.z.array(zod_1.z.number().int()).optional().describe('Hidden layer sizes'),
+    activation: zod_1.z.string().optional().describe('Activation function'),
+    dropout: zod_1.z.number().optional().describe('Dropout rate'),
+    /** Regularization */
+    l1Regularization: zod_1.z.number().optional().describe('L1 regularization strength'),
+    l2Regularization: zod_1.z.number().optional().describe('L2 regularization strength'),
+    /** Clustering */
+    numClusters: zod_1.z.number().int().optional().describe('Number of clusters (k-means, etc.)'),
+    /** Time Series */
+    seasonalPeriod: zod_1.z.number().int().optional().describe('Seasonal period for time series'),
+    forecastHorizon: zod_1.z.number().int().optional().describe('Number of periods to forecast'),
+    /** Additional custom parameters */
+    custom: zod_1.z.record(zod_1.z.any()).optional().describe('Algorithm-specific parameters'),
+});
+/**
+ * Model Training Configuration
+ */
+exports.TrainingConfigSchema = zod_1.z.object({
+    /** Data Split */
+    trainingDataRatio: zod_1.z.number().min(0).max(1).optional().default(0.8).describe('Proportion of data for training'),
+    validationDataRatio: zod_1.z.number().min(0).max(1).optional().default(0.1).describe('Proportion for validation'),
+    testDataRatio: zod_1.z.number().min(0).max(1).optional().default(0.1).describe('Proportion for testing'),
+    /** Data Filtering */
+    dataFilter: zod_1.z.string().optional().describe('Formula to filter training data'),
+    minRecords: zod_1.z.number().int().optional().default(100).describe('Minimum records required'),
+    maxRecords: zod_1.z.number().int().optional().describe('Maximum records to use'),
+    /** Training Strategy */
+    strategy: zod_1.z.enum(['full', 'incremental', 'online', 'transfer_learning']).optional().default('full'),
+    crossValidation: zod_1.z.boolean().optional().default(true),
+    folds: zod_1.z.number().int().min(2).max(10).optional().default(5).describe('Cross-validation folds'),
+    /** Early Stopping */
+    earlyStoppingEnabled: zod_1.z.boolean().optional().default(true),
+    earlyStoppingPatience: zod_1.z.number().int().optional().default(10).describe('Epochs without improvement before stopping'),
+    /** Resource Limits */
+    maxTrainingTime: zod_1.z.number().optional().describe('Maximum training time in seconds'),
+    gpuEnabled: zod_1.z.boolean().optional().default(false),
+    /** Reproducibility */
+    randomSeed: zod_1.z.number().int().optional().describe('Random seed for reproducibility'),
+});
+/**
+ * Model Evaluation Metrics
+ */
+exports.EvaluationMetricsSchema = zod_1.z.object({
+    /** Classification Metrics */
+    accuracy: zod_1.z.number().optional(),
+    precision: zod_1.z.number().optional(),
+    recall: zod_1.z.number().optional(),
+    f1Score: zod_1.z.number().optional(),
+    auc: zod_1.z.number().optional().describe('Area Under ROC Curve'),
+    /** Regression Metrics */
+    mse: zod_1.z.number().optional().describe('Mean Squared Error'),
+    rmse: zod_1.z.number().optional().describe('Root Mean Squared Error'),
+    mae: zod_1.z.number().optional().describe('Mean Absolute Error'),
+    r2Score: zod_1.z.number().optional().describe('R-squared score'),
+    /** Clustering Metrics */
+    silhouetteScore: zod_1.z.number().optional(),
+    daviesBouldinIndex: zod_1.z.number().optional(),
+    /** Time Series Metrics */
+    mape: zod_1.z.number().optional().describe('Mean Absolute Percentage Error'),
+    smape: zod_1.z.number().optional().describe('Symmetric MAPE'),
+    /** Additional Metrics */
+    custom: zod_1.z.record(zod_1.z.number()).optional(),
+});
+/**
+ * Predictive Model Schema
+ * Complete definition of a predictive model
+ */
+exports.PredictiveModelSchema = zod_1.z.object({
+    /** Identity */
+    name: zod_1.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe('Model unique identifier (snake_case)'),
+    label: zod_1.z.string().describe('Model display name'),
+    description: zod_1.z.string().optional(),
+    /** Model Type */
+    type: exports.PredictiveModelTypeSchema,
+    algorithm: zod_1.z.string().optional().describe('Specific algorithm (e.g., "random_forest", "xgboost", "lstm")'),
+    /** Target Object & Field */
+    objectName: zod_1.z.string().describe('Target object for predictions'),
+    target: zod_1.z.string().describe('Target field to predict'),
+    targetType: zod_1.z.enum(['numeric', 'categorical', 'binary']).optional().describe('Target field type'),
+    /** Features */
+    features: zod_1.z.array(exports.ModelFeatureSchema).describe('Input features for the model'),
+    /** Hyperparameters */
+    hyperparameters: exports.HyperparametersSchema.optional(),
+    /** Training Configuration */
+    training: exports.TrainingConfigSchema.optional(),
+    /** Model Performance */
+    metrics: exports.EvaluationMetricsSchema.optional().describe('Evaluation metrics from last training'),
+    /** Deployment */
+    deploymentStatus: zod_1.z.enum(['draft', 'training', 'trained', 'deployed', 'deprecated']).optional().default('draft'),
+    version: zod_1.z.string().optional().default('1.0.0'),
+    /** Prediction Configuration */
+    predictionField: zod_1.z.string().optional().describe('Field to store predictions'),
+    confidenceField: zod_1.z.string().optional().describe('Field to store confidence scores'),
+    updateTrigger: zod_1.z.enum(['on_create', 'on_update', 'manual', 'scheduled']).optional().default('on_create'),
+    /** Retraining */
+    autoRetrain: zod_1.z.boolean().optional().default(false),
+    retrainSchedule: zod_1.z.string().optional().describe('Cron expression for auto-retraining'),
+    retrainThreshold: zod_1.z.number().optional().describe('Performance threshold to trigger retraining'),
+    /** Explainability */
+    enableExplainability: zod_1.z.boolean().optional().default(false).describe('Generate feature importance & explanations'),
+    /** Monitoring */
+    enableMonitoring: zod_1.z.boolean().optional().default(true),
+    alertOnDrift: zod_1.z.boolean().optional().default(true).describe('Alert when model drift is detected'),
+    /** Access Control */
+    active: zod_1.z.boolean().optional().default(true),
+    owner: zod_1.z.string().optional().describe('User ID of model owner'),
+    permissions: zod_1.z.array(zod_1.z.string()).optional().describe('User/group IDs with access'),
+    /** Metadata */
+    tags: zod_1.z.array(zod_1.z.string()).optional(),
+    category: zod_1.z.string().optional().describe('Model category (e.g., "sales", "marketing", "operations")'),
+    lastTrainedAt: zod_1.z.string().optional().describe('ISO timestamp'),
+    createdAt: zod_1.z.string().optional().describe('ISO timestamp'),
+    updatedAt: zod_1.z.string().optional().describe('ISO timestamp'),
+});
+/**
+ * Prediction Request
+ * Request for making predictions using a trained model
+ */
+exports.PredictionRequestSchema = zod_1.z.object({
+    modelName: zod_1.z.string().describe('Model to use for prediction'),
+    recordIds: zod_1.z.array(zod_1.z.string()).optional().describe('Specific records to predict (if not provided, uses all)'),
+    inputData: zod_1.z.record(zod_1.z.any()).optional().describe('Direct input data (alternative to recordIds)'),
+    returnConfidence: zod_1.z.boolean().optional().default(true),
+    returnExplanation: zod_1.z.boolean().optional().default(false),
+});
+/**
+ * Prediction Result
+ * Result of a prediction request
+ */
+exports.PredictionResultSchema = zod_1.z.object({
+    modelName: zod_1.z.string(),
+    modelVersion: zod_1.z.string(),
+    recordId: zod_1.z.string().optional(),
+    prediction: zod_1.z.any().describe('The predicted value'),
+    confidence: zod_1.z.number().optional().describe('Confidence score (0-1)'),
+    probabilities: zod_1.z.record(zod_1.z.number()).optional().describe('Class probabilities (for classification)'),
+    explanation: zod_1.z.object({
+        topFeatures: zod_1.z.array(zod_1.z.object({
+            feature: zod_1.z.string(),
+            importance: zod_1.z.number(),
+            value: zod_1.z.any(),
+        })).optional(),
+        reasoning: zod_1.z.string().optional(),
+    }).optional(),
+    metadata: zod_1.z.object({
+        executionTime: zod_1.z.number().optional().describe('Execution time in milliseconds'),
+        timestamp: zod_1.z.string().optional().describe('ISO timestamp'),
+    }).optional(),
+});
+/**
+ * Model Drift Detection
+ * Monitoring for model performance degradation
+ */
+exports.ModelDriftSchema = zod_1.z.object({
+    modelName: zod_1.z.string(),
+    driftType: zod_1.z.enum(['feature_drift', 'prediction_drift', 'performance_drift']),
+    severity: zod_1.z.enum(['low', 'medium', 'high', 'critical']),
+    detectedAt: zod_1.z.string().describe('ISO timestamp'),
+    metrics: zod_1.z.object({
+        driftScore: zod_1.z.number().describe('Drift magnitude (0-1)'),
+        affectedFeatures: zod_1.z.array(zod_1.z.string()).optional(),
+        performanceChange: zod_1.z.number().optional().describe('Change in performance metric'),
+    }),
+    recommendation: zod_1.z.string().optional(),
+    autoRetrainTriggered: zod_1.z.boolean().optional().default(false),
+});