@objectstack/spec 0.3.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),
+});

package/dist/ai/rag-pipeline.zod.d.ts

@@ -21,21 +21,21 @@ export declare const EmbeddingModelSchema: z.ZodObject<{
     endpoint: z.ZodOptional<z.ZodString>;
     apiKey: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    batchSize: number;
     provider: "custom" | "openai" | "azure_openai" | "local" | "cohere" | "huggingface";
+    batchSize: number;
     model: string;
     dimensions: number;
-    maxTokens?: number | undefined;
     endpoint?: string | undefined;
     apiKey?: string | undefined;
+    maxTokens?: number | undefined;
 }, {
     provider: "custom" | "openai" | "azure_openai" | "local" | "cohere" | "huggingface";
     model: string;
     dimensions: number;
     batchSize?: number | undefined;
-    maxTokens?: number | undefined;
     endpoint?: string | undefined;
     apiKey?: string | undefined;
+    maxTokens?: number | undefined;
 }>;
 /**
  * Text Chunking Strategy
@@ -290,8 +290,8 @@ export declare const RerankingConfigSchema: z.ZodObject<{
     provider?: "custom" | "cohere" | "huggingface" | undefined;
     model?: string | undefined;
 }, {
-    enabled?: boolean | undefined;
     provider?: "custom" | "cohere" | "huggingface" | undefined;
+    enabled?: boolean | undefined;
     model?: string | undefined;
     topK?: number | undefined;
 }>;
@@ -315,9 +315,9 @@ export declare const VectorStoreConfigSchema: z.ZodObject<{
     timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
     timeout: number;
+    provider: "custom" | "redis" | "elasticsearch" | "pinecone" | "weaviate" | "qdrant" | "milvus" | "chroma" | "pgvector" | "opensearch";
     batchSize: number;
     metric: "cosine" | "euclidean" | "dotproduct";
-    provider: "custom" | "redis" | "pinecone" | "weaviate" | "qdrant" | "milvus" | "chroma" | "pgvector" | "opensearch" | "elasticsearch";
     dimensions: number;
     indexName: string;
     connectionPoolSize: number;
@@ -326,7 +326,7 @@ export declare const VectorStoreConfigSchema: z.ZodObject<{
     host?: string | undefined;
     port?: number | undefined;
 }, {
-    provider: "custom" | "redis" | "pinecone" | "weaviate" | "qdrant" | "milvus" | "chroma" | "pgvector" | "opensearch" | "elasticsearch";
+    provider: "custom" | "redis" | "elasticsearch" | "pinecone" | "weaviate" | "qdrant" | "milvus" | "chroma" | "pgvector" | "opensearch";
     dimensions: number;
     indexName: string;
     timeout?: number | undefined;
@@ -395,21 +395,21 @@ export declare const RAGPipelineConfigSchema: z.ZodObject<{
         endpoint: z.ZodOptional<z.ZodString>;
         apiKey: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
-        batchSize: number;
         provider: "custom" | "openai" | "azure_openai" | "local" | "cohere" | "huggingface";
+        batchSize: number;
         model: string;
         dimensions: number;
-        maxTokens?: number | undefined;
         endpoint?: string | undefined;
         apiKey?: string | undefined;
+        maxTokens?: number | undefined;
     }, {
         provider: "custom" | "openai" | "azure_openai" | "local" | "cohere" | "huggingface";
         model: string;
         dimensions: number;
         batchSize?: number | undefined;
-        maxTokens?: number | undefined;
         endpoint?: string | undefined;
         apiKey?: string | undefined;
+        maxTokens?: number | undefined;
     }>;
     vectorStore: z.ZodObject<{
         provider: z.ZodEnum<["pinecone", "weaviate", "qdrant", "milvus", "chroma", "pgvector", "redis", "opensearch", "elasticsearch", "custom"]>;
@@ -428,9 +428,9 @@ export declare const RAGPipelineConfigSchema: z.ZodObject<{
         timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     }, "strip", z.ZodTypeAny, {
         timeout: number;
+        provider: "custom" | "redis" | "elasticsearch" | "pinecone" | "weaviate" | "qdrant" | "milvus" | "chroma" | "pgvector" | "opensearch";
         batchSize: number;
         metric: "cosine" | "euclidean" | "dotproduct";
-        provider: "custom" | "redis" | "pinecone" | "weaviate" | "qdrant" | "milvus" | "chroma" | "pgvector" | "opensearch" | "elasticsearch";
         dimensions: number;
         indexName: string;
         connectionPoolSize: number;
@@ -439,7 +439,7 @@ export declare const RAGPipelineConfigSchema: z.ZodObject<{
         host?: string | undefined;
         port?: number | undefined;
     }, {
-        provider: "custom" | "redis" | "pinecone" | "weaviate" | "qdrant" | "milvus" | "chroma" | "pgvector" | "opensearch" | "elasticsearch";
+        provider: "custom" | "redis" | "elasticsearch" | "pinecone" | "weaviate" | "qdrant" | "milvus" | "chroma" | "pgvector" | "opensearch";
         dimensions: number;
         indexName: string;
         timeout?: number | undefined;
@@ -578,8 +578,8 @@ export declare const RAGPipelineConfigSchema: z.ZodObject<{
         provider?: "custom" | "cohere" | "huggingface" | undefined;
         model?: string | undefined;
     }, {
-        enabled?: boolean | undefined;
         provider?: "custom" | "cohere" | "huggingface" | undefined;
+        enabled?: boolean | undefined;
         model?: string | undefined;
         topK?: number | undefined;
     }>>;
@@ -633,19 +633,19 @@ export declare const RAGPipelineConfigSchema: z.ZodObject<{
     label: string;
     name: string;
     embedding: {
-        batchSize: number;
         provider: "custom" | "openai" | "azure_openai" | "local" | "cohere" | "huggingface";
+        batchSize: number;
         model: string;
         dimensions: number;
-        maxTokens?: number | undefined;
         endpoint?: string | undefined;
         apiKey?: string | undefined;
+        maxTokens?: number | undefined;
     };
     vectorStore: {
         timeout: number;
+        provider: "custom" | "redis" | "elasticsearch" | "pinecone" | "weaviate" | "qdrant" | "milvus" | "chroma" | "pgvector" | "opensearch";
         batchSize: number;
         metric: "cosine" | "euclidean" | "dotproduct";
-        provider: "custom" | "redis" | "pinecone" | "weaviate" | "qdrant" | "milvus" | "chroma" | "pgvector" | "opensearch" | "elasticsearch";
         dimensions: number;
         indexName: string;
         connectionPoolSize: number;
@@ -726,12 +726,12 @@ export declare const RAGPipelineConfigSchema: z.ZodObject<{
         model: string;
         dimensions: number;
         batchSize?: number | undefined;
-        maxTokens?: number | undefined;
         endpoint?: string | undefined;
         apiKey?: string | undefined;
+        maxTokens?: number | undefined;
     };
     vectorStore: {
-        provider: "custom" | "redis" | "pinecone" | "weaviate" | "qdrant" | "milvus" | "chroma" | "pgvector" | "opensearch" | "elasticsearch";
+        provider: "custom" | "redis" | "elasticsearch" | "pinecone" | "weaviate" | "qdrant" | "milvus" | "chroma" | "pgvector" | "opensearch";
         dimensions: number;
         indexName: string;
         timeout?: number | undefined;
@@ -786,8 +786,8 @@ export declare const RAGPipelineConfigSchema: z.ZodObject<{
     description?: string | undefined;
     contextWindow?: number | undefined;
     reranking?: {
-        enabled?: boolean | undefined;
         provider?: "custom" | "cohere" | "huggingface" | undefined;
+        enabled?: boolean | undefined;
         model?: string | undefined;
         topK?: number | undefined;
     } | undefined;
@@ -934,6 +934,7 @@ export declare const RAGQueryResponseSchema: z.ZodObject<{
     tokensUsed: z.ZodOptional<z.ZodNumber>;
     retrievalTime: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
+    context: string;
     query: string;
     results: {
         content: string;
@@ -952,10 +953,10 @@ export declare const RAGQueryResponseSchema: z.ZodObject<{
         } | undefined;
         chunkId?: string | undefined;
     }[];
-    context: string;
     tokensUsed?: number | undefined;
     retrievalTime?: number | undefined;
 }, {
+    context: string;
     query: string;
     results: {
         content: string;
@@ -974,7 +975,6 @@ export declare const RAGQueryResponseSchema: z.ZodObject<{
         } | undefined;
         chunkId?: string | undefined;
     }[];
-    context: string;
     tokensUsed?: number | undefined;
     retrievalTime?: number | undefined;
 }>;
@@ -1001,8 +1001,8 @@ export declare const RAGPipelineStatusSchema: z.ZodObject<{
     status: "active" | "error" | "disabled" | "indexing";
     name: string;
     documentsIndexed: number;
-    lastIndexed?: string | undefined;
     errorMessage?: string | undefined;
+    lastIndexed?: string | undefined;
     health?: {
         vectorStore: "unknown" | "healthy" | "unhealthy";
         embeddingService: "unknown" | "healthy" | "unhealthy";
@@ -1011,8 +1011,8 @@ export declare const RAGPipelineStatusSchema: z.ZodObject<{
     status: "active" | "error" | "disabled" | "indexing";
     name: string;
     documentsIndexed: number;
-    lastIndexed?: string | undefined;
     errorMessage?: string | undefined;
+    lastIndexed?: string | undefined;
     health?: {
         vectorStore: "unknown" | "healthy" | "unhealthy";
         embeddingService: "unknown" | "healthy" | "unhealthy";