@props-labs/mesh-os 0.1.20 → 0.2.0

package/dist/core/__fixtures__/mock_responses.d.ts

@@ -0,0 +1,318 @@
+export declare const SAMPLE_IDS: {
+    readonly AGENT: "d7f3668d-5ebf-4f95-9b5c-07301f5d4c62";
+    readonly MEMORY: "f7a6c2b1-d123-4567-8901-2345abcdef67";
+    readonly WORKFLOW: "c4d5e6f7-3456-7890-12cd-ef3456789012";
+};
+export declare const AGENT_MOCKS: {
+    getAgent: {
+        data: {
+            agents_by_pk: {
+                id: "d7f3668d-5ebf-4f95-9b5c-07301f5d4c62";
+                name: string;
+                description: string;
+                slug: string;
+                created_at: string;
+                updated_at: string;
+            };
+        };
+    };
+    getBySlug: {
+        data: {
+            agents: {
+                id: "d7f3668d-5ebf-4f95-9b5c-07301f5d4c62";
+                name: string;
+                description: string;
+                slug: string;
+                created_at: string;
+                updated_at: string;
+            }[];
+        };
+    };
+    register: {
+        data: {
+            insert_agents_one: {
+                id: string;
+                name: string;
+                description: string;
+                slug: string;
+                created_at: string;
+                updated_at: string;
+            };
+        };
+    };
+};
+export declare const MEMORY_MOCKS: {
+    getTypeSchema: {
+        data: {
+            type_schemas_by_pk: {
+                type: string;
+                schema: {
+                    type: string;
+                    properties: {
+                        title: {
+                            type: string;
+                            description: string;
+                        };
+                        content: {
+                            type: string;
+                            description: string;
+                        };
+                    };
+                };
+                metadata_schema: {
+                    type: string;
+                    properties: {
+                        source: {
+                            type: string;
+                            description: string;
+                        };
+                        tags: {
+                            type: string;
+                            description: string;
+                            items: {
+                                type: string;
+                            };
+                        };
+                    };
+                };
+                embedding_config: {
+                    model: string;
+                    dimensions: number;
+                };
+                chunking_config: {
+                    chunk_size: number;
+                    chunk_overlap: number;
+                };
+                created_at: string;
+                updated_at: string;
+            };
+        };
+    };
+    listSchemas: {
+        data: {
+            type_schemas: ({
+                type: string;
+                schema: {
+                    type: string;
+                    properties: {
+                        title: {
+                            type: string;
+                        };
+                        content: {
+                            type: string;
+                        };
+                        language?: undefined;
+                        code?: undefined;
+                    };
+                };
+                metadata_schema: {
+                    type: string;
+                    properties: {
+                        source: {
+                            type: string;
+                        };
+                        tags: {
+                            type: string;
+                            items: {
+                                type: string;
+                            };
+                        };
+                    };
+                };
+                embedding_config: {
+                    model: string;
+                    dimensions: number;
+                };
+                chunking_config: {
+                    chunk_size: number;
+                    chunk_overlap: number;
+                };
+                created_at: string;
+                updated_at: string;
+            } | {
+                type: string;
+                schema: {
+                    type: string;
+                    properties: {
+                        language: {
+                            type: string;
+                        };
+                        code: {
+                            type: string;
+                        };
+                        title?: undefined;
+                        content?: undefined;
+                    };
+                };
+                metadata_schema: {
+                    type: string;
+                    properties: {
+                        source: {
+                            type: string;
+                        };
+                        tags: {
+                            type: string;
+                            items: {
+                                type: string;
+                            };
+                        };
+                    };
+                };
+                embedding_config: {
+                    model: string;
+                    dimensions: number;
+                };
+                chunking_config: {
+                    chunk_size: number;
+                    chunk_overlap: number;
+                };
+                created_at: string;
+                updated_at: string;
+            })[];
+        };
+    };
+};
+export declare const WORKFLOW_MOCKS: {
+    listSchemas: {
+        data: {
+            workflow_schemas: ({
+                type: string;
+                input_schema: {
+                    type: string;
+                    properties: {
+                        document_id: {
+                            type: string;
+                            description: string;
+                        };
+                        analysis_type: {
+                            type: string;
+                            description: string;
+                            enum: string[];
+                        };
+                        code_id?: undefined;
+                    };
+                };
+                output_schema: {
+                    type: string;
+                    properties: {
+                        result: {
+                            type: string;
+                            description: string;
+                        };
+                        confidence: {
+                            type: string;
+                            description: string;
+                        };
+                        issues?: undefined;
+                    };
+                };
+                metadata_schema: {
+                    type: string;
+                    properties: {
+                        model_version: {
+                            type: string;
+                            description: string;
+                        };
+                    };
+                };
+                created_at: string;
+                updated_at: string;
+            } | {
+                type: string;
+                input_schema: {
+                    type: string;
+                    properties: {
+                        code_id: {
+                            type: string;
+                            description: string;
+                        };
+                        document_id?: undefined;
+                        analysis_type?: undefined;
+                    };
+                };
+                output_schema: {
+                    type: string;
+                    properties: {
+                        issues: {
+                            type: string;
+                            description: string;
+                        };
+                        result?: undefined;
+                        confidence?: undefined;
+                    };
+                };
+                created_at: string;
+                updated_at: string;
+                metadata_schema?: undefined;
+            })[];
+        };
+    };
+    getSchema: {
+        data: {
+            workflow_schemas_by_pk: {
+                type: string;
+                input_schema: {
+                    type: string;
+                    properties: {
+                        document_id: {
+                            type: string;
+                            description: string;
+                        };
+                        analysis_type: {
+                            type: string;
+                            description: string;
+                            enum: string[];
+                        };
+                    };
+                };
+                output_schema: {
+                    type: string;
+                    properties: {
+                        result: {
+                            type: string;
+                            description: string;
+                        };
+                        confidence: {
+                            type: string;
+                            description: string;
+                        };
+                    };
+                };
+                metadata_schema: {
+                    type: string;
+                    properties: {
+                        model_version: {
+                            type: string;
+                            description: string;
+                        };
+                    };
+                };
+                created_at: string;
+                updated_at: string;
+            };
+        };
+    };
+    createRun: {
+        data: {
+            insert_workflow_runs_one: {
+                id: "c4d5e6f7-3456-7890-12cd-ef3456789012";
+                type: string;
+                status: string;
+                input: {
+                    document_id: string;
+                    analysis_type: string;
+                };
+                metadata: {
+                    source: string;
+                };
+                created_at: string;
+                updated_at: string;
+                agent_id: "d7f3668d-5ebf-4f95-9b5c-07301f5d4c62";
+            };
+        };
+    };
+};
+export declare const createMockFetch: (mocks: Record<string, any>) => (url: string, init?: RequestInit) => Promise<{
+    ok: boolean;
+    json: () => Promise<any>;
+}>;

package/dist/core/__fixtures__/mock_responses.js

@@ -0,0 +1,333 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMockFetch = exports.WORKFLOW_MOCKS = exports.MEMORY_MOCKS = exports.AGENT_MOCKS = exports.SAMPLE_IDS = void 0;
+// Sample IDs used across tests
+exports.SAMPLE_IDS = {
+    AGENT: 'd7f3668d-5ebf-4f95-9b5c-07301f5d4c62',
+    MEMORY: 'f7a6c2b1-d123-4567-8901-2345abcdef67',
+    WORKFLOW: 'c4d5e6f7-3456-7890-12cd-ef3456789012'
+};
+// Agent mock responses
+exports.AGENT_MOCKS = {
+    getAgent: {
+        data: {
+            agents_by_pk: {
+                id: exports.SAMPLE_IDS.AGENT,
+                name: 'TestAgent',
+                description: 'A test agent for development and examples',
+                slug: 'test-agent',
+                created_at: '2025-02-18T00:00:00Z',
+                updated_at: '2025-02-18T00:00:00Z'
+            }
+        }
+    },
+    getBySlug: {
+        data: {
+            agents: [{
+                    id: exports.SAMPLE_IDS.AGENT,
+                    name: 'TestAgent',
+                    description: 'A test agent for development and examples',
+                    slug: 'test-agent',
+                    created_at: '2025-02-18T00:00:00Z',
+                    updated_at: '2025-02-18T00:00:00Z'
+                }]
+        }
+    },
+    register: {
+        data: {
+            insert_agents_one: {
+                id: '11111111-1111-1111-1111-111111111111',
+                name: 'New Agent',
+                description: 'A newly registered test agent',
+                slug: 'new-test-agent',
+                created_at: '2025-02-18T00:00:00Z',
+                updated_at: '2025-02-18T00:00:00Z'
+            }
+        }
+    }
+};
+// Memory mock responses
+exports.MEMORY_MOCKS = {
+    getTypeSchema: {
+        data: {
+            type_schemas_by_pk: {
+                type: 'text_document',
+                schema: {
+                    type: 'object',
+                    properties: {
+                        title: {
+                            type: 'string',
+                            description: 'The title or heading of the text document'
+                        },
+                        content: {
+                            type: 'string',
+                            description: 'The main content or body of the text document'
+                        }
+                    }
+                },
+                metadata_schema: {
+                    type: 'object',
+                    properties: {
+                        source: {
+                            type: 'string',
+                            description: 'The origin or source of the document'
+                        },
+                        tags: {
+                            type: 'array',
+                            description: 'List of tags or categories for the document',
+                            items: { type: 'string' }
+                        }
+                    }
+                },
+                embedding_config: {
+                    model: 'text-embedding-3-small',
+                    dimensions: 1536
+                },
+                chunking_config: {
+                    chunk_size: 1000,
+                    chunk_overlap: 100
+                },
+                created_at: '2025-02-18T00:00:00Z',
+                updated_at: '2025-02-18T00:00:00Z'
+            }
+        }
+    },
+    listSchemas: {
+        data: {
+            type_schemas: [
+                {
+                    type: 'text_document',
+                    schema: {
+                        type: 'object',
+                        properties: {
+                            title: { type: 'string' },
+                            content: { type: 'string' }
+                        }
+                    },
+                    metadata_schema: {
+                        type: 'object',
+                        properties: {
+                            source: { type: 'string' },
+                            tags: { type: 'array', items: { type: 'string' } }
+                        }
+                    },
+                    embedding_config: {
+                        model: 'text-embedding-3-small',
+                        dimensions: 1536
+                    },
+                    chunking_config: {
+                        chunk_size: 1000,
+                        chunk_overlap: 100
+                    },
+                    created_at: '2025-02-18T00:00:00Z',
+                    updated_at: '2025-02-18T00:00:00Z'
+                },
+                {
+                    type: 'code_snippet',
+                    schema: {
+                        type: 'object',
+                        properties: {
+                            language: { type: 'string' },
+                            code: { type: 'string' }
+                        }
+                    },
+                    metadata_schema: {
+                        type: 'object',
+                        properties: {
+                            source: { type: 'string' },
+                            tags: { type: 'array', items: { type: 'string' } }
+                        }
+                    },
+                    embedding_config: {
+                        model: 'text-embedding-3-small',
+                        dimensions: 1536
+                    },
+                    chunking_config: {
+                        chunk_size: 500,
+                        chunk_overlap: 50
+                    },
+                    created_at: '2025-02-18T00:00:00Z',
+                    updated_at: '2025-02-18T00:00:00Z'
+                }
+            ]
+        }
+    }
+};
+// Workflow mock responses
+exports.WORKFLOW_MOCKS = {
+    listSchemas: {
+        data: {
+            workflow_schemas: [
+                {
+                    type: 'document_analysis',
+                    input_schema: {
+                        type: 'object',
+                        properties: {
+                            document_id: {
+                                type: 'string',
+                                description: 'The unique identifier of the document to analyze'
+                            },
+                            analysis_type: {
+                                type: 'string',
+                                description: 'The type of analysis to perform on the document',
+                                enum: ['sentiment', 'summary', 'key_points']
+                            }
+                        }
+                    },
+                    output_schema: {
+                        type: 'object',
+                        properties: {
+                            result: {
+                                type: 'object',
+                                description: 'The analysis results for the document'
+                            },
+                            confidence: {
+                                type: 'number',
+                                description: 'Confidence score of the analysis result'
+                            }
+                        }
+                    },
+                    metadata_schema: {
+                        type: 'object',
+                        properties: {
+                            model_version: {
+                                type: 'string',
+                                description: 'Version of the model used for analysis'
+                            }
+                        }
+                    },
+                    created_at: '2025-02-18T00:00:00Z',
+                    updated_at: '2025-02-18T00:00:00Z'
+                },
+                {
+                    type: 'code_review',
+                    input_schema: {
+                        type: 'object',
+                        properties: {
+                            code_id: {
+                                type: 'string',
+                                description: 'The unique identifier of the code to review'
+                            }
+                        }
+                    },
+                    output_schema: {
+                        type: 'object',
+                        properties: {
+                            issues: {
+                                type: 'array',
+                                description: 'List of identified issues'
+                            }
+                        }
+                    },
+                    created_at: '2025-02-18T00:00:00Z',
+                    updated_at: '2025-02-18T00:00:00Z'
+                }
+            ]
+        }
+    },
+    getSchema: {
+        data: {
+            workflow_schemas_by_pk: {
+                type: 'document_analysis',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        document_id: {
+                            type: 'string',
+                            description: 'The unique identifier of the document to analyze'
+                        },
+                        analysis_type: {
+                            type: 'string',
+                            description: 'The type of analysis to perform on the document',
+                            enum: ['sentiment', 'summary', 'key_points']
+                        }
+                    }
+                },
+                output_schema: {
+                    type: 'object',
+                    properties: {
+                        result: {
+                            type: 'object',
+                            description: 'The analysis results for the document'
+                        },
+                        confidence: {
+                            type: 'number',
+                            description: 'Confidence score of the analysis result'
+                        }
+                    }
+                },
+                metadata_schema: {
+                    type: 'object',
+                    properties: {
+                        model_version: {
+                            type: 'string',
+                            description: 'Version of the model used for analysis'
+                        }
+                    }
+                },
+                created_at: '2025-02-18T00:00:00Z',
+                updated_at: '2025-02-18T00:00:00Z'
+            }
+        }
+    },
+    createRun: {
+        data: {
+            insert_workflow_runs_one: {
+                id: exports.SAMPLE_IDS.WORKFLOW,
+                type: 'document_analysis',
+                status: 'pending',
+                input: {
+                    document_id: 'test-doc-123',
+                    analysis_type: 'summary'
+                },
+                metadata: {
+                    source: 'test'
+                },
+                created_at: '2025-02-18T00:00:00Z',
+                updated_at: '2025-02-18T00:00:00Z',
+                agent_id: exports.SAMPLE_IDS.AGENT
+            }
+        }
+    }
+};
+// Mock fetch function for testing
+const createMockFetch = (mocks) => {
+    return async (url, init) => {
+        const body = init?.body ? JSON.parse(init.body) : {};
+        const query = body.query;
+        // Determine which mock to return based on the query
+        let mockResponse;
+        if (query.includes('GetAgent')) {
+            mockResponse = mocks.getAgent;
+        }
+        else if (query.includes('GetAgentBySlug')) {
+            mockResponse = mocks.getBySlug;
+        }
+        else if (query.includes('RegisterAgent')) {
+            mockResponse = mocks.register;
+        }
+        else if (query.includes('ListTypeSchemas')) {
+            mockResponse = mocks.listSchemas;
+        }
+        else if (query.includes('GetTypeSchema')) {
+            mockResponse = mocks.getTypeSchema;
+        }
+        else if (query.includes('ListWorkflowSchemas')) {
+            mockResponse = mocks.listSchemas;
+        }
+        else if (query.includes('GetWorkflowSchema')) {
+            mockResponse = mocks.getSchema;
+        }
+        else if (query.includes('CreateWorkflowRun')) {
+            mockResponse = mocks.createRun;
+        }
+        if (!mockResponse) {
+            throw new Error(`No mock response found for query: ${query}`);
+        }
+        return {
+            ok: true,
+            json: async () => mockResponse
+        };
+    };
+};
+exports.createMockFetch = createMockFetch;