diff --git a/.gitignore b/.gitignore index d859fb059..92894e76a 100644 --- a/.gitignore +++ b/.gitignore @@ -100,6 +100,7 @@ ocrs .nx/installation .nx/cache .nx/workspace-data +storage_testing_debug_my_local_ai shinkai-bin/shinkai-node/files/zeko_mini.vrkai shinkai-bin/shinkai-node/files/short_story.md shinkai-bin/shinkai-node/files/shinkai_intro.vrkai diff --git a/Cargo.lock b/Cargo.lock index a6d53baca..0363a1260 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1866,18 +1866,6 @@ version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10" -[[package]] -name = "docx-rust" -version = "0.1.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "21507309413f0ba54ec1f2beeda534d116d3db94bffea9c18991bea116f3e522" -dependencies = [ - "derive_more 0.99.18", - "hard-xml", - "log", - "zip 1.1.4", -] - [[package]] name = "dotenv" version = "0.15.0" @@ -2948,31 +2936,6 @@ dependencies = [ "crunchy", ] -[[package]] -name = "hard-xml" -version = "1.36.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a344e0cef8802f37dc47f17c01a04354d3e66d9f6c8744108b0912f616efe266" -dependencies = [ - "hard-xml-derive", - "jetscii", - "lazy_static", - "memchr", - "xmlparser", -] - -[[package]] -name = "hard-xml-derive" -version = "1.36.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1bfae7cdfe23e50ea96929ccf1948d9ae1d8608353556461e5de247463d3a4f6" -dependencies = [ - "bitflags 2.6.0", - "proc-macro2", - "quote", - "syn 1.0.109", -] - [[package]] name = "hashbrown" version = "0.12.3" @@ -3762,12 +3725,6 @@ version = "1.0.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b" -[[package]] -name = "jetscii" -version = "0.5.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "47f142fe24a9c9944451e8349de0a56af5f3e7226dc46f3ed4d4ecc0b85af75e" - [[package]] name = "jobserver" version = "0.1.32" @@ -3938,7 +3895,7 @@ checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d" dependencies = [ "bitflags 2.6.0", "libc", - "redox_syscall", + "redox_syscall 0.5.7", ] [[package]] @@ -4022,15 +3979,6 @@ dependencies = [ "linked-hash-map", ] -[[package]] -name = "lz4_flex" -version = "0.11.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "75761162ae2b0e580d7e7c390558127e5f01b4194debd6221fd8c207fc80e3f5" -dependencies = [ - "twox-hash", -] - [[package]] name = "lzma-rs" version = "0.3.0" @@ -4594,15 +4542,6 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d" -[[package]] -name = "ordered-float" -version = "3.9.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1e1c390732d15f1d48471625cd92d154e66db2c56645e29a9cd26f4699f72dc" -dependencies = [ - "num-traits", -] - [[package]] name = "os_str_bytes" version = "6.6.1" @@ -4672,6 +4611,17 @@ dependencies = [ "parking_lot_core 0.2.14", ] +[[package]] +name = "parking_lot" +version = "0.11.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99" +dependencies = [ + "instant", + "lock_api", + "parking_lot_core 0.8.6", +] + [[package]] name = "parking_lot" version = "0.12.3" @@ -4694,6 +4644,20 @@ dependencies = [ "winapi", ] +[[package]] +name = "parking_lot_core" +version = "0.8.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60a2cfe6f0ad2bfc16aefa463b497d5c7a5ecd44a23efa72aa342d90177356dc" +dependencies = [ + "cfg-if", + "instant", + "libc", + "redox_syscall 0.2.16", + "smallvec 1.13.2", + "winapi", +] + [[package]] name = "parking_lot_core" version = "0.9.10" @@ -4702,7 +4666,7 @@ checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8" dependencies = [ "cfg-if", "libc", - "redox_syscall", + "redox_syscall 0.5.7", "smallvec 1.13.2", "windows-targets 0.52.6", ] @@ -5677,6 +5641,15 @@ dependencies = [ "rand_core 0.3.1", ] +[[package]] +name = "redox_syscall" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a" +dependencies = [ + "bitflags 1.3.2", +] + [[package]] name = "redox_syscall" version = "0.5.7" @@ -6494,6 +6467,28 @@ dependencies = [ "unsafe-libyaml", ] +[[package]] +name = "serial_test" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e0bccbcf40c8938196944a3da0e133e031a33f4d6b72db3bda3cc556e361905d" +dependencies = [ + "lazy_static", + "parking_lot 0.11.2", + "serial_test_derive", +] + +[[package]] +name = "serial_test_derive" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b2acd6defeddb41eb60bb468f8825d0cfd0c2a76bc03bfd235b6a1dc4f6a1ad5" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.109", +] + [[package]] name = "servo_arc" version = "0.3.0" @@ -6578,7 +6573,7 @@ checksum = "24188a676b6ae68c3b2cb3a01be17fbf7240ce009799bb56d5b1409051e78fde" [[package]] name = "shinkai-spreadsheet-llm" -version = "0.9.3" +version = "0.9.4" dependencies = [ "async-trait", "chrono", @@ -6593,7 +6588,7 @@ dependencies = [ [[package]] name = "shinkai_crypto_identities" -version = "0.9.3" +version = "0.9.4" dependencies = [ "chrono", "dashmap", @@ -6607,9 +6602,61 @@ dependencies = [ "x25519-dalek", ] +[[package]] +name = "shinkai_embedding" +version = "0.9.4" +dependencies = [ + "async-trait", + "bincode", + "blake3", + "chrono", + "csv", + "futures", + "keyphrases", + "lazy_static", + "rand 0.8.5", + "regex", + "reqwest 0.11.27", + "serde", + "serde_json", + "thiserror 2.0.3", + "utoipa", +] + +[[package]] +name = "shinkai_fs" +version = "0.9.4" +dependencies = [ + "async-trait", + "bincode", + "blake3", + "chrono", + "comrak", + "csv", + "futures", + "keyphrases", + "lazy_static", + "rand 0.8.5", + "regex", + "reqwest 0.11.27", + "scraper", + "serde", + "serde_json", + "serial_test", + "shinkai_embedding", + "shinkai_message_primitives", + "shinkai_ocr", + "shinkai_sqlite", + "tempfile", + "thiserror 2.0.3", + "tokio", + "urlencoding", + "utoipa", +] + [[package]] name = "shinkai_http_api" -version = "0.9.3" +version = "0.9.4" dependencies = [ "async-channel 1.9.0", "bytes", @@ -6634,21 +6681,21 @@ dependencies = [ [[package]] name = "shinkai_job_queue_manager" -version = "0.9.3" +version = "0.9.4" dependencies = [ "chrono", "serde", "serde_json", + "shinkai_embedding", "shinkai_message_primitives", "shinkai_sqlite", - "shinkai_vector_resources", "tempfile", "tokio", ] [[package]] name = "shinkai_message_primitives" -version = "0.9.3" +version = "0.9.4" dependencies = [ "aes-gcm", "async-trait", @@ -6663,7 +6710,8 @@ dependencies = [ "rust_decimal", "serde", "serde_json", - "shinkai_vector_resources", + "serial_test", + "tempfile", "thiserror 1.0.69", "tokio", "tracing", @@ -6674,14 +6722,14 @@ dependencies = [ [[package]] name = "shinkai_mini_libs" -version = "0.9.3" +version = "0.9.4" dependencies = [ "base64 0.22.1", ] [[package]] name = "shinkai_node" -version = "0.9.3" +version = "0.9.4" dependencies = [ "aes-gcm", "anyhow", @@ -6727,6 +6775,8 @@ dependencies = [ "serde", "serde_json", "shinkai_crypto_identities", + "shinkai_embedding", + "shinkai_fs", "shinkai_http_api", "shinkai_job_queue_manager", "shinkai_message_primitives", @@ -6735,15 +6785,13 @@ dependencies = [ "shinkai_tcp_relayer", "shinkai_tools_primitives", "shinkai_tools_runner", - "shinkai_vector_fs", - "shinkai_vector_resources", "tempfile", "tiny-bip39", "tokio", "tokio-tungstenite 0.15.0", "tokio-util", "umya-spreadsheet", - "urlencoding 2.1.3", + "urlencoding", "utoipa", "uuid 1.11.0", "warp", @@ -6753,7 +6801,7 @@ dependencies = [ [[package]] name = "shinkai_ocr" -version = "0.9.3" +version = "0.9.4" dependencies = [ "anyhow", "image 0.25.5", @@ -6768,7 +6816,7 @@ dependencies = [ [[package]] name = "shinkai_sheet" -version = "0.9.3" +version = "0.9.4" dependencies = [ "async-channel 1.9.0", "chrono", @@ -6782,7 +6830,7 @@ dependencies = [ [[package]] name = "shinkai_sqlite" -version = "0.9.3" +version = "0.9.4" dependencies = [ "bincode", "blake3", @@ -6799,10 +6847,10 @@ dependencies = [ "rust_decimal", "serde", "serde_json", + "shinkai_embedding", "shinkai_message_primitives", "shinkai_sheet", "shinkai_tools_primitives", - "shinkai_vector_resources", "sqlite-vec", "tempfile", "thiserror 2.0.3", @@ -6813,7 +6861,7 @@ dependencies = [ [[package]] name = "shinkai_tcp_relayer" -version = "0.9.3" +version = "0.9.4" dependencies = [ "chrono", "clap 3.2.25", @@ -6832,7 +6880,7 @@ dependencies = [ [[package]] name = "shinkai_tools_primitives" -version = "0.9.3" +version = "0.9.4" dependencies = [ "anyhow", "regex", @@ -6841,7 +6889,6 @@ dependencies = [ "serde_json", "shinkai_message_primitives", "shinkai_tools_runner", - "shinkai_vector_resources", "tokio", ] @@ -6880,53 +6927,6 @@ dependencies = [ "zip 2.2.1", ] -[[package]] -name = "shinkai_vector_fs" -version = "0.9.3" -dependencies = [ - "bincode", - "blake3", - "chrono", - "rand 0.8.5", - "serde", - "serde_json", - "shinkai_message_primitives", - "shinkai_sqlite", - "shinkai_vector_resources", - "tokio", -] - -[[package]] -name = "shinkai_vector_resources" -version = "0.9.3" -dependencies = [ - "async-trait", - "base64 0.22.1", - "blake3", - "chrono", - "comrak", - "csv", - "docx-rust", - "futures", - "hex", - "keyphrases", - "lazy_static", - "lz4_flex", - "num-traits", - "ordered-float", - "rand 0.8.5", - "regex", - "reqwest 0.11.27", - "scraper", - "serde", - "serde_json", - "shinkai_ocr", - "tokio", - "umya-spreadsheet", - "urlencoding 1.3.3", - "utoipa", -] - [[package]] name = "shlex" version = "1.3.0" @@ -7976,16 +7976,6 @@ dependencies = [ "utf-8", ] -[[package]] -name = "twox-hash" -version = "1.6.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675" -dependencies = [ - "cfg-if", - "static_assertions", -] - [[package]] name = "typed-arena" version = "2.0.2" @@ -8145,12 +8135,6 @@ dependencies = [ "percent-encoding", ] -[[package]] -name = "urlencoding" -version = "1.3.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a1f0175e03a0973cf4afd476bef05c26e228520400eb1fd473ad417b1c00ffb" - [[package]] name = "urlencoding" version = "2.1.3" @@ -8814,12 +8798,6 @@ version = "2.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "213b7324336b53d2414b2db8537e56544d981803139155afa84f76eeebb7a546" -[[package]] -name = "xmlparser" -version = "0.13.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "66fee0b777b0f5ac1c69bb06d361268faafa61cd4682ae064a171c16c433e9e4" - [[package]] name = "yaml-rust" version = "0.4.5" diff --git a/Cargo.toml b/Cargo.toml index 13194ccf2..a2c8445e1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -5,10 +5,10 @@ members = [ "shinkai-libs/shinkai-message-primitives", "shinkai-libs/shinkai-ocr", "shinkai-libs/shinkai-tcp-relayer", - "shinkai-libs/shinkai-vector-resources", - "shinkai-libs/shinkai-vector-fs", "shinkai-libs/shinkai-job-queue-manager", # "shinkai-libs/shinkai-baml", + "shinkai-libs/shinkai-fs", + "shinkai-libs/shinkai-embedding", "shinkai-libs/shinkai-http-api", "shinkai-libs/shinkai-tools-primitives", "shinkai-libs/shinkai-mini-libs", @@ -19,24 +19,24 @@ members = [ resolver = "2" [workspace.package] -version = "0.9.3" +version = "0.9.4" edition = "2021" authors = ["Nico Arqueros "] [workspace.dependencies] shinkai_message_primitives = { path = "./shinkai-libs/shinkai-message-primitives" } -shinkai_vector_resources = { path = "./shinkai-libs/shinkai-vector-resources" } shinkai_crypto_identities = { path = "./shinkai-libs/shinkai-crypto-identities" } shinkai_tcp_relayer = { path = "./shinkai-libs/shinkai-tcp-relayer" } shinkai_sheet = { path = "./shinkai-libs/shinkai-sheet" } shinkai_ocr = { path = "./shinkai-libs/shinkai-ocr" } -shinkai_vector_fs = { path = "./shinkai-libs/shinkai-vector-fs" } shinkai_job_queue_manager = { path = "./shinkai-libs/shinkai-job-queue-manager" } # shinkai_baml = { path = "./shinkai-libs/shinkai-baml" } shinkai_http_api = { path = "./shinkai-libs/shinkai-http-api" } shinkai_tools_primitives = { path = "./shinkai-libs/shinkai-tools-primitives" } shinkai_mini_libs = { path = "./shinkai-libs/shinkai-mini-libs" } shinkai_sqlite = { path = "./shinkai-libs/shinkai-sqlite" } +shinkai_fs = { path = "./shinkai-libs/shinkai-fs" } +shinkai_embedding = { path = "./shinkai-libs/shinkai-embedding" } futures = "0.3.30" keyphrases = "0.3.3" @@ -58,3 +58,4 @@ rand = "=0.8.5" chrono-tz = "0.5" hex = "=0.4.3" env_logger = "0.11.5" +async-trait = "0.1.74" diff --git a/README.md b/README.md index dc517a80c..731a8f6d9 100644 --- a/README.md +++ b/README.md @@ -14,6 +14,10 @@ More In Depth Codebase Documentation (Mutable.ai): [https://wiki.mutable.ai/dcSp ## Installation (Local Compilation) +### Prerequisites + +- Rust version >= 1.81 (required for `std::fs::exists` functionality) + Please refer to the installation instructions for your operating system: - [Windows Installation Instructions](docs/installation/windows.md) @@ -122,4 +126,4 @@ Use `act -j test-wasm -P self-hosted=nektos/act-environments-ubuntu:18.04 --cont ## Releasing a New Version -When releasing a new version, ensure that you update the `Cargo.toml` of the shinkai-node as well as the `Cargo.toml` of the shinkai-libs/shinkai-http-api library. \ No newline at end of file +When releasing a new version, ensure that you update the `Cargo.toml` of the shinkai-node as well as the `Cargo.toml` of the shinkai-libs/shinkai-http-api library. diff --git a/docs/architecture/group_chats.md b/docs/architecture/group_chats.md deleted file mode 100644 index 2013925ba..000000000 --- a/docs/architecture/group_chats.md +++ /dev/null @@ -1,34 +0,0 @@ -## Group Chats - -The implementation of group chats is not as simple as 1on1 chats. The main complexity is related to keeping the group chat history (particularly admin related actions) in sync between all the participants. The following sections describe the implementation of group chats in detail. - -### Group Chat Requirements - -- Multiple people should be able to send messages to each other (even encrypted). -- The group chat should be able to be created by any user. -- The group chat should allow users to be added and removed by admins. -- Admins can add other admins. -- Admins can remove other admins. - -### Group Chat Creation - -- Only one user is the actual creator. This user generates the group chat inbox_name which is used to identify the group chat. -- InboxName: group_chat::chat_uuid::creation_time::hash_of_initial_sorted_identities::creator_shinkai_id -- The creator is the first admin of the group chat. -- Besides the normal inbox_name used for the chat an action_group_inbox is created where all the admin actions are stored. - -### Group Admin Actions - -- Add user -- Remove user -- Update Group Description -- Add Admin (user already needs to have been added to the group) -- Remove Admin - -### Messages - -- Messages are normal ShinkaiMessages for most of it. -- The exception is that the sender needs to always send the id / time of the action when it was added to the action_group_inbox. -- Similar for admin actions, the sender needs to send the id / time of the action when it was added to the action_group_inbox. - -WIP \ No newline at end of file diff --git a/docs/chatgpt.md b/docs/chatgpt.md deleted file mode 100644 index 20345f018..000000000 --- a/docs/chatgpt.md +++ /dev/null @@ -1,37 +0,0 @@ -## A Guide to Leveraging ChatGPT for Rust Development - -Dear fellow Rustacean, if you're looking to harness the power of ChatGPT for your Rust development, you've come to the right place. The following are some tips and best practices to help you make the most of this versatile tool. Let's dive right in. - -### Structuring Your Rust Code - -Rust's expressive and efficient nature makes it a pleasure to work with. Here's how you can structure your code to assist both ChatGPT and yourself. - -- **Embrace brevity:** As a fellow dev, you already know the value of clean and concise code. Keep your files short and focused. This makes your code more maintainable, and it also helps ChatGPT by providing it with an easily digestible context. - -- **Modularize, modularize, modularize:** Breaking down your application into smaller, independent modules is beneficial in so many ways. It encourages code reuse, keeps your code organized, and helps when you need to ask ChatGPT about specific components. - -- **Use clear naming conventions:** Choose descriptive names for your functions, variables, and modules. This simple practice improves code readability and helps ChatGPT understand your code's purpose. - -- **Avoid adding tests in the same file:** While it's tempting to add tests to the same file as your code, it's better to keep them separate. This way, ChatGPT can focus on your code without getting distracted by the tests and we can maintain smaller files. - -### Engaging with ChatGPT - -ChatGPT can be an incredibly helpful companion for your Rust development. Here are some tips on how to effectively interact with it: - -- **Context is key:** When asking ChatGPT about a certain piece of code, ensure you provide all the relevant context. Include the piece of code in question, its intended function, and any problems you've run into. - -- **Be specific with your queries:** The more precise your question, the better the response. For instance, instead of asking "What's wrong with this?", try to provide details about expected vs. actual behavior and any error messages you've received. - -- **Acknowledge its limitations:** Remember, ChatGPT's training cut-off is September 2021, so it might not be aware of newer Rust features or libraries. Also, it can't execute or test your code, which means it won't know your project's current state or the output of your code. - -### Documenting Your Code - -Proper documentation goes a long way in any development process. Here's how you can make it work for you and ChatGPT. - -- **Leverage inline comments:** For complex code snippets, consider using inline comments to describe their functionality. This extra layer of information can provide ChatGPT with vital context. - -- **Make the most of doc comments:** Rust supports doc comments (comments starting with `///` or `//!`). Use them generously. These comments not only help generate documentation with `rustdoc`, but also provide quick summaries for ChatGPT. - -- **Consider README files:** A README file for each module, describing its role and relation to other parts of the application, can provide invaluable high-level context to ChatGPT. - -Remember, the goal here is to make your code as clear and understandable as possible, not just for you, but also for any tool or colleague who might work with it. This way, you ensure that both you and ChatGPT can work effectively with your Rust codebase. Happy coding! \ No newline at end of file diff --git a/docs/filesystem_changes.md b/docs/filesystem_changes.md new file mode 100644 index 000000000..79626f975 --- /dev/null +++ b/docs/filesystem_changes.md @@ -0,0 +1,74 @@ +# Filesystem Changes in Shinkai Node + +## Overview +This document describes the transition from virtual inboxes to a real filesystem implementation in Shinkai Node, including changes to the `JobMessage` structure and the introduction of the `ShinkaiPath` system. + +## Major Changes + +### Removal of Inboxes +Previously, inboxes were implemented as virtual constructs that simulated folders while storing blobs in a database. The system has been updated to use actual folders and files in the filesystem, providing a 1:1 mapping between virtual and physical files. + +### Updated JobMessage Structure +The `JobMessage` struct has been updated to reflect these changes: + +```rust +#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, ToSchema)] +pub struct JobMessage { + pub job_id: String, + pub content: String, + pub parent: Option, + pub sheet_job_data: Option, + // Whenever we need to chain actions, we can use this + pub callback: Option>, + // This is added from the node + pub metadata: Option, + // Whenever we want to force the use of a specific tool, we can use this + pub tool_key: Option, + // Field that lists associated files of the message + #[serde(default)] + pub fs_files_paths: Vec, + #[serde(default)] + pub job_filenames: Vec, +} +``` + +## File Path Handling + +### fs_files_paths +The `fs_files_paths` field uses `ShinkaiPath` to represent relative paths that appear as absolute paths from the node's perspective. + +Example: +``` +Folder: legal +File: buying my dog a house contract.pdf +fs_files_paths entry: legal/buying my dog a house contract.pdf +``` + +### job_filenames +The `job_filenames` field is used for files uploaded directly to a job. Job folders are created with a specific naming convention: +``` +Format: {Month} {Day} - ({JobID last 4 chars}) {First message...} +Example: Dec 26 - (89AF) Tell me what this... +``` + +When uploading a file to a job (e.g., `my cat.jpg`), you only need to specify the filename in `job_filenames` rather than the full path. + +### ShinkaiPath +The `ShinkaiPath` struct handles path conversions at the node level: +- Provides a consistent way to handle file paths across the system +- Offers `.full_path()` method to get the absolute path when needed +- Includes comprehensive test coverage for various scenarios + +## Docker Mount Considerations + +### Current Limitations +- Cannot mount two files with the same name from different folders +- Example: If you have `folder1/config.json` and `folder2/config.json`, you can't mount both simultaneously + +### Workaround +A file map implementation in the code runner side is being developed to address this limitation. From the code runner's perspective, only the real (absolute) path is required for operation. + +## Implementation Notes +- `ShinkaiFileManager` and `ShinkaiPath` include comprehensive tests for various scenarios +- Path conversion happens automatically at the node level +- The system maintains backward compatibility while providing a more robust file handling mechanism diff --git a/docs/network/architecture.md b/docs/network/architecture.md deleted file mode 100644 index 199ba50fc..000000000 --- a/docs/network/architecture.md +++ /dev/null @@ -1,27 +0,0 @@ -## TODO -Review this and address the different points - - -## Architecture - -The Node-based architecture you have implemented is a good starting point for a peer-to-peer (P2P) network. However, depending on the specific requirements of your application, there are many ways to enhance or change this implementation. Some of them include: - -1. **Connection Management**: The current implementation does not actively manage connections. You can introduce a connection manager to keep track of all the connected nodes, check the health of the connections, and drop connections that are inactive or not responding. - -2. **Message Routing**: Implementing some sort of routing protocol to propagate messages in the network could be beneficial. This is especially important in larger P2P networks where not all nodes are directly connected to each other. - -3. **Concurrency Management**: Your current implementation uses async tasks for handling incoming and outgoing connections. It would be better to have more structured task management to limit the number of concurrent tasks, and to properly clean up tasks that are finished or errored. - -4. **Peer Discovery**: Another feature that could be added is a peer discovery mechanism. Currently, you have to manually specify which node to connect to. With peer discovery, nodes can automatically find each other. - -5. **Reliability**: Implement a retry mechanism for failed message sends. In a P2P network, peers can join and leave the network unpredictably, so message delivery is not always guaranteed. You might want to implement a retry mechanism or even a more advanced reliable transport protocol on top of TCP. - -6. **Security**: You could add more security features, such as encrypting the entire communication, not just the messages, authenticating nodes, or protecting against denial-of-service attacks. - -7. **Scalability**: As your network grows, you might need to implement some form of distributed hash table (DHT) for more efficient message routing. - -8. **Error Handling**: Improve error handling. In a real-world application, you should avoid using `.unwrap()` and instead handle errors gracefully. - -9. **Testing**: Implement tests to ensure the correct behavior of your application. This could include unit tests, integration tests, and end-to-end tests. - -These are just some examples of how you could improve your P2P network. The specific improvements and features you should implement depend heavily on the requirements of your application. A P2P network for file sharing, for example, would have very different requirements compared to a P2P network for a multiplayer game. \ No newline at end of file diff --git a/docs/network/closing_connection.md b/docs/network/closing_connection.md deleted file mode 100644 index 0bc84a4a4..000000000 --- a/docs/network/closing_connection.md +++ /dev/null @@ -1,11 +0,0 @@ -Closing the TCP connection in a more graceful manner would usually involve following the standard TCP connection termination process, which consists of a four-way handshake (FIN, ACK, FIN, ACK). However, this process is typically handled by lower-level libraries, and you may not need to implement it manually. - -In your case, you could attempt to enhance the process by ensuring both sides are ready to close the connection before actually closing it. Here's how: - -1. **Client sends termination request to the server**: The client sends a special "terminate" message to the server. - -2. **Server acknowledges termination request**: Upon receiving the "terminate" message, the server could send a "terminate_ack" message back to the client to acknowledge that it's ready to close the connection, and then stop its reading task. - -3. **Client acknowledges server's termination acknowledgement**: The client, after receiving the "terminate_ack" message, can then also stop its reading task, effectively ending its side of the connection. - -4. **Both sides close the connection**: Now, both the client and the server can close their sockets, since they have both agreed to terminate the connection. diff --git a/docs/network/job_engine_alt.md b/docs/network/job_engine_alt.md deleted file mode 100644 index bd1817036..000000000 --- a/docs/network/job_engine_alt.md +++ /dev/null @@ -1,45 +0,0 @@ -Designing architectures to handle parallel or sequential message processing is a complex task that heavily depends on the specific use-case and requirements of the application. Here, we'll go over a few different architectures that could handle the task you've described, including their pros and cons. - -1. **Sequential Processing with a Single Queue:** - - **Pros:** - - Sequential processing guarantees the order of processing, which is critical for certain types of tasks. - - The code for this setup tends to be quite simple. - - **Cons:** - - This setup can become a bottleneck if the processing function is slow and there are many incoming messages. - - It doesn't leverage multi-core capabilities of modern processors. - -2. **Parallel Processing with Multiple Queues (One per Thread/Task):** - - **Pros:** - - It can process multiple messages concurrently, providing much higher throughput. - - It leverages multi-core capabilities. - - **Cons:** - - Managing multiple threads/tasks and their corresponding queues can be complex. - - It doesn't guarantee the order of processing, which can be problematic for certain types of tasks. - -3. **Actor Model (using a library like Actix):** - - **Pros:** - - It simplifies asynchronous programming by encapsulating state and behavior within actors, reducing the chance for race conditions. - - The library manages the creation and scheduling of tasks, leaving you to focus on your business logic. - - Messages sent to actors are handled in the order they were received, which can be beneficial for tasks that require ordered processing. - - **Cons:** - - It can have a learning curve if you're not already familiar with the actor model. - - The actor model adds another layer of abstraction, which can potentially complicate the codebase. - -4. **Event-Driven Architecture (using a library like Tokio or async-std):** - - **Pros:** - - Allows for highly concurrent operations and handles backpressure naturally. - - Libraries like Tokio have built-in support for timers, I/O operations, and other asynchronous operations. - - **Cons:** - - Can be more difficult to reason about due to the inherent complexities of asynchronous programming. - - Debugging can be more challenging than synchronous programming. - -5. **Distributed Message Queue (like Kafka or RabbitMQ):** - - **Pros:** - - Great for applications that need to process a large number of messages concurrently. - - They provide out-of-the-box support for things like delivery guarantees, message ordering, and message durability. - - Built-in support for distributing work across multiple machines. - - **Cons:** - - Overkill for applications that don't need to process a large volume of messages. - - Requires maintaining an additional piece of infrastructure. - -Each of these architectures has its pros and cons, and the right choice depends on the specific use case and requirements. While the single queue architecture might be the simplest, it may not offer the best performance if you need to process many messages concurrently. The Actor Model and Event-Driven Architecture offer more flexibility and potentially better performance, but they can be more challenging to set up and reason about. And while Distributed Message Queues can handle a large volume of messages, they might be overkill for applications that don't require such capabilities. \ No newline at end of file diff --git a/docs/vector_fs.md b/docs/vector_fs.md deleted file mode 100644 index b299a023d..000000000 --- a/docs/vector_fs.md +++ /dev/null @@ -1,231 +0,0 @@ -# VectorFS In-Node Rust Documentation - -## Introduction - -Shinkai's Vector File System (VectorFS) offers a file-system like experience while providing full Vector Search capabilities. The VectorFS does not replace classical operating-system level file systems, but lives within the Shinkai node, acting as both the native storage solution for all content used with AI in the Shinkai node, while also allowing external apps to integrate it into their stack like a next-generation VectorDB. - -The VectorFS fully incorporates a global permission system (based on Shinkai identities) thereby securely allowing sharing AI data embeddings with anyone, including with gated whitelists which require delegation/payments (coming Q2 2024). - -### Understanding the Basics - -At the heart of VectorFS is a hierarchical structure based on paths, where `/` represents the root directory. This structure allows for an intuitive organization of data, mirroring the familiar file system hierarchy found in operating systems. - -#### FSEntries: FSFolder and FSItem - -Within the VectorFS, every non-root path contains an FSEntry, which can be either an FSFolder or an FSItem. This distinction is crucial for understanding how VectorFS organizes and manages its contents: - -- **FSFolders**: These are directory-like structures that can exist at any depth within the VectorFS, starting from the root. An FSFolder can contain other FSFolders (subdirectories) and FSItems (files), allowing for a nested, tree-like organization of data. Folders in VectorFS are not just simple containers; they also hold metadata such as creation, modification, and access times, providing a rich context for the data they contain. - -```rust -pub struct FSFolder { - /// Name of the FSFolder - pub name: String, - /// Path where the FSItem is held in the VectorFS - pub path: VRPath, - /// FSFolders which are held within this FSFolder - pub child_folders: Vec, - /// FSItems which are held within this FSFolder - pub child_items: Vec, - /// Datetime the FSFolder was first created - pub created_datetime: DateTime, - /// Datetime the FSFolder was last read by any ShinkaiName - pub last_read_datetime: DateTime, - /// Datetime the FSFolder was last modified, meaning contents of the directory were changed. - /// Ie. An FSEntry is moved/renamed/deleted/new one added. - pub last_modified_datetime: DateTime, - /// Datetime the FSFolder was last written to, meaning any write took place under the folder. In other words, even when - /// a VR is updated or moved/renamed, then last written is always updated. - pub last_written_datetime: DateTime, - /// Merkle hash comprised of all of the FSEntries within this folder - pub merkle_hash: String, -} -``` - -- **FSItems**: Representing the "files" within VectorFS, FSItems are containers for a single Vector Resource + an optional set of Source Files the Vector Resource was created from (pdfs, docs, txts, etc). FSItems enables the VectorFS to tie original file formats with their vector representations, enhancing the system's utility for a wide range of applications. All FSItems have embeddings, meaning that they are always able to be found via Vector Search in the VectorFS (and be Vector Searched internally as well). Of note, unlike FSFolders, FSItems cannot be placed directly under the root of the file system, but may be placed in any FSFolder. - -```rust -pub struct FSItem { - /// Name of the FSItem (based on Vector Resource name) - pub name: String, - /// Path where the FSItem is held in the VectorFS - pub path: VRPath, - /// The VRHeader matching the Vector Resource stored at this FSItem's path - pub vr_header: VRHeader, - /// Datetime the Vector Resource in the FSItem was first created - pub created_datetime: DateTime, - /// Datetime the Vector Resource in the FSItem was last written to, meaning any updates to its contents. - pub last_written_datetime: DateTime, - /// Datetime the FSItem was last read by any ShinkaiName - pub last_read_datetime: DateTime, - /// Datetime the Vector Resource in the FSItem was last saved/updated. - /// For example when saving a VR into the FS that someone else generated on their node, last_written and last_saved will be different. - pub vr_last_saved_datetime: DateTime, - /// Datetime the SourceFileMap in the FSItem was last saved/updated. None if no SourceFileMap was ever saved. - pub source_file_map_last_saved_datetime: Option>, - /// The original location where the VectorResource/SourceFileMap in this FSItem were downloaded/fetched/synced from. - pub distribution_origin: Option, - /// The size in bytes of the Vector Resource in this FSItem - pub vr_size: usize, - /// The size in bytes of the SourceFileMap in this FSItem. Will be 0 if no SourceFiles are saved. - pub source_file_map_size: usize, - /// Merkle hash, which is in fact the merkle root of the Vector Resource stored in the FSItem - pub merkle_hash: String, -} -``` - -### Understanding Permissions in The VectorFS - -Every path into the VectorFS holds an FSEntry has a PathPermission specified for it. The `PathPermission` consists of: - -- **ReadPermission**: Determines who can read the contents of a path. It can be one of the following: - - - `Private`: Only the profile owner has read access. - - `NodeProfiles`: Specific profiles on the same node have read access. - - `Whitelist`: Only identities explicitly listed in the whitelist have read access. - - `Public`: Anyone on the Shinkai Network can read the contents. - -- **WritePermission**: Determines who can modify the contents of a path. - - - `Private`: Only the profile owner has read access. - - `NodeProfiles`: Specific profiles on the same node have read access. - - `Whitelist`: Only identities explicitly listed in the whitelist have read access. - - As of February 2024, the current implementation automatically sets all newly created item/folder permissions to "Whitelist" with no identities added to it. In effect this is equivalent to "Private" as the list is empty, and it simplifies frontend permission management up-front. However do note for advanced use cases, when identities are added to the whitelist it is possible to change the permission to "Private" in order to block access (potentially temporarily) to the path while still preserving the whitelist (whitelists are preserved when changing read/write perms of the path, and only deleted in whole if the FSEntry at the path is fully deleted). - -#### Whitelist Permissions - -When either the read or write permission for a path is set to Whitelist, then whether a user (Shinkai Name) has access to the path is determined by the whitelist held inside the PathPermission. - -In the whitelist each `ShinkaiName` can be set to one of `Read`, `Write`, or `ReadWrite`. This mechanism enables the filesystem to grant or restrict access based on the specific needs of each path. - -Folder permissions are also naturally hierarchical as one would expect. This means that if a user is whitelisted for `/folder1/` then they will be automatically whitelisted for an item that is held at `/folder1/my_item`. Do note, `/folder1/my_item` needs to have at least one of its read/write permissions set to `Whitelist` in order for the whitelist on `/folder1/` to apply to my_item. - -## Implementation - -When a Shinkai Node is initialized, it orchestrates the setup of the Vector File System (VectorFS). The VectorFS is made available as a field within the Node struct as an Arc Mutex to have it be easily accessible across the entire Node. - -```rust -pub struct Node { - ... - pub vector_fs: Arc -} -``` - -### Core Components - -The VectorFS comprises several key components, each playing a vital role in the system's functionality: - -- **VectorFS**: The central struct that wraps all functionality related to the Vector File System. It maintains a map of `VectorFSInternals` for all profiles on the node, handles the database interactions, and manages permissions and access controls. This is the main struct you will use to interface with the VectorFS. - -- **VectorFSInternals**: A struct that contains the internal data + auxillary metadata of the VectorFS for a specific profile, including permissions, supported embedding models, and everything else. - -- **VectorFSDB**: The database layer for the VectorFS, responsible for persisting the file system's state, including profiles, permissions, and file entries. - -### Interacting with VectorFS - -To interact with the VectorFS, two extra structs of note are required which deal with all permissioning in a streamlined manner: `VFSReader` and `VFSWriter`. - -- **VFSReader**: A struct representing read access rights to the VectorFS under a specific profile and specific path. A `VFSReader` instance is successfully created if permission validation checks pass, allowing for read operations at the path supplied when creating the VFSReader. - -- **VFSWriter**: Similar to `VFSReader`, but for write operations. A `VFSWriter` instance grants the ability to perform write actions under a specific profile and specific path, following successful permission validation. - -Once you have created a Reader you can use the following methods on the VectorFS struct for retrieval from the file system: - -- `retrieve_fs_path_simplified_json(&mut self, reader: &VFSReader) -> Result`: Retrieves a simplified JSON String representation of the FSEntry at the reader's path in the VectorFS. (To sent a summary of a profile's whole FS to frontends, target root `/` with this endpoint) -- `retrieve_vector_resource(reader: &VFSReader) -> Result`: Attempts to retrieve a VectorResource from inside an FSItem at the path specified in reader. -- `vector_search_fs_item(reader: &VFSReader, query: Embedding, num_of_results: u64) -> Result, VectorFSError>`: Performs a vector search into the VectorFS starting at the reader's path, returning the most similar FSItems (which can be converted via `.to_json_simplified()` before passing to frontends). -- And more - -Once you have created a Writer, you can use the following methods on the VectorFS struct: - -- `create_new_folder(writer: &VFSWriter, new_folder_name: &str) -> Result`: Creates a new FSFolder at the writer's path. - -- `save_vector_resource_in_folder(writer: &VFSWriter, resource: BaseVectorResource, source_file_map: Option, distribution_origin: Option) -> Result`: Saves a Vector Resource and optional SourceFileMap into an FSItem, underneath the FSFolder at the writer's path. If an FSItem with the same name (as the VR) already exists underneath the current path, then it updates (overwrites) it. This method does not support saving into the VecFS root. - -- `copy_folder(writer: &VFSWriter, destination_path: VRPath) -> Result`: Copies the FSFolder from the writer's path into being held underneath the destination_path. - -- `copy_item(writer: &VFSWriter, destination_path: VRPath) -> Result`: Copies the FSItem from the writer's path into being held underneath the destination_path. This method does not support copying into the VecFS root. - -- `move_item(writer: &VFSWriter, destination_path: VRPath) -> Result`: Moves the FSItem from the writer's path into being held underneath the destination_path. This method does not support moving into the VecFS root. - -- `move_folder(writer: &VFSWriter, destination_path: VRPath) -> Result`: Moves the FSFolder from the writer's path into being held underneath the destination_path. This method supports moving into the VecFS root. - -- And more - -#### Workflow - -1. **Initialization**: Upon the Shinkai Node's startup, the VectorFS is initialized, setting up the necessary structures for all profiles based on the node's configuration. - -2. **Creating Readers and Writers**: Before performing any operations on the VectorFS, a valid `VFSReader` or `VFSWriter` must be created. This involves validating the requester_name has permissions for the desired action (read or write) at the specified path (when user is interacting through frontends, then requester_name should be specified to be the user's profile). - -3. **Performing Operations**: With a valid `VFSReader` or `VFSWriter`, various operations can be performed on the VectorFS, such as retrieving file entries, writing data, etc. - -## Example Usage Inside The Node - -#### Creating a Folder - -Assuming that we are in the node and have access to the initialized VectorFS (which is set accessible as a field under the `Node` struct ) we can create a folder in root as such: - -```rust - let path = VRPath::new(); - let writer = vector_fs - .new_writer(requester_name, path.clone(), profile_name) - .unwrap(); - let folder_name = "first_folder"; - let folder = vector_fs.create_new_folder(&writer, folder_name.clone()).unwrap(); - // And the json can be sent back to the frontend to show all details of the new folder - let folder_json = folder.to_json_simplified().unwrap(); -``` - -#### Saving A Vector Resource Into An FSItem - -Once a folder is created, we can save a BaseVectorResource (ie. One that was generated in the local scope of a job) into as an FSItem in the folder: - -```rust - let folder_path = path.push_cloned(folder_name); - let writer = vector_fs - .new_writer(requester_name, folder_path.clone(), profile_name) - .unwrap(); - let item = vector_fs - .save_vector_resource_in_folder( - &writer, - resource.clone(), - None, - None, - ) - .unwrap(); - - // And the json can be sent back to the frontend to show all details of the new item - let item_json = item.to_json_simplified().unwrap(); -``` - -#### Reading The Whole VectorFS As Json - -From there, the whole VectorFS of the profile can be retrieved as a simplified JSON representation for the frontend to visualize via: - -```rust - let reader = vector_fs.new_reader(requester_name, VRPath::root(), profile_name).unwrap(); - let json = vector_fs.retrieve_fs_path_simplified_json(&reader).unwrap(); -``` - -#### Performing Vector Searches On The VectorFS - -You can also perform a Vector Search starting from the root (or any path which is a FSFolder) of the VectorFS: - -```rust - let reader = vector_fs.new_reader(requester_name, VRPath::root(), profile_name).unwrap(); - let query_string = "Who is building Shinkai?".to_string(); - let query_embedding = vector_fs - .generate_query_embedding_using_reader(query_string, &reader) - .await - .unwrap(); - - // If you just want to return the simplified json representation - let items = vector_fs.vector_search_fs_item(&reader, query_embedding, 5).unwrap(); - let first_item_json = items[0].to_json_simplified().unwrap(); - - - // If you want to return the actual VectorResource encoded as JSON (which the encoding stored in .vrkai files) - let resources = vector_fs.vector_search_vector_resource(&reader, query_embedding, 5).unwrap(); - let resource_json = items[0].to_json().unwrap(); -``` diff --git a/shinkai-bin/shinkai-node/Cargo.toml b/shinkai-bin/shinkai-node/Cargo.toml index 5ee28b18f..88faa7dcf 100644 --- a/shinkai-bin/shinkai-node/Cargo.toml +++ b/shinkai-bin/shinkai-node/Cargo.toml @@ -13,7 +13,7 @@ shinkai_tools_runner = { workspace = true, features = ["built-in-tools"] } [features] default = [] console = ["console-subscriber"] -static-pdf-parser = ["shinkai_vector_resources/static-pdf-parser"] +# static-pdf-parser = ["shinkai_vector_resources/static-pdf-parser"] [lib] doctest = false @@ -49,13 +49,13 @@ keyphrases = { workspace = true } shinkai_message_primitives = { workspace = true } shinkai_crypto_identities = { workspace = true } shinkai_job_queue_manager = { workspace = true } -shinkai_vector_resources = { workspace = true } shinkai_tools_primitives = { workspace = true } shinkai_tcp_relayer = { workspace = true } -shinkai_vector_fs = { workspace = true } shinkai_http_api = { workspace = true } shinkai_sqlite = { workspace = true } shinkai_sheet = { workspace = true } +shinkai_embedding = { workspace = true } +shinkai_fs = { workspace = true } # shinkai_baml = { workspace = true } bincode = { workspace = true } qrcode = "0.12" diff --git a/shinkai-bin/shinkai-node/src/cron_tasks/cron_manager.rs b/shinkai-bin/shinkai-node/src/cron_tasks/cron_manager.rs index 3a1c38716..e8688522c 100644 --- a/shinkai-bin/shinkai-node/src/cron_tasks/cron_manager.rs +++ b/shinkai-bin/shinkai-node/src/cron_tasks/cron_manager.rs @@ -612,19 +612,20 @@ impl CronManager { #[cfg(test)] mod tests { use super::*; - use chrono::{Timelike, Utc}; + use chrono::Timelike; use shinkai_message_primitives::schemas::crontab::CronTaskAction; fn create_test_cron_task(cron: &str) -> CronTask { let job_message = JobMessage { job_id: "job_id".to_string(), content: "message".to_string(), - files_inbox: "".to_string(), parent: None, sheet_job_data: None, callback: None, metadata: None, tool_key: None, + fs_files_paths: vec![], + job_filenames: vec![], }; CronTask { diff --git a/shinkai-bin/shinkai-node/src/llm_provider/error.rs b/shinkai-bin/shinkai-node/src/llm_provider/error.rs index 5b26facbf..5456b4bcf 100644 --- a/shinkai-bin/shinkai-node/src/llm_provider/error.rs +++ b/shinkai-bin/shinkai-node/src/llm_provider/error.rs @@ -1,13 +1,12 @@ use crate::managers::model_capabilities_manager::ModelCapabilitiesManagerError; use anyhow::Error as AnyhowError; +use shinkai_fs::shinkai_fs_error::ShinkaiFsError; use shinkai_message_primitives::{ schemas::{inbox_name::InboxNameError, prompts::PromptError, shinkai_name::ShinkaiNameError}, shinkai_message::shinkai_message_error::ShinkaiMessageError, }; use shinkai_sqlite::errors::SqliteManagerError; use shinkai_tools_primitives::tools::{error::ToolError, rust_tools::RustToolError}; -use shinkai_vector_fs::vector_fs::vector_fs_error::VectorFSError; -use shinkai_vector_resources::resource_errors::VRError; use std::fmt; use tokio::task::JoinError; @@ -27,13 +26,11 @@ pub enum LLMProviderError { MessageTypeParseFailed, IO(String), ShinkaiDB(SqliteManagerError), - VectorFS(VectorFSError), ShinkaiNameError(ShinkaiNameError), LLMProviderNotFound, ContentParseFailed, InferenceJSONResponseMissingField(String), JSONSerializationError(String), - VectorResource(VRError), InvalidSubidentity(ShinkaiNameError), InvalidProfileSubidentity(String), SerdeError(serde_json::Error), @@ -86,6 +83,7 @@ pub enum LLMProviderError { ToolSearchError(String), AgentNotFound(String), MessageTooLargeForLLM { max_tokens: usize, used_tokens: usize }, + SomeError(String), } impl fmt::Display for LLMProviderError { @@ -116,7 +114,6 @@ impl fmt::Display for LLMProviderError { LLMProviderError::MessageTypeParseFailed => write!(f, "Could not parse message type"), LLMProviderError::IO(err) => write!(f, "IO error: {}", err), LLMProviderError::ShinkaiDB(err) => write!(f, "Shinkai DB error: {}", err), - LLMProviderError::VectorFS(err) => write!(f, "VectorFS error: {}", err), LLMProviderError::LLMProviderNotFound => write!(f, "Agent not found"), LLMProviderError::ContentParseFailed => write!(f, "Failed to parse content"), LLMProviderError::ShinkaiNameError(err) => write!(f, "ShinkaiName error: {}", err), @@ -124,7 +121,6 @@ impl fmt::Display for LLMProviderError { write!(f, "Response from LLM does not include needed key/field: {}", s) } LLMProviderError::JSONSerializationError(s) => write!(f, "JSON Serialization error: {}", s), - LLMProviderError::VectorResource(err) => write!(f, "VectorResource error: {}", err), LLMProviderError::InvalidSubidentity(err) => write!(f, "Invalid subidentity: {}", err), LLMProviderError::InvalidProfileSubidentity(s) => write!(f, "Invalid profile subidentity: {}", s), LLMProviderError::SerdeError(err) => write!(f, "Serde error: {}", err), @@ -178,7 +174,8 @@ impl fmt::Display for LLMProviderError { LLMProviderError::AgentNotFound(s) => write!(f, "Agent not found: {}", s), LLMProviderError::MessageTooLargeForLLM { max_tokens, used_tokens } => { write!(f, "Message too large for LLM: Used {} tokens, but the maximum allowed is {}.", used_tokens, max_tokens) - } + }, + LLMProviderError::SomeError(s) => write!(f, "{}", s), } } } @@ -201,13 +198,11 @@ impl LLMProviderError { LLMProviderError::MessageTypeParseFailed => "MessageTypeParseFailed", LLMProviderError::IO(_) => "IO", LLMProviderError::ShinkaiDB(_) => "ShinkaiDB", - LLMProviderError::VectorFS(_) => "VectorFS", LLMProviderError::ShinkaiNameError(_) => "ShinkaiNameError", LLMProviderError::LLMProviderNotFound => "LLMProviderNotFound", LLMProviderError::ContentParseFailed => "ContentParseFailed", LLMProviderError::InferenceJSONResponseMissingField(_) => "InferenceJSONResponseMissingField", LLMProviderError::JSONSerializationError(_) => "JSONSerializationError", - LLMProviderError::VectorResource(_) => "VectorResource", LLMProviderError::InvalidSubidentity(_) => "InvalidSubidentity", LLMProviderError::InvalidProfileSubidentity(_) => "InvalidProfileSubidentity", LLMProviderError::SerdeError(_) => "SerdeError", @@ -260,6 +255,7 @@ impl LLMProviderError { LLMProviderError::ToolSearchError(_) => "ToolSearchError", LLMProviderError::AgentNotFound(_) => "AgentNotFound", LLMProviderError::MessageTooLargeForLLM { .. } => "MessageTooLargeForLLM", + LLMProviderError::SomeError(_) => "SomeError", }; format!("Error {} with message: {}", error_name, self) @@ -313,12 +309,6 @@ impl From for LLMProviderError { } } -impl From for LLMProviderError { - fn from(error: VRError) -> Self { - LLMProviderError::VectorResource(error) - } -} - impl From for LLMProviderError { fn from(err: JoinError) -> LLMProviderError { LLMProviderError::TaskJoinError(err.to_string()) @@ -343,12 +333,6 @@ impl From for LLMProviderError { } } -impl From for LLMProviderError { - fn from(err: VectorFSError) -> LLMProviderError { - LLMProviderError::VectorFS(err) - } -} - impl From for LLMProviderError { fn from(err: String) -> LLMProviderError { LLMProviderError::WorkflowExecutionError(err) @@ -375,3 +359,9 @@ impl From for LLMProviderError { } } } + +impl From for LLMProviderError { + fn from(err: ShinkaiFsError) -> LLMProviderError { + LLMProviderError::IO(err.to_string()) + } +} diff --git a/shinkai-bin/shinkai-node/src/llm_provider/execution/chains/generic_chain/generic_inference_chain.rs b/shinkai-bin/shinkai-node/src/llm_provider/execution/chains/generic_chain/generic_inference_chain.rs index 2060ca944..556f106c4 100644 --- a/shinkai-bin/shinkai-node/src/llm_provider/execution/chains/generic_chain/generic_inference_chain.rs +++ b/shinkai-bin/shinkai-node/src/llm_provider/execution/chains/generic_chain/generic_inference_chain.rs @@ -4,6 +4,7 @@ use crate::llm_provider::execution::chains::inference_chain_trait::{ }; use crate::llm_provider::execution::prompts::general_prompts::JobPromptGenerator; use crate::llm_provider::execution::user_message_parser::ParsedUserMessage; +use crate::llm_provider::job_callback_manager::JobCallbackManager; use crate::llm_provider::job_manager::JobManager; use crate::llm_provider::llm_stopper::LLMStopper; use crate::managers::model_capabilities_manager::ModelCapabilitiesManager; @@ -11,26 +12,28 @@ use crate::managers::sheet_manager::SheetManager; use crate::managers::tool_router::{ToolCallFunctionResponse, ToolRouter}; use crate::network::agent_payments_manager::external_agent_offerings_manager::ExtAgentOfferingsManager; use crate::network::agent_payments_manager::my_agent_offerings_manager::MyAgentOfferingsManager; + use crate::utils::environment::{fetch_node_environment, NodeEnvironment}; use async_trait::async_trait; +use shinkai_embedding::embedding_generator::RemoteEmbeddingGenerator; use shinkai_message_primitives::schemas::inbox_name::InboxName; use shinkai_message_primitives::schemas::job::{Job, JobLike}; use shinkai_message_primitives::schemas::llm_providers::common_agent_llm_provider::ProviderOrAgent; +use shinkai_message_primitives::schemas::shinkai_fs::ShinkaiFileChunkCollection; use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; use shinkai_message_primitives::schemas::ws_types::{ ToolMetadata, ToolStatus, ToolStatusType, WSMessageType, WSUpdateHandler, WidgetMetadata, }; use shinkai_message_primitives::shinkai_message::shinkai_message_schemas::WSTopic; use shinkai_message_primitives::shinkai_utils::shinkai_logging::{shinkai_log, ShinkaiLogLevel, ShinkaiLogOption}; +use shinkai_message_primitives::shinkai_utils::shinkai_path::ShinkaiPath; use shinkai_sqlite::SqliteManager; -use shinkai_vector_fs::vector_fs::vector_fs::VectorFS; -use shinkai_vector_resources::embedding_generator::RemoteEmbeddingGenerator; -use shinkai_vector_resources::vector_resource::RetrievedNode; + use std::fmt; use std::result::Result::Ok; use std::time::Instant; use std::{collections::HashMap, sync::Arc}; -use tokio::sync::{Mutex, RwLock}; +use tokio::sync::Mutex; #[derive(Clone)] pub struct GenericInferenceChain { @@ -65,14 +68,14 @@ impl InferenceChain for GenericInferenceChain { async fn run_chain(&mut self) -> Result { let response = GenericInferenceChain::start_chain( self.context.db.clone(), - self.context.vector_fs.clone(), self.context.full_job.clone(), self.context.user_message.original_user_message_string.to_string(), self.context.user_tool_selected.clone(), + self.context.fs_files_paths.clone(), + self.context.job_filenames.clone(), self.context.message_hash_id.clone(), self.context.image_files.clone(), self.context.llm_provider.clone(), - self.context.execution_context.clone(), self.context.generator.clone(), self.context.user_profile.clone(), self.context.max_iterations, @@ -82,6 +85,7 @@ impl InferenceChain for GenericInferenceChain { self.context.sheet_manager.clone(), self.context.my_agent_payments_manager.clone(), self.context.ext_agent_payments_manager.clone(), + self.context.job_callback_manager.clone(), // self.context.sqlite_logger.clone(), self.context.llm_stopper.clone(), fetch_node_environment(), @@ -105,14 +109,14 @@ impl GenericInferenceChain { #[allow(clippy::too_many_arguments)] pub async fn start_chain( db: Arc, - vector_fs: Arc, full_job: Job, user_message: String, user_tool_selected: Option, + fs_files_paths: Vec, + job_filenames: Vec, message_hash_id: Option, image_files: HashMap, llm_provider: ProviderOrAgent, - execution_context: HashMap, generator: RemoteEmbeddingGenerator, user_profile: ShinkaiName, max_iterations: u64, @@ -122,6 +126,7 @@ impl GenericInferenceChain { sheet_manager: Option>>, my_agent_payments_manager: Option>>, ext_agent_payments_manager: Option>>, + job_callback_manager: Option>>, // sqlite_logger: Option>, llm_stopper: Arc, node_env: NodeEnvironment, @@ -150,23 +155,39 @@ impl GenericInferenceChain { */ // 1) Vector search for knowledge if the scope isn't empty - let scope_is_empty = full_job.scope_with_files().unwrap().is_empty(); - let mut ret_nodes: Vec = vec![]; - let mut summary_node_text = None; - if !scope_is_empty { - let (ret, summary) = JobManager::keyword_chained_job_scope_vector_search( + let scope_is_empty = full_job.scope().is_empty(); + let mut ret_nodes: ShinkaiFileChunkCollection = ShinkaiFileChunkCollection { + chunks: vec![], + paths: None, + }; + + // Merge agent scope fs_files_paths if llm_provider is an agent + let mut merged_fs_files_paths = fs_files_paths.clone(); + let mut merged_fs_folder_paths = Vec::new(); + if let ProviderOrAgent::Agent(agent) = &llm_provider { + merged_fs_files_paths.extend(agent.scope.vector_fs_items.clone()); + merged_fs_folder_paths.extend(agent.scope.vector_fs_folders.clone()); + } + + if !scope_is_empty + || !merged_fs_files_paths.is_empty() + || !merged_fs_folder_paths.is_empty() + || !job_filenames.is_empty() + { + let ret = JobManager::search_for_chunks_in_resources( + merged_fs_files_paths, + merged_fs_folder_paths, + job_filenames.clone(), + full_job.job_id.clone(), + full_job.scope(), db.clone(), - vector_fs.clone(), - full_job.scope_with_files().unwrap(), user_message.clone(), - &user_profile, - generator.clone(), 20, max_tokens_in_prompt, + generator.clone(), ) .await?; ret_nodes = ret; - summary_node_text = summary; } // 2) Vector search for tooling / workflows if the workflow / tooling scope isn't empty @@ -329,7 +350,7 @@ impl GenericInferenceChain { user_message.clone(), image_files.clone(), ret_nodes.clone(), - summary_node_text.clone(), + None, Some(full_job.step_history.clone()), tools.clone(), None, @@ -379,14 +400,14 @@ impl GenericInferenceChain { let image_files = HashMap::new(); let context = InferenceChainContext::new( db.clone(), - vector_fs.clone(), full_job.clone(), parsed_message, None, + fs_files_paths.clone(), + job_filenames.clone(), message_hash_id.clone(), image_files.clone(), llm_provider.clone(), - execution_context.clone(), generator.clone(), user_profile.clone(), max_iterations, @@ -396,6 +417,7 @@ impl GenericInferenceChain { sheet_manager.clone(), my_agent_payments_manager.clone(), ext_agent_payments_manager.clone(), + job_callback_manager.clone(), // sqlite_logger.clone(), llm_stopper.clone(), ); @@ -452,7 +474,7 @@ impl GenericInferenceChain { user_message.clone(), image_files.clone(), ret_nodes.clone(), - summary_node_text.clone(), + None, Some(full_job.step_history.clone()), tools.clone(), Some(function_response), @@ -467,7 +489,6 @@ impl GenericInferenceChain { response.response_string, response.tps.map(|tps| tps.to_string()), answer_duration_ms, - execution_context.clone(), Some(tool_calls_history.clone()), ); diff --git a/shinkai-bin/shinkai-node/src/llm_provider/execution/chains/generic_chain/generic_prompts.rs b/shinkai-bin/shinkai-node/src/llm_provider/execution/chains/generic_chain/generic_prompts.rs index a5677ecfb..47caffc4d 100644 --- a/shinkai-bin/shinkai-node/src/llm_provider/execution/chains/generic_chain/generic_prompts.rs +++ b/shinkai-bin/shinkai-node/src/llm_provider/execution/chains/generic_chain/generic_prompts.rs @@ -1,16 +1,20 @@ +use serde_json::json; use std::collections::HashMap; use crate::llm_provider::execution::prompts::general_prompts::JobPromptGenerator; use crate::managers::tool_router::ToolCallFunctionResponse; + use crate::network::v2_api::api_v2_commands_app_files::get_app_folder_path; use crate::network::Node; +use crate::tools::tool_implementation::native_tools::sql_processor::get_current_tables; use crate::utils::environment::NodeEnvironment; -use serde_json::json; -use shinkai_message_primitives::schemas::job::JobStepResult; use shinkai_message_primitives::schemas::prompts::Prompt; +use shinkai_message_primitives::schemas::shinkai_fs::ShinkaiFileChunkCollection; use shinkai_message_primitives::schemas::subprompts::SubPromptType; +use shinkai_message_primitives::shinkai_message::shinkai_message::ShinkaiMessage; use shinkai_tools_primitives::tools::shinkai_tool::ShinkaiTool; -use shinkai_vector_resources::vector_resource::RetrievedNode; +use std::sync::mpsc; +use tokio::runtime::Runtime; impl JobPromptGenerator { /// A basic generic prompt generator @@ -21,9 +25,9 @@ impl JobPromptGenerator { custom_user_prompt: Option, user_message: String, image_files: HashMap, - ret_nodes: Vec, + ret_nodes: ShinkaiFileChunkCollection, _summary_text: Option, - job_step_history: Option>, + job_step_history: Option>, tools: Vec, function_call: Option, job_id: String, @@ -41,7 +45,6 @@ impl JobPromptGenerator { let has_ret_nodes = !ret_nodes.is_empty(); // Add previous messages - // TODO: this should be full messages with assets and not just strings if let Some(step_history) = job_step_history { prompt.add_step_history(step_history, 97); } @@ -51,13 +54,42 @@ impl JobPromptGenerator { let mut priority = 98; for (i, tool) in tools.iter().enumerate() { if let Ok(tool_content) = tool.json_function_call_format() { + match tool_content.get("function") { + Some(function) => { + let tool_router_key = function["tool_router_key"].as_str().unwrap_or(""); + if tool_router_key == "local:::rust_toolkit:::shinkai_sqlite_query_executor" { + let (tx, rx) = mpsc::channel(); + let job_id_clone = job_id.clone(); + // Spawn the async task on a runtime + std::thread::spawn(move || { + let runtime = Runtime::new().unwrap(); + let result = runtime.block_on(get_current_tables(job_id_clone)); + tx.send(result).unwrap(); + }); + // Wait for the result + let current_tables = rx.recv().unwrap(); + if let Ok(current_tables) = current_tables { + prompt.add_content( + format!( + "\n{}\n\n", + current_tables.join("; \n") + ), + SubPromptType::ExtraContext, + 97, + ); + } + } + } + None => {} + } + prompt.add_tool(tool_content, SubPromptType::AvailableTool, priority); } if (i + 1) % 2 == 0 { priority = priority.saturating_sub(1); } } - let folder = get_app_folder_path(node_env, job_id); + let folder = get_app_folder_path(node_env, job_id.clone()); let current_files = Node::v2_api_list_app_files_internal(folder.clone(), true); if let Ok(current_files) = current_files { if !current_files.is_empty() { @@ -76,9 +108,9 @@ impl JobPromptGenerator { if has_ret_nodes && !user_message.is_empty() { prompt.add_content("--- start --- \n".to_string(), SubPromptType::ExtraContext, 97); } - for node in ret_nodes { - prompt.add_ret_node_content(node, SubPromptType::ExtraContext, 96); - } + + prompt.add_ret_node_content(ret_nodes, SubPromptType::ExtraContext, 96); + if has_ret_nodes && !user_message.is_empty() { prompt.add_content("--- end ---".to_string(), SubPromptType::ExtraContext, 97); } diff --git a/shinkai-bin/shinkai-node/src/llm_provider/execution/chains/inference_chain_router.rs b/shinkai-bin/shinkai-node/src/llm_provider/execution/chains/inference_chain_router.rs index ae52d4ea2..748fa340c 100644 --- a/shinkai-bin/shinkai-node/src/llm_provider/execution/chains/inference_chain_router.rs +++ b/shinkai-bin/shinkai-node/src/llm_provider/execution/chains/inference_chain_router.rs @@ -3,6 +3,7 @@ use super::inference_chain_trait::{InferenceChain, InferenceChainContext, Infere use super::sheet_ui_chain::sheet_ui_inference_chain::SheetUIInferenceChain; use crate::llm_provider::error::LLMProviderError; use crate::llm_provider::execution::user_message_parser::ParsedUserMessage; +use crate::llm_provider::job_callback_manager::JobCallbackManager; use crate::llm_provider::job_manager::JobManager; use crate::llm_provider::llm_stopper::LLMStopper; use crate::managers::model_capabilities_manager::ModelCapabilitiesManager; @@ -10,14 +11,13 @@ use crate::managers::sheet_manager::SheetManager; use crate::managers::tool_router::ToolRouter; use crate::network::agent_payments_manager::external_agent_offerings_manager::ExtAgentOfferingsManager; use crate::network::agent_payments_manager::my_agent_offerings_manager::MyAgentOfferingsManager; +use shinkai_embedding::embedding_generator::RemoteEmbeddingGenerator; use shinkai_message_primitives::schemas::job::Job; use shinkai_message_primitives::schemas::llm_providers::common_agent_llm_provider::ProviderOrAgent; use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; use shinkai_message_primitives::schemas::ws_types::WSUpdateHandler; use shinkai_message_primitives::shinkai_message::shinkai_message_schemas::{AssociatedUI, JobMessage}; use shinkai_sqlite::SqliteManager; -use shinkai_vector_fs::vector_fs::vector_fs::VectorFS; -use shinkai_vector_resources::embedding_generator::RemoteEmbeddingGenerator; use std::{collections::HashMap, sync::Arc}; use tokio::sync::Mutex; @@ -28,13 +28,11 @@ impl JobManager { #[allow(clippy::too_many_arguments)] pub async fn inference_chain_router( db: Arc, - vector_fs: Arc, llm_provider_found: Option, full_job: Job, job_message: JobMessage, message_hash_id: Option, image_files: HashMap, - prev_execution_context: HashMap, generator: RemoteEmbeddingGenerator, user_profile: ShinkaiName, ws_manager_trait: Option>>, @@ -42,6 +40,7 @@ impl JobManager { sheet_manager: Option>>, my_agent_payments_manager: Option>>, ext_agent_payments_manager: Option>>, + job_callback_manager: Arc>, // sqlite_logger: Option>, llm_stopper: Arc, ) -> Result { @@ -66,14 +65,14 @@ impl JobManager { // Create the inference chain context let chain_context = InferenceChainContext::new( db, - vector_fs, full_job.clone(), parsed_user_message, job_message.tool_key, + job_message.fs_files_paths, + job_message.job_filenames, message_hash_id, image_files, llm_provider, - prev_execution_context, generator, user_profile, 3, @@ -83,6 +82,7 @@ impl JobManager { sheet_manager.clone(), my_agent_payments_manager.clone(), ext_agent_payments_manager.clone(), + Some(job_callback_manager.clone()), // sqlite_logger.clone(), llm_stopper.clone(), ); diff --git a/shinkai-bin/shinkai-node/src/llm_provider/execution/chains/inference_chain_trait.rs b/shinkai-bin/shinkai-node/src/llm_provider/execution/chains/inference_chain_trait.rs index bd87c3976..eae8ae357 100644 --- a/shinkai-bin/shinkai-node/src/llm_provider/execution/chains/inference_chain_trait.rs +++ b/shinkai-bin/shinkai-node/src/llm_provider/execution/chains/inference_chain_trait.rs @@ -1,5 +1,6 @@ use crate::llm_provider::error::LLMProviderError; use crate::llm_provider::execution::user_message_parser::ParsedUserMessage; +use crate::llm_provider::job_callback_manager::JobCallbackManager; use crate::llm_provider::llm_stopper::LLMStopper; use crate::managers::sheet_manager::SheetManager; use crate::managers::tool_router::ToolRouter; @@ -9,18 +10,18 @@ use async_trait::async_trait; use serde::{Deserialize, Serialize}; use serde_json::Value as JsonValue; +use shinkai_embedding::embedding_generator::RemoteEmbeddingGenerator; use shinkai_message_primitives::schemas::job::Job; use shinkai_message_primitives::schemas::llm_providers::common_agent_llm_provider::ProviderOrAgent; use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; use shinkai_message_primitives::schemas::ws_types::WSUpdateHandler; use shinkai_message_primitives::shinkai_message::shinkai_message_schemas::FunctionCallMetadata; +use shinkai_message_primitives::shinkai_utils::shinkai_path::ShinkaiPath; use shinkai_sqlite::SqliteManager; -// use shinkai_sqlite::SqliteLogger; -use shinkai_vector_fs::vector_fs::vector_fs::VectorFS; -use shinkai_vector_resources::embedding_generator::RemoteEmbeddingGenerator; + use std::fmt; use std::{collections::HashMap, sync::Arc}; -use tokio::sync::{Mutex, RwLock}; +use tokio::sync::Mutex; /// Trait that abstracts top level functionality between the inference chains. This allows /// the inference chain router to work with them all easily. @@ -59,13 +60,11 @@ pub trait InferenceChainContextTrait: Send + Sync { fn update_message(&mut self, new_message: ParsedUserMessage); fn db(&self) -> Arc; - fn vector_fs(&self) -> Arc; fn full_job(&self) -> &Job; fn user_message(&self) -> &ParsedUserMessage; fn message_hash_id(&self) -> Option; fn image_files(&self) -> &HashMap; fn agent(&self) -> &ProviderOrAgent; - fn execution_context(&self) -> &HashMap; fn generator(&self) -> &RemoteEmbeddingGenerator; fn user_profile(&self) -> &ShinkaiName; fn max_iterations(&self) -> u64; @@ -77,6 +76,7 @@ pub trait InferenceChainContextTrait: Send + Sync { fn sheet_manager(&self) -> Option>>; fn my_agent_payments_manager(&self) -> Option>>; fn ext_agent_payments_manager(&self) -> Option>>; + fn job_callback_manager(&self) -> Option>>; // fn sqlite_logger(&self) -> Option>; fn llm_stopper(&self) -> Arc; @@ -109,11 +109,7 @@ impl InferenceChainContextTrait for InferenceChainContext { fn db(&self) -> Arc { Arc::clone(&self.db) } - - fn vector_fs(&self) -> Arc { - Arc::clone(&self.vector_fs) - } - + fn full_job(&self) -> &Job { &self.full_job } @@ -134,10 +130,6 @@ impl InferenceChainContextTrait for InferenceChainContext { &self.llm_provider } - fn execution_context(&self) -> &HashMap { - &self.execution_context - } - fn generator(&self) -> &RemoteEmbeddingGenerator { &self.generator } @@ -182,6 +174,10 @@ impl InferenceChainContextTrait for InferenceChainContext { self.ext_agent_payments_manager.clone() } + fn job_callback_manager(&self) -> Option>> { + self.job_callback_manager.clone() + } + // fn sqlite_logger(&self) -> Option> { // self.sqlite_logger.clone() // } @@ -200,15 +196,15 @@ impl InferenceChainContextTrait for InferenceChainContext { #[derive(Clone)] pub struct InferenceChainContext { pub db: Arc, - pub vector_fs: Arc, pub full_job: Job, pub user_message: ParsedUserMessage, pub user_tool_selected: Option, + pub fs_files_paths: Vec, + pub job_filenames: Vec, pub message_hash_id: Option, pub image_files: HashMap, pub llm_provider: ProviderOrAgent, /// Job's execution context, used to store potentially relevant data across job steps. - pub execution_context: HashMap, pub generator: RemoteEmbeddingGenerator, pub user_profile: ShinkaiName, pub max_iterations: u64, @@ -220,6 +216,7 @@ pub struct InferenceChainContext { pub sheet_manager: Option>>, pub my_agent_payments_manager: Option>>, pub ext_agent_payments_manager: Option>>, + pub job_callback_manager: Option>>, // pub sqlite_logger: Option>, pub llm_stopper: Arc, } @@ -228,14 +225,14 @@ impl InferenceChainContext { #[allow(clippy::too_many_arguments)] pub fn new( db: Arc, - vector_fs: Arc, full_job: Job, user_message: ParsedUserMessage, user_tool_selected: Option, + fs_files_paths: Vec, + job_filenames: Vec, message_hash_id: Option, image_files: HashMap, llm_provider: ProviderOrAgent, - execution_context: HashMap, generator: RemoteEmbeddingGenerator, user_profile: ShinkaiName, max_iterations: u64, @@ -245,19 +242,20 @@ impl InferenceChainContext { sheet_manager: Option>>, my_agent_payments_manager: Option>>, ext_agent_payments_manager: Option>>, + job_callback_manager: Option>>, // sqlite_logger: Option>, llm_stopper: Arc, ) -> Self { Self { db, - vector_fs, full_job, user_message, user_tool_selected, + fs_files_paths, + job_filenames, message_hash_id, image_files, llm_provider, - execution_context, generator, user_profile, max_iterations, @@ -269,6 +267,7 @@ impl InferenceChainContext { sheet_manager, my_agent_payments_manager, ext_agent_payments_manager, + job_callback_manager, // sqlite_logger, llm_stopper, } @@ -289,14 +288,14 @@ impl fmt::Debug for InferenceChainContext { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_struct("InferenceChainContext") .field("db", &self.db) - .field("vector_fs", &self.vector_fs) .field("full_job", &self.full_job) .field("user_message", &self.user_message) .field("user_tool_selected", &self.user_tool_selected) + .field("fs_files_paths", &self.fs_files_paths) + .field("job_filenames", &self.job_filenames) .field("message_hash_id", &self.message_hash_id) .field("image_files", &self.image_files.len()) .field("llm_provider", &self.llm_provider) - .field("execution_context", &self.execution_context) .field("generator", &self.generator) .field("user_profile", &self.user_profile) .field("max_iterations", &self.max_iterations) @@ -308,6 +307,7 @@ impl fmt::Debug for InferenceChainContext { .field("sheet_manager", &self.sheet_manager.is_some()) .field("my_agent_payments_manager", &self.my_agent_payments_manager.is_some()) .field("ext_agent_payments_manager", &self.ext_agent_payments_manager.is_some()) + .field("job_callback_manager", &self.job_callback_manager.is_some()) // .field("sqlite_logger", &self.sqlite_logger.is_some()) .finish() } @@ -319,15 +319,13 @@ pub struct InferenceChainResult { pub response: String, pub tps: Option, pub answer_duration: Option, - pub new_job_execution_context: HashMap, pub tool_calls: Option>, } impl InferenceChainResult { - pub fn new(response: String, new_job_execution_context: HashMap) -> Self { + pub fn new(response: String) -> Self { Self { response, - new_job_execution_context, tps: None, answer_duration: None, tool_calls: None, @@ -338,26 +336,16 @@ impl InferenceChainResult { response: String, tps: Option, answer_duration_ms: Option, - new_job_execution_context: HashMap, tool_calls: Option>, ) -> Self { Self { response, tps, answer_duration: answer_duration_ms, - new_job_execution_context, tool_calls, } } - pub fn new_empty_execution_context(response: String) -> Self { - Self::new(response, HashMap::new()) - } - - pub fn new_empty() -> Self { - Self::new_empty_execution_context(String::new()) - } - pub fn tool_calls_metadata(&self) -> Option> { self.tool_calls .as_ref() @@ -430,10 +418,6 @@ impl InferenceChainContextTrait for Box { (**self).db() } - fn vector_fs(&self) -> Arc { - (**self).vector_fs() - } - fn full_job(&self) -> &Job { (**self).full_job() } @@ -454,10 +438,6 @@ impl InferenceChainContextTrait for Box { (**self).agent() } - fn execution_context(&self) -> &HashMap { - (**self).execution_context() - } - fn generator(&self) -> &RemoteEmbeddingGenerator { (**self).generator() } @@ -502,6 +482,10 @@ impl InferenceChainContextTrait for Box { (**self).ext_agent_payments_manager() } + fn job_callback_manager(&self) -> Option>> { + (**self).job_callback_manager() + } + // fn sqlite_logger(&self) -> Option> { // (**self).sqlite_logger() // } @@ -519,14 +503,12 @@ impl InferenceChainContextTrait for Box { pub struct MockInferenceChainContext { pub user_message: ParsedUserMessage, pub image_files: HashMap, - pub execution_context: HashMap, pub user_profile: ShinkaiName, pub max_iterations: u64, pub iteration_count: u64, pub max_tokens_in_prompt: usize, pub raw_files: RawFiles, pub db: Option>, - pub vector_fs: Option>, pub my_agent_payments_manager: Option>>, pub ext_agent_payments_manager: Option>>, pub llm_stopper: Arc, @@ -537,14 +519,12 @@ impl MockInferenceChainContext { #[allow(dead_code)] pub fn new( user_message: ParsedUserMessage, - execution_context: HashMap, user_profile: ShinkaiName, max_iterations: u64, iteration_count: u64, max_tokens_in_prompt: usize, raw_files: Option)>>>, db: Option>, - vector_fs: Option>, my_agent_payments_manager: Option>>, ext_agent_payments_manager: Option>>, llm_stopper: Arc, @@ -552,14 +532,12 @@ impl MockInferenceChainContext { Self { user_message, image_files: HashMap::new(), - execution_context, user_profile, max_iterations, iteration_count, max_tokens_in_prompt, raw_files, db, - vector_fs, my_agent_payments_manager, ext_agent_payments_manager, llm_stopper, @@ -577,14 +555,12 @@ impl Default for MockInferenceChainContext { Self { user_message, image_files: HashMap::new(), - execution_context: HashMap::new(), user_profile, max_iterations: 10, iteration_count: 0, max_tokens_in_prompt: 1000, raw_files: None, db: None, - vector_fs: None, my_agent_payments_manager: None, ext_agent_payments_manager: None, llm_stopper: Arc::new(LLMStopper::new()), @@ -613,10 +589,6 @@ impl InferenceChainContextTrait for MockInferenceChainContext { self.db.clone().expect("DB is not set") } - fn vector_fs(&self) -> Arc { - self.vector_fs.clone().expect("VectorFS is not set") - } - fn full_job(&self) -> &Job { unimplemented!() } @@ -637,10 +609,6 @@ impl InferenceChainContextTrait for MockInferenceChainContext { unimplemented!() } - fn execution_context(&self) -> &HashMap { - &self.execution_context - } - fn generator(&self) -> &RemoteEmbeddingGenerator { unimplemented!() } @@ -685,6 +653,10 @@ impl InferenceChainContextTrait for MockInferenceChainContext { unimplemented!() } + fn job_callback_manager(&self) -> Option>> { + unimplemented!() + } + // fn sqlite_logger(&self) -> Option> { // None // } @@ -703,14 +675,12 @@ impl Clone for MockInferenceChainContext { Self { user_message: self.user_message.clone(), image_files: self.image_files.clone(), - execution_context: self.execution_context.clone(), user_profile: self.user_profile.clone(), max_iterations: self.max_iterations, iteration_count: self.iteration_count, max_tokens_in_prompt: self.max_tokens_in_prompt, raw_files: self.raw_files.clone(), db: self.db.clone(), - vector_fs: self.vector_fs.clone(), my_agent_payments_manager: self.my_agent_payments_manager.clone(), ext_agent_payments_manager: self.ext_agent_payments_manager.clone(), llm_stopper: self.llm_stopper.clone(), diff --git a/shinkai-bin/shinkai-node/src/llm_provider/execution/chains/sheet_ui_chain/sheet_rust_functions.rs b/shinkai-bin/shinkai-node/src/llm_provider/execution/chains/sheet_ui_chain/sheet_rust_functions.rs index 4e508ae77..79ae20746 100644 --- a/shinkai-bin/shinkai-node/src/llm_provider/execution/chains/sheet_ui_chain/sheet_rust_functions.rs +++ b/shinkai-bin/shinkai-node/src/llm_provider/execution/chains/sheet_ui_chain/sheet_rust_functions.rs @@ -607,13 +607,17 @@ mod tests { use futures::Future; use shinkai_message_primitives::schemas::ws_types::WSUpdateHandler; + use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use shinkai_message_primitives::{ schemas::shinkai_name::ShinkaiName, shinkai_message::shinkai_message_schemas::{JobCreationInfo, JobMessage}, }; use shinkai_sqlite::SqliteManager; - use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; - use std::{path::PathBuf, sync::Arc}; + use std::{ + fs, + path::{Path, PathBuf}, + sync::Arc, + }; use tempfile::NamedTempFile; use tokio::sync::{Mutex, RwLock}; diff --git a/shinkai-bin/shinkai-node/src/llm_provider/execution/chains/sheet_ui_chain/sheet_ui_inference_chain.rs b/shinkai-bin/shinkai-node/src/llm_provider/execution/chains/sheet_ui_chain/sheet_ui_inference_chain.rs index 9cb967969..e74c12661 100644 --- a/shinkai-bin/shinkai-node/src/llm_provider/execution/chains/sheet_ui_chain/sheet_ui_inference_chain.rs +++ b/shinkai-bin/shinkai-node/src/llm_provider/execution/chains/sheet_ui_chain/sheet_ui_inference_chain.rs @@ -5,6 +5,7 @@ use crate::llm_provider::execution::chains::inference_chain_trait::{ use crate::llm_provider::execution::chains::sheet_ui_chain::sheet_rust_functions::SheetRustFunctions; use crate::llm_provider::execution::prompts::general_prompts::JobPromptGenerator; use crate::llm_provider::execution::user_message_parser::ParsedUserMessage; +use crate::llm_provider::job_callback_manager::JobCallbackManager; use crate::llm_provider::job_manager::JobManager; use crate::llm_provider::llm_stopper::LLMStopper; use crate::managers::model_capabilities_manager::ModelCapabilitiesManager; @@ -14,22 +15,22 @@ use crate::network::agent_payments_manager::external_agent_offerings_manager::Ex use crate::network::agent_payments_manager::my_agent_offerings_manager::MyAgentOfferingsManager; use crate::utils::environment::{fetch_node_environment, NodeEnvironment}; use async_trait::async_trait; +use shinkai_embedding::embedding_generator::RemoteEmbeddingGenerator; use shinkai_message_primitives::schemas::inbox_name::InboxName; use shinkai_message_primitives::schemas::job::{Job, JobLike}; use shinkai_message_primitives::schemas::llm_providers::common_agent_llm_provider::ProviderOrAgent; +use shinkai_message_primitives::schemas::shinkai_fs::ShinkaiFileChunkCollection; use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; use shinkai_message_primitives::schemas::ws_types::WSUpdateHandler; use shinkai_message_primitives::shinkai_utils::shinkai_logging::{shinkai_log, ShinkaiLogLevel, ShinkaiLogOption}; +use shinkai_message_primitives::shinkai_utils::shinkai_path::ShinkaiPath; use shinkai_sqlite::SqliteManager; -use shinkai_vector_fs::vector_fs::vector_fs::VectorFS; -use shinkai_vector_resources::embedding_generator::RemoteEmbeddingGenerator; -use shinkai_vector_resources::vector_resource::{RetrievedNode, VRPath}; use std::any::Any; use std::collections::HashSet; use std::fmt; use std::result::Result::Ok; use std::{collections::HashMap, sync::Arc}; -use tokio::sync::{Mutex, RwLock}; +use tokio::sync::Mutex; use tokio::task; #[derive(Clone)] @@ -61,13 +62,13 @@ impl InferenceChain for SheetUIInferenceChain { async fn run_chain(&mut self) -> Result { let response = SheetUIInferenceChain::start_chain( self.context.db.clone(), - self.context.vector_fs.clone(), self.context.full_job.clone(), self.context.user_message.original_user_message_string.to_string(), + self.context.fs_files_paths.clone(), + self.context.job_filenames.clone(), self.context.message_hash_id.clone(), self.context.image_files.clone(), self.context.llm_provider.clone(), - self.context.execution_context.clone(), self.context.generator.clone(), self.context.user_profile.clone(), self.context.max_iterations, @@ -78,13 +79,13 @@ impl InferenceChain for SheetUIInferenceChain { self.sheet_id.clone(), self.context.my_agent_payments_manager.clone(), self.context.ext_agent_payments_manager.clone(), + self.context.job_callback_manager.clone(), // self.context.sqlite_logger.clone(), self.context.llm_stopper.clone(), fetch_node_environment(), ) .await?; - let job_execution_context = self.context.execution_context.clone(); - Ok(InferenceChainResult::new(response, job_execution_context)) + Ok(InferenceChainResult::new(response)) } } @@ -106,13 +107,13 @@ impl SheetUIInferenceChain { #[allow(clippy::too_many_arguments)] pub async fn start_chain( db: Arc, - vector_fs: Arc, full_job: Job, user_message: String, + fs_files_paths: Vec, + job_filenames: Vec, message_hash_id: Option, image_files: HashMap, llm_provider: ProviderOrAgent, - execution_context: HashMap, generator: RemoteEmbeddingGenerator, user_profile: ShinkaiName, max_iterations: u64, @@ -123,6 +124,7 @@ impl SheetUIInferenceChain { sheet_id: String, my_agent_payments_manager: Option>>, ext_agent_payments_manager: Option>>, + job_callback_manager: Option>>, // sqlite_logger: Option>, llm_stopper: Arc, node_env: NodeEnvironment, @@ -152,7 +154,7 @@ impl SheetUIInferenceChain { // 1) Vector search for knowledge if the scope isn't empty // Check if the sheet has uploaded files and add them to the job scope let job_scope = if let Some(sheet_manager) = &sheet_manager { - let mut job_scope = full_job.scope_with_files.clone().unwrap(); + let mut job_scope = full_job.scope().clone(); let sheet = { let sheet_manager_guard = sheet_manager.lock().await; @@ -174,42 +176,44 @@ impl SheetUIInferenceChain { job_scope .vector_fs_items .iter() - .any(|fs_item| fs_item.path.format_to_string() == *path) + .any(|fs_item| fs_item.relative_path() == *path) }) .collect(); // Add new FS items to the job scope for file in vr_files { - let vr_path = VRPath::from_string(&file)?; - let reader = vector_fs - .new_reader(user_profile.clone(), vr_path, user_profile.clone()) - .await?; - let fs_item = vector_fs.retrieve_fs_entry(&reader).await?.as_item()?.as_scope_entry(); - job_scope.vector_fs_items.push(fs_item); + let vr_path = ShinkaiPath::from_string(file); + job_scope.vector_fs_items.push(vr_path); } } job_scope } else { - full_job.scope_with_files.clone().unwrap() + full_job.scope().clone() }; let scope_is_empty = job_scope.is_empty(); - let mut ret_nodes: Vec = vec![]; + let mut ret_nodes: ShinkaiFileChunkCollection = ShinkaiFileChunkCollection { + chunks: vec![], + paths: None, + }; + // tODO: remove this let mut summary_node_text = None; if !scope_is_empty { - let (ret, summary) = JobManager::keyword_chained_job_scope_vector_search( - db.clone(), - vector_fs.clone(), + let ret = JobManager::search_for_chunks_in_resources( + fs_files_paths.clone(), + Vec::new(), // fs_folder_paths + job_filenames.clone(), + full_job.job_id.clone(), &job_scope, + db.clone(), user_message.clone(), - &user_profile, - generator.clone(), 20, max_tokens_in_prompt, + generator.clone(), ) .await?; ret_nodes = ret; - summary_node_text = summary; + // summary_node_text = summary; } // 2) Vector search for tooling / workflows if the workflow / tooling scope isn't empty @@ -378,14 +382,14 @@ impl SheetUIInferenceChain { let parsed_message = ParsedUserMessage::new(user_message.clone()); let context = InferenceChainContext::new( db.clone(), - vector_fs.clone(), full_job.clone(), parsed_message, None, // TODO: hook this up + fs_files_paths.clone(), + job_filenames.clone(), message_hash_id.clone(), image_files.clone(), llm_provider.clone(), - execution_context.clone(), generator.clone(), user_profile.clone(), max_iterations, @@ -395,6 +399,7 @@ impl SheetUIInferenceChain { sheet_manager.clone(), my_agent_payments_manager.clone(), ext_agent_payments_manager.clone(), + job_callback_manager.clone(), // sqlite_logger.clone(), llm_stopper.clone(), ); diff --git a/shinkai-bin/shinkai-node/src/llm_provider/execution/job_execution_core.rs b/shinkai-bin/shinkai-node/src/llm_provider/execution/job_execution_core.rs index 9d52fcbd0..2185f33f6 100644 --- a/shinkai-bin/shinkai-node/src/llm_provider/execution/job_execution_core.rs +++ b/shinkai-bin/shinkai-node/src/llm_provider/execution/job_execution_core.rs @@ -2,7 +2,7 @@ use crate::llm_provider::error::LLMProviderError; use crate::llm_provider::job_callback_manager::JobCallbackManager; use crate::llm_provider::job_manager::JobManager; use crate::llm_provider::llm_stopper::LLMStopper; -use crate::llm_provider::parsing_helper::ParsingHelper; + use crate::managers::model_capabilities_manager::{ModelCapabilitiesManager, ModelCapability}; use crate::managers::sheet_manager::SheetManager; use crate::managers::tool_router::ToolRouter; @@ -10,6 +10,8 @@ use crate::network::agent_payments_manager::external_agent_offerings_manager::Ex use crate::network::agent_payments_manager::my_agent_offerings_manager::MyAgentOfferingsManager; use ed25519_dalek::SigningKey; +use shinkai_embedding::embedding_generator::RemoteEmbeddingGenerator; +use shinkai_fs::shinkai_file_manager::ShinkaiFileManager; use shinkai_job_queue_manager::job_queue_manager::{JobForProcessing, JobQueueManager}; use shinkai_message_primitives::schemas::job::{Job, JobLike}; use shinkai_message_primitives::schemas::llm_providers::common_agent_llm_provider::ProviderOrAgent; @@ -17,20 +19,14 @@ use shinkai_message_primitives::schemas::sheet::WorkflowSheetJobData; use shinkai_message_primitives::schemas::tool_router_key::ToolRouterKey; use shinkai_message_primitives::schemas::ws_types::WSUpdateHandler; use shinkai_message_primitives::shinkai_message::shinkai_message_schemas::{CallbackAction, MessageMetadata}; -use shinkai_message_primitives::shinkai_utils::job_scope::{ - LocalScopeVRKaiEntry, LocalScopeVRPackEntry, ScopeEntry, VectorFSFolderScopeEntry, VectorFSItemScopeEntry, -}; use shinkai_message_primitives::shinkai_utils::shinkai_logging::{shinkai_log, ShinkaiLogLevel, ShinkaiLogOption}; +use shinkai_message_primitives::shinkai_utils::shinkai_path::ShinkaiPath; use shinkai_message_primitives::{ schemas::shinkai_name::ShinkaiName, shinkai_message::shinkai_message_schemas::JobMessage, shinkai_utils::{shinkai_message_builder::ShinkaiMessageBuilder, signatures::clone_signature_secret_key}, }; use shinkai_sqlite::SqliteManager; -use shinkai_vector_fs::vector_fs::vector_fs::VectorFS; -use shinkai_vector_resources::embedding_generator::RemoteEmbeddingGenerator; -use shinkai_vector_resources::source::{DistributionInfo, VRSourceReference}; -use shinkai_vector_resources::vector_resource::{VRPack, VRPath}; use std::result::Result::Ok; use std::sync::Weak; use std::time::Instant; @@ -43,7 +39,6 @@ impl JobManager { pub async fn process_job_message_queued( job_message: JobForProcessing, db: Weak, - vector_fs: Weak, node_profile_name: ShinkaiName, identity_secret_key: SigningKey, generator: RemoteEmbeddingGenerator, @@ -58,7 +53,6 @@ impl JobManager { llm_stopper: Arc, ) -> Result { let db = db.upgrade().ok_or("Failed to upgrade shinkai_db").unwrap(); - let vector_fs = vector_fs.upgrade().ok_or("Failed to upgrade vector_db").unwrap(); let job_id = job_message.job_message.job_id.clone(); shinkai_log( ShinkaiLogOption::JobExecution, @@ -102,27 +96,25 @@ impl JobManager { } } - // 1.- Processes any files which were sent with the job message - let process_files_result = JobManager::process_job_message_files_for_vector_resources( - db.clone(), - vector_fs.clone(), - &job_message.job_message, - llm_provider_found.clone(), - &mut full_job, - user_profile.clone(), - None, - generator.clone(), - ws_manager.clone(), - ) - .await; - if let Err(e) = process_files_result { - return Self::handle_error(&db, Some(user_profile), &job_id, &identity_secret_key, e, ws_manager).await; - } + // TODO: Fix this if it's still needed + // // 1.- Processes any files which were sent with the job message + // let process_files_result = JobManager::process_job_message_files_for_vector_resources( + // db.clone(), + // &job_message.job_message, + // llm_provider_found.clone(), + // &mut full_job, + // user_profile.clone(), + // generator.clone(), + // ws_manager.clone(), + // ) + // .await; + // if let Err(e) = process_files_result { + // return Self::handle_error(&db, Some(user_profile), &job_id, &identity_secret_key, e, ws_manager).await; + // } // 2.- *If* a sheet job is found, processing job message is taken over by this alternate logic let sheet_job_found = JobManager::process_sheet_job( db.clone(), - vector_fs.clone(), &job_message.job_message, job_message.message_hash_id.clone(), llm_provider_found.clone(), @@ -135,6 +127,7 @@ impl JobManager { job_queue_manager.clone(), my_agent_payments_manager.clone(), ext_agent_payments_manager.clone(), + job_callback_manager.clone(), // sqlite_logger.clone(), llm_stopper.clone(), ) @@ -146,7 +139,6 @@ impl JobManager { // Otherwise proceed forward with rest of logic. let inference_chain_result = JobManager::process_inference_chain( db.clone(), - vector_fs.clone(), clone_signature_secret_key(&identity_secret_key), job_message.job_message, job_message.message_hash_id.clone(), @@ -198,7 +190,7 @@ impl JobManager { let shinkai_message = ShinkaiMessageBuilder::job_message_from_llm_provider( job_id.to_string(), error_for_frontend.to_string(), - "".to_string(), + vec![], None, identity_secret_key_clone, node_name.clone(), @@ -218,7 +210,6 @@ impl JobManager { #[allow(clippy::too_many_arguments)] pub async fn process_inference_chain( db: Arc, - vector_fs: Arc, identity_secret_key: SigningKey, job_message: JobMessage, message_hash_id: Option, @@ -232,7 +223,6 @@ impl JobManager { job_callback_manager: Arc>, my_agent_payments_manager: Option>>, ext_agent_payments_manager: Option>>, - // sqlite_logger: Option>, llm_stopper: Arc, ) -> Result<(), LLMProviderError> { let job_id = full_job.job_id().to_string(); @@ -272,25 +262,16 @@ impl JobManager { &format!("Retrieved {} image files", image_files.len()), ); - // Setup initial data to get ready to call a specific inference chain - let prev_execution_context = full_job.execution_context.clone(); - shinkai_log( - ShinkaiLogOption::JobExecution, - ShinkaiLogLevel::Debug, - &format!("Prev Execution Context: {:?}", prev_execution_context), - ); let start = Instant::now(); // Call the inference chain router to choose which chain to use, and call it let inference_response = JobManager::inference_chain_router( db.clone(), - vector_fs.clone(), llm_provider_found, full_job, job_message.clone(), message_hash_id, image_files.clone(), - prev_execution_context, generator, user_profile.clone(), ws_manager.clone(), @@ -298,12 +279,12 @@ impl JobManager { sheet_manager.clone(), my_agent_payments_manager.clone(), ext_agent_payments_manager.clone(), + job_callback_manager.clone(), // sqlite_logger.clone(), llm_stopper.clone(), ) .await?; let inference_response_content = inference_response.response.clone(); - let new_execution_context = inference_response.new_job_execution_context.clone(); let duration = start.elapsed(); shinkai_log( @@ -323,7 +304,7 @@ impl JobManager { let shinkai_message = ShinkaiMessageBuilder::job_message_from_llm_provider( job_id.to_string(), inference_response_content.to_string(), - "".to_string(), + vec![], Some(message_metadata), identity_secret_key_clone, user_profile.node_name.clone(), @@ -337,18 +318,8 @@ impl JobManager { format!("process_inference_chain> shinkai_message: {:?}", shinkai_message).as_str(), ); - // Save response data to DB - db.add_step_history( - job_message.job_id.clone(), - job_message.content, - Some(image_files), - inference_response_content.to_string(), - None, - None, - )?; db.add_message_to_job_inbox(&job_message.job_id.clone(), &shinkai_message, None, ws_manager) .await?; - db.set_job_execution_context(job_message.job_id.clone(), new_execution_context, None)?; // Check for callbacks and add them to the JobManagerQueue if required if let Some(callback) = &job_message.callback { @@ -375,7 +346,6 @@ impl JobManager { #[allow(clippy::too_many_arguments)] pub async fn process_sheet_job( db: Arc, - vector_fs: Arc, job_message: &JobMessage, message_hash_id: Option, llm_provider_found: Option, @@ -388,6 +358,7 @@ impl JobManager { job_queue_manager: Arc>>, my_agent_payments_manager: Option>>, ext_agent_payments_manager: Option>>, + job_callback_manager: Arc>, // sqlite_logger: Option>, llm_stopper: Arc, ) -> Result { @@ -415,36 +386,28 @@ impl JobManager { let (files_inbox, file_names): (Vec, Vec) = input_string.uploaded_files.iter().cloned().unzip(); - Self::process_specified_files_for_vector_resources( - db.clone(), - vector_fs.clone(), - files_inbox.first().unwrap().clone(), - file_names, - None, - &mut mutable_job, - user_profile.clone(), - None, - generator.clone(), - ws_manager.clone(), - ) - .await?; + unimplemented!(); + + // TODO: fix this + // Self::process_specified_files_for_vector_resources( + // db.clone(), + // files_inbox.first().unwrap().clone(), + // file_names, + // None, + // &mut mutable_job, + // user_profile.clone(), + // None, + // generator.clone(), + // ws_manager.clone(), + // ) + // .await?; } for (local_file_path, local_file_name) in &input_string.local_files { - let vector_fs_entry = VectorFSItemScopeEntry { - name: local_file_name.clone(), - path: VRPath::from_string(local_file_path) - .map_err(|e| LLMProviderError::InvalidVRPath(e.to_string()))?, - source: VRSourceReference::None, - }; + let path = ShinkaiPath::from_string(local_file_path.to_string()); // Unwrap the scope_with_files since you are sure it is always Some - mutable_job - .scope_with_files - .as_mut() - .unwrap() - .vector_fs_items - .push(vector_fs_entry); + mutable_job.scope.vector_fs_items.push(path); } let mut job_message = job_message.clone(); @@ -454,13 +417,11 @@ impl JobManager { let inference_result = JobManager::inference_chain_router( db.clone(), - vector_fs.clone(), llm_provider_found, mutable_job.clone(), job_message.clone(), message_hash_id, empty_files, - HashMap::new(), // Assuming prev_execution_context is an empty HashMap generator, user_profile.clone(), ws_manager.clone(), @@ -468,6 +429,7 @@ impl JobManager { Some(sheet_manager.clone()), my_agent_payments_manager.clone(), ext_agent_payments_manager.clone(), + job_callback_manager.clone(), // sqlite_logger.clone(), llm_stopper.clone(), ) @@ -511,271 +473,105 @@ impl JobManager { } } - /// Helper function to process files and update the job scope. - async fn process_files_and_update_scope( - db: Arc, - vector_fs: Arc, - files: Vec<(String, Vec)>, - agent_found: Option, - full_job: &mut Job, - profile: ShinkaiName, - save_to_vector_fs_folder: Option, - generator: RemoteEmbeddingGenerator, - _ws_manager: Option>>, - ) -> Result<(), LLMProviderError> { - // TODO: sync with Paul about format - // // Send WS message indicating file processing is starting - // if let Some(ref manager) = ws_manager { - // let m = manager.lock().await; - // let metadata = WSMetadata { - // id: Some(full_job.job_id().to_string()), - // is_done: false, - // done_reason: Some("Starting file processing".to_string()), - // total_duration: None, - // eval_count: None, - // }; - - // let ws_message_type = WSMessageType::Metadata(metadata); - // let _ = m - // .queue_message( - // WSTopic::Inbox, - // full_job.job_id().to_string(), - // "Processing files...".to_string(), - // ws_message_type, - // false, - // ) - // .await; - // } - - // Start timing the file processing - let start_time = Instant::now(); - - // Process the files - let new_scope_entries_result = JobManager::process_files_inbox( - db.clone(), - vector_fs.clone(), - agent_found, - files.clone(), - profile, - save_to_vector_fs_folder, - generator, - ) - .await; - - // Calculate processing duration - let processing_duration = start_time.elapsed(); - shinkai_log( - ShinkaiLogOption::JobExecution, - ShinkaiLogLevel::Debug, - &format!("File processing took: {:?}", processing_duration), - ); - - // // Send WS message indicating file processing is complete - // if let Some(ref manager) = ws_manager { - // let m = manager.lock().await; - // let metadata = WSMetadata { - // id: Some(full_job.job_id().to_string()), - // is_done: false, - // done_reason: Some("File processing complete".to_string()), - // total_duration: None, - // eval_count: None, - // }; - - // let ws_message_type = WSMessageType::Metadata(metadata); - // let _ = m - // .queue_message( - // WSTopic::Inbox, - // full_job.job_id().to_string(), - // "Files processed successfully".to_string(), - // ws_message_type, - // true, - // ) - // .await; - // } - - match new_scope_entries_result { - Ok(new_scope_entries) => { - // Safely unwrap the scope_with_files - let job_id = full_job.job_id().to_string(); - if let Some(ref mut scope_with_files) = full_job.scope_with_files { - // Update the job scope with new entries - for (_filename, scope_entry) in new_scope_entries { - match scope_entry { - ScopeEntry::LocalScopeVRKai(local_entry) => { - if !scope_with_files.local_vrkai.contains(&local_entry) { - scope_with_files.local_vrkai.push(local_entry); - } else { - shinkai_log( - ShinkaiLogOption::JobExecution, - ShinkaiLogLevel::Error, - "Duplicate LocalScopeVRKaiEntry detected", - ); - } - } - ScopeEntry::LocalScopeVRPack(local_entry) => { - if !scope_with_files.local_vrpack.contains(&local_entry) { - scope_with_files.local_vrpack.push(local_entry); - } else { - shinkai_log( - ShinkaiLogOption::JobExecution, - ShinkaiLogLevel::Error, - "Duplicate LocalScopeVRPackEntry detected", - ); - } - } - ScopeEntry::VectorFSItem(fs_entry) => { - if !scope_with_files.vector_fs_items.contains(&fs_entry) { - scope_with_files.vector_fs_items.push(fs_entry); - } else { - shinkai_log( - ShinkaiLogOption::JobExecution, - ShinkaiLogLevel::Error, - "Duplicate VectorFSScopeEntry detected", - ); - } - } - ScopeEntry::VectorFSFolder(fs_entry) => { - if !scope_with_files.vector_fs_folders.contains(&fs_entry) { - scope_with_files.vector_fs_folders.push(fs_entry); - } else { - shinkai_log( - ShinkaiLogOption::JobExecution, - ShinkaiLogLevel::Error, - "Duplicate VectorFSScopeEntry detected", - ); - } - } - } - } - db.update_job_scope(job_id, scope_with_files.clone())?; - } else { - shinkai_log( - ShinkaiLogOption::JobExecution, - ShinkaiLogLevel::Error, - "No scope_with_files found in full_job", - ); - } - } - Err(e) => { - shinkai_log( - ShinkaiLogOption::JobExecution, - ShinkaiLogLevel::Error, - format!("Error processing files: {}", e).as_str(), - ); - return Err(e); - } - } - - Ok(()) - } - - /// Processes the files sent together with the current job_message into Vector Resources. - #[allow(clippy::too_many_arguments)] - pub async fn process_job_message_files_for_vector_resources( - db: Arc, - vector_fs: Arc, - job_message: &JobMessage, - agent_found: Option, - full_job: &mut Job, - profile: ShinkaiName, - save_to_vector_fs_folder: Option, - generator: RemoteEmbeddingGenerator, - ws_manager: Option>>, - ) -> Result<(), LLMProviderError> { - if !job_message.files_inbox.is_empty() { - shinkai_log( - ShinkaiLogOption::JobExecution, - ShinkaiLogLevel::Debug, - format!("Processing files_map: ... files: {}", job_message.files_inbox.len()).as_str(), - ); - - // Get the files from the DB - let files = { - let files_result = db.get_all_files_from_inbox(job_message.files_inbox.clone()); - match files_result { - Ok(files) => files, - Err(e) => return Err(LLMProviderError::ShinkaiDB(e)), - } - }; - - // Process the files and update the job scope - Self::process_files_and_update_scope( - db, - vector_fs, - files, - agent_found, - full_job, - profile, - save_to_vector_fs_folder, - generator, - ws_manager, - ) - .await?; - } - - Ok(()) - } - - /// Processes the specified files into Vector Resources. - #[allow(clippy::too_many_arguments)] - pub async fn process_specified_files_for_vector_resources( - db: Arc, - vector_fs: Arc, - files_inbox: String, - file_names: Vec, - agent_found: Option, - full_job: &mut Job, - profile: ShinkaiName, - save_to_vector_fs_folder: Option, - generator: RemoteEmbeddingGenerator, - ws_manager: Option>>, - ) -> Result<(), LLMProviderError> { - if !file_names.is_empty() { - shinkai_log( - ShinkaiLogOption::JobExecution, - ShinkaiLogLevel::Debug, - format!("Processing specified files: {:?}", file_names).as_str(), - ); - - // Get the files from the DB - let files = { - let files_result = db.get_all_files_from_inbox(files_inbox.clone()); - match files_result { - Ok(files) => files, - Err(e) => return Err(LLMProviderError::ShinkaiDB(e)), - } - }; - - // Filter files based on the provided file names - let specified_files: Vec<(String, Vec)> = files - .into_iter() - .filter(|(name, _)| file_names.contains(name)) - .collect(); - - // Process the specified files and update the job scope - Self::process_files_and_update_scope( - db, - vector_fs, - specified_files, - agent_found, - full_job, - profile, - save_to_vector_fs_folder, - generator, - ws_manager, - ) - .await?; - } - - Ok(()) - } + // /// Processes the files sent together with the current job_message into Vector Resources. + // #[allow(clippy::too_many_arguments)] + // pub async fn process_job_message_files_for_vector_resources( + // db: Arc, + // job_message: &JobMessage, + // agent_found: Option, + // full_job: &mut Job, + // profile: ShinkaiName, + // generator: RemoteEmbeddingGenerator, + // ws_manager: Option>>, + // ) -> Result<(), LLMProviderError> { + // if !job_message.files_inbox.is_empty() { + // shinkai_log( + // ShinkaiLogOption::JobExecution, + // ShinkaiLogLevel::Debug, + // format!("Processing files_map: ... files: {}", job_message.files_inbox.len()).as_str(), + // ); + + // // Get the files from the DB + // let files = { + // let files_result = db.get_all_files_from_inbox(job_message.files_inbox.clone()); + // match files_result { + // Ok(files) => files, + // Err(e) => return Err(LLMProviderError::ShinkaiDB(e)), + // } + // }; + + // // Process the files and update the job scope + // Self::process_files_and_update_scope( + // db, + // files, + // agent_found, + // full_job, + // profile, + // generator, + // ws_manager, + // ) + // .await?; + // } + + // Ok(()) + // } + + // /// Processes the specified files into Vector Resources. + // #[allow(clippy::too_many_arguments)] + // pub async fn process_specified_files_for_vector_resources( + // db: Arc, + // files_inbox: String, + // file_names: Vec, + // agent_found: Option, + // full_job: &mut Job, + // profile: ShinkaiName, + // generator: RemoteEmbeddingGenerator, + // ws_manager: Option>>, + // ) -> Result<(), LLMProviderError> { + // if !file_names.is_empty() { + // shinkai_log( + // ShinkaiLogOption::JobExecution, + // ShinkaiLogLevel::Debug, + // format!("Processing specified files: {:?}", file_names).as_str(), + // ); + + // // Get the files from the DB + // let files = { + // let files_result = db.get_all_files_from_inbox(files_inbox.clone()); + // match files_result { + // Ok(files) => files, + // Err(e) => return Err(LLMProviderError::ShinkaiDB(e)), + // } + // }; + + // // Filter files based on the provided file names + // let specified_files: Vec<(String, Vec)> = files + // .into_iter() + // .filter(|(name, _)| file_names.contains(name)) + // .collect(); + + // // Process the specified files and update the job scope + // Self::process_files_and_update_scope( + // db, + // specified_files, + // agent_found, + // full_job, + // profile, + // generator, + // ws_manager, + // ) + // .await?; + // } + + // Ok(()) + // } /// Retrieves image files associated with a job message and converts them to base64 pub async fn get_image_files_from_message( db: Arc, job_message: &JobMessage, ) -> Result, LLMProviderError> { - if job_message.files_inbox.is_empty() { + if job_message.fs_files_paths.is_empty() && job_message.job_filenames.is_empty() { return Ok(HashMap::new()); } @@ -785,115 +581,140 @@ impl JobManager { format!("Retrieving files for job message: {}", job_message.job_id).as_str(), ); - let files_vec = db.get_all_files_from_inbox(job_message.files_inbox.clone())?; + let mut image_files = HashMap::new(); - let image_files: HashMap = files_vec - .into_iter() - .filter_map(|(filename, content)| { - let filename_lower = filename.to_lowercase(); + // Process fs_files_paths + for file_path in &job_message.fs_files_paths { + if let Some(file_name) = file_path.path.file_name() { + let filename_lower = file_name.to_string_lossy().to_lowercase(); if filename_lower.ends_with(".png") || filename_lower.ends_with(".jpg") || filename_lower.ends_with(".jpeg") || filename_lower.ends_with(".gif") { - // Note: helpful for later, when we add other types like audio, video, etc. - // let file_extension = filename.split('.').last().unwrap_or("jpg"); - let base64_content = base64::encode(&content); - Some((filename, base64_content)) - } else { - None + // Retrieve the file content + match ShinkaiFileManager::get_file_content(file_path.clone()) { + Ok(content) => { + let base64_content = base64::encode(&content); + image_files.insert(file_path.relative_path().to_string(), base64_content); + } + Err(_) => continue, + } } - }) - .collect(); - - Ok(image_files) - } - - /// Processes the files in a given file inbox by generating VectorResources + job `ScopeEntry`s. - /// If save_to_vector_fs_folder == true, the files will save to the DB and be returned as `VectorFSScopeEntry`s. - /// Else, the files will be returned as LocalScopeEntries and thus held inside. - #[allow(clippy::too_many_arguments)] - pub async fn process_files_inbox( - db: Arc, - _vector_fs: Arc, - agent: Option, - files: Vec<(String, Vec)>, - _profile: ShinkaiName, - save_to_vector_fs_folder: Option, - generator: RemoteEmbeddingGenerator, - ) -> Result, LLMProviderError> { - // Create the RemoteEmbeddingGenerator instance - let mut files_map: HashMap = HashMap::new(); - - // Filter out image files - // TODO: Eventually we will add extra embeddings that support images - let files: Vec<(String, Vec)> = files - .into_iter() - .filter(|(name, _)| { - let name_lower = name.to_lowercase(); - !name_lower.ends_with(".png") - && !name_lower.ends_with(".jpg") - && !name_lower.ends_with(".jpeg") - && !name_lower.ends_with(".gif") - }) - .collect(); - - // Sort out the vrpacks from the rest - #[allow(clippy::type_complexity)] - let (vr_packs, other_files): (Vec<(String, Vec)>, Vec<(String, Vec)>) = - files.into_iter().partition(|(name, _)| name.ends_with(".vrpack")); - - // TODO: Decide how frontend relays distribution info so it can be properly added - // For now attempting basic auto-detection of distribution origin based on filename, and setting release date to none - let mut dist_files = vec![]; - for file in other_files { - let distribution_info = DistributionInfo::new_auto(&file.0, None); - dist_files.push((file.0, file.1, distribution_info)); - } - - let processed_vrkais = - ParsingHelper::process_files_into_vrkai(dist_files, &generator, agent.clone(), db.clone()).await?; - - // Save the vrkai into scope (and potentially VectorFS) - for (filename, vrkai) in processed_vrkais { - // Now create Local/VectorFSScopeEntry depending on setting - if let Some(folder_path) = &save_to_vector_fs_folder { - let fs_scope_entry = VectorFSItemScopeEntry { - name: vrkai.resource.as_trait_object().name().to_string(), - path: folder_path.clone(), - source: vrkai.resource.as_trait_object().source().clone(), - }; - - // TODO: Save to the vector_fs if `save_to_vector_fs_folder` not None - // let vector_fs = self.v - - files_map.insert(filename, ScopeEntry::VectorFSItem(fs_scope_entry)); - } else { - let local_scope_entry = LocalScopeVRKaiEntry { vrkai }; - files_map.insert(filename, ScopeEntry::LocalScopeVRKai(local_scope_entry)); } } - // Save the vrpacks into scope (and potentially VectorFS) - for (filename, vrpack_bytes) in vr_packs { - let vrpack = VRPack::from_bytes(&vrpack_bytes)?; - // Now create Local/VectorFSScopeEntry depending on setting - if let Some(folder_path) = &save_to_vector_fs_folder { - let fs_scope_entry = VectorFSFolderScopeEntry { - name: vrpack.name.clone(), - path: folder_path.push_cloned(vrpack.name.clone()), - }; - - // TODO: Save to the vector_fs if `save_to_vector_fs_folder` not None - // let vector_fs = self.v - - files_map.insert(filename, ScopeEntry::VectorFSFolder(fs_scope_entry)); - } else { - let local_scope_entry = LocalScopeVRPackEntry { vrpack }; - files_map.insert(filename, ScopeEntry::LocalScopeVRPack(local_scope_entry)); + // Process job_filenames + for filename in &job_message.job_filenames { + let filename_lower = filename.to_lowercase(); + if filename_lower.ends_with(".png") + || filename_lower.ends_with(".jpg") + || filename_lower.ends_with(".jpeg") + || filename_lower.ends_with(".gif") + { + // Construct the job file path + match ShinkaiFileManager::construct_job_file_path(&job_message.job_id, filename, &db) { + Ok(file_path) => { + // Retrieve the file content + match ShinkaiFileManager::get_file_content(file_path.clone()) { + Ok(content) => { + let base64_content = base64::encode(&content); + image_files.insert(filename.clone(), base64_content); + } + Err(_) => continue, + } + } + Err(_) => continue, + } } } - Ok(files_map) + Ok(image_files) } + + // /// Processes the files in a given file inbox by generating VectorResources + job `ScopeEntry`s. + // /// If save_to_vector_fs_folder == true, the files will save to the DB and be returned as `VectorFSScopeEntry`s. + // /// Else, the files will be returned as LocalScopeEntries and thus held inside. + // #[allow(clippy::too_many_arguments)] + // pub async fn process_files_inbox( + // db: Arc, + // agent: Option, + // files: Vec<(String, Vec)>, + // _profile: ShinkaiName, + // generator: RemoteEmbeddingGenerator, + // ) -> Result, LLMProviderError> { + // // Create the RemoteEmbeddingGenerator instance + // let mut files_map: HashMap = HashMap::new(); + + // // Filter out image files + // // TODO: Eventually we will add extra embeddings that support images + // let files: Vec<(String, Vec)> = files + // .into_iter() + // .filter(|(name, _)| { + // let name_lower = name.to_lowercase(); + // !name_lower.ends_with(".png") + // && !name_lower.ends_with(".jpg") + // && !name_lower.ends_with(".jpeg") + // && !name_lower.ends_with(".gif") + // }) + // .collect(); + + // // Sort out the vrpacks from the rest + // #[allow(clippy::type_complexity)] + // let (vr_packs, other_files): (Vec<(String, Vec)>, Vec<(String, Vec)>) = + // files.into_iter().partition(|(name, _)| name.ends_with(".vrpack")); + + // // TODO: Decide how frontend relays distribution info so it can be properly added + // // For now attempting basic auto-detection of distribution origin based on filename, and setting release date to none + // let mut dist_files = vec![]; + // for file in other_files { + // let distribution_info = DistributionInfo::new_auto(&file.0, None); + // dist_files.push((file.0, file.1, distribution_info)); + // } + + // let processed_vrkais = + // ParsingHelper::process_files_into_vrkai(dist_files, &generator, agent.clone(), db.clone()).await?; + + // // Save the vrkai into scope (and potentially VectorFS) + // for (filename, vrkai) in processed_vrkais { + // // Now create Local/VectorFSScopeEntry depending on setting + // if let Some(folder_path) = &save_to_vector_fs_folder { + // let fs_scope_entry = VectorFSItemScopeEntry { + // name: vrkai.resource.as_trait_object().name().to_string(), + // path: folder_path.clone(), + // source: vrkai.resource.as_trait_object().source().clone(), + // }; + + // // TODO: Save to the vector_fs if `save_to_vector_fs_folder` not None + // // let vector_fs = self.v + + // files_map.insert(filename, ScopeEntry::VectorFSItem(fs_scope_entry)); + // } else { + // let local_scope_entry = LocalScopeVRKaiEntry { vrkai }; + // files_map.insert(filename, ScopeEntry::LocalScopeVRKai(local_scope_entry)); + // } + // } + + // // Save the vrpacks into scope (and potentially VectorFS) + // for (filename, vrpack_bytes) in vr_packs { + // let vrpack = VRPack::from_bytes(&vrpack_bytes)?; + // // Now create Local/VectorFSScopeEntry depending on setting + // if let Some(folder_path) = &save_to_vector_fs_folder { + // let fs_scope_entry = VectorFSFolderScopeEntry { + // name: vrpack.name.clone(), + // path: folder_path.push_cloned(vrpack.name.clone()), + // }; + + // // TODO: Save to the vector_fs if `save_to_vector_fs_folder` not None + // // let vector_fs = self.v + + // files_map.insert(filename, ScopeEntry::VectorFSFolder(fs_scope_entry)); + // } else { + // let local_scope_entry = LocalScopeVRPackEntry { vrpack }; + // files_map.insert(filename, ScopeEntry::LocalScopeVRPack(local_scope_entry)); + // } + // } + + // Ok(files_map) + // } } diff --git a/shinkai-bin/shinkai-node/src/llm_provider/execution/job_scope_helpers.rs b/shinkai-bin/shinkai-node/src/llm_provider/execution/job_scope_helpers.rs index 9f878c140..31ed73e75 100644 --- a/shinkai-bin/shinkai-node/src/llm_provider/execution/job_scope_helpers.rs +++ b/shinkai-bin/shinkai-node/src/llm_provider/execution/job_scope_helpers.rs @@ -1,255 +1,94 @@ use crate::llm_provider::job_manager::JobManager; -use futures::stream::Stream; -use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; -use shinkai_message_primitives::shinkai_utils::job_scope::JobScope; +use shinkai_fs::shinkai_file_manager::ShinkaiFileManager; +use shinkai_message_primitives::schemas::shinkai_fs::ShinkaiFileChunkCollection; +use shinkai_message_primitives::shinkai_utils::job_scope::MinimalJobScope; use shinkai_message_primitives::shinkai_utils::shinkai_logging::{shinkai_log, ShinkaiLogLevel, ShinkaiLogOption}; +use shinkai_message_primitives::shinkai_utils::shinkai_path::ShinkaiPath; use shinkai_sqlite::errors::SqliteManagerError; -use shinkai_vector_fs::vector_fs::{vector_fs::VectorFS, vector_fs_error::VectorFSError}; -use shinkai_vector_resources::vector_resource::{BaseVectorResource, VRPath}; -use std::pin::Pin; +use shinkai_sqlite::SqliteManager; use std::result::Result::Ok; -use std::sync::Arc; -use std::task::{Context, Poll}; -use tokio::sync::mpsc; - -struct ResourceStream { - receiver: mpsc::Receiver, -} - -impl Stream for ResourceStream { - type Item = BaseVectorResource; - - /// Polls the next BaseVectorResource from the stream - fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { - Pin::new(&mut self.receiver).poll_recv(cx) - } -} +use std::collections::HashMap; impl JobManager { - /// Retrieves all resources in the given job scope, returning them as a stream. Starts with VRKai, then VRPacks, then VectorFS items, then VectorFS folders. - /// For VectorFS items/folders, only fetches 5 at a time, to save on memory + for it to be more agile. - pub async fn retrieve_all_resources_in_job_scope_stream( - vector_fs: Arc, - scope: &JobScope, - profile: &ShinkaiName, - ) -> impl Stream { - let (tx, rx) = mpsc::channel(5); - - // Extract all of the vrkai and vrpack BaseVectorResources (cloned) - let vrkai_resources = scope - .local_vrkai - .iter() - .map(|e| e.vrkai.resource.clone()) - .collect::>(); - let vrpacks_resources = { - let mut resources = Vec::new(); - for entry in &scope.local_vrpack { - if let Ok(unpacked_vrkais) = entry.vrpack.unpack_all_vrkais() { - for (vrkai, _) in unpacked_vrkais { - resources.push(vrkai.resource); - } - } - } - resources - }; - - // Get the entries for FS folders/items - let fs_item_paths = scope - .vector_fs_items - .iter() - .map(|e| e.path.clone()) - .collect::>(); - let fs_folder_paths = scope - .vector_fs_folders - .iter() - .map(|e| e.path.clone()) - .collect::>(); - let cloned_profile1 = profile.clone(); - - tokio::spawn(async move { - // Iterate over local VRKai resources - for resource in vrkai_resources { - if tx.send(resource).await.is_err() { - // Handle the case where the receiver has been dropped - break; - } + /// Retrieves all resources in the given job scope and returns them as a vector of ShinkaiFileChunkCollection. + pub async fn retrieve_all_resources_in_job_scope( + scope: &MinimalJobScope, + sqlite_manager: &SqliteManager, + ) -> Result, SqliteManagerError> { + let mut collections = Vec::new(); + + // Retrieve each file in the job scope + for path in &scope.vector_fs_items { + if let Some(collection) = JobManager::retrieve_file_chunks(path, sqlite_manager).await? { + collections.push(collection); } + } - // Iterate over local VRPacks resources - for resource in vrpacks_resources { - if tx.send(resource).await.is_err() { - break; + // Retrieve files inside vector_fs_folders + for folder in &scope.vector_fs_folders { + let files = match ShinkaiFileManager::list_directory_contents(folder.clone(), sqlite_manager) { + Ok(files) => files, + Err(e) => { + shinkai_log( + ShinkaiLogOption::JobExecution, + ShinkaiLogLevel::Error, + &format!("Error listing directory contents: {:?}", e), + ); + return Err(SqliteManagerError::SomeError(format!("ShinkaiFsError: {:?}", e))); } - } - - // Iterate over vector_fs_items, fetching resources asynchronously - for path in fs_item_paths { - let reader = match vector_fs - .new_reader(cloned_profile1.clone(), path.clone(), cloned_profile1.clone()) - .await - { - Ok(reader) => reader, - Err(_) => { - shinkai_log( - ShinkaiLogOption::JobExecution, - ShinkaiLogLevel::Error, - &format!("retrieve_all_resources_in_job_scope reader create failed: {}", path), - ); - continue; - } - }; + }; - match vector_fs.retrieve_vector_resource(&reader).await { - Ok(resource) => { - if tx.send(resource).await.is_err() { - break; - } - } - Err(_) => { - shinkai_log( - ShinkaiLogOption::JobExecution, - ShinkaiLogLevel::Error, - &format!("retrieve_all_resources_in_job_scope VR retrieve failed: {}", path), - ); - continue; + for file_info in files { + if !file_info.is_directory && file_info.has_embeddings { + let file_path = ShinkaiPath::from_string(file_info.path); + if let Some(collection) = JobManager::retrieve_file_chunks(&file_path, sqlite_manager).await? { + collections.push(collection); } } } - - // Iterate over vector fs folders, fetching resources asynchronously - for folder_path in fs_folder_paths { - let folder_reader = match vector_fs - .new_reader(cloned_profile1.clone(), folder_path.clone(), cloned_profile1.clone()) - .await - { - Ok(reader) => reader, - Err(e) => { - shinkai_log( - ShinkaiLogOption::JobExecution, - ShinkaiLogLevel::Error, - &format!( - "retrieve_all_resources_in_job_scope reader create failed: {} with error: {:?}", - folder_path, e - ), - ); - continue; - } - }; - - // Fetch resource paths - let resource_paths = match vector_fs.retrieve_all_item_paths_underneath_folder(folder_reader).await { - Ok(paths) => paths, - Err(_) => { - shinkai_log( - ShinkaiLogOption::JobExecution, - ShinkaiLogLevel::Error, - &format!( - "retrieve_all_resources_in_job_scope VRs paths in folder fetching failed: {}", - folder_path - ), - ); - - continue; - } - }; - - // Now start processing each resource in the folder - for resource_path in resource_paths { - let resource_reader = match vector_fs - .new_reader(cloned_profile1.clone(), resource_path.clone(), cloned_profile1.clone()) - .await - { - Ok(reader) => reader, - Err(_) => { - shinkai_log( - ShinkaiLogOption::JobExecution, - ShinkaiLogLevel::Error, - &format!( - "retrieve_all_resources_in_job_scope reader create failed: {}", - folder_path - ), - ); - continue; - } - }; - - match vector_fs.retrieve_vector_resource(&resource_reader).await { - Ok(resource) => { - if tx.send(resource).await.is_err() { - break; - } - } - Err(_) => { - shinkai_log( - ShinkaiLogOption::JobExecution, - ShinkaiLogLevel::Error, - &format!( - "retrieve_all_resources_in_job_scope VR retrieve failed: {}", - resource_path - ), - ); - continue; - } - } - } - } - }); - - ResourceStream { receiver: rx } - } -} - -impl JobManager { - /// TODO: When Folder is added into job scope, count the number of folders/items at the time and store in job scope - /// Counts the number of resources in the scope, accessing the VectorFS to check for folders - pub async fn count_number_of_resources_in_job_scope( - vector_fs: Arc, - profile: &ShinkaiName, - scope: &JobScope, - ) -> Result { - let mut count = scope.local_vrkai.len() + scope.vector_fs_items.len(); - - for vrpack_entry in &scope.local_vrpack { - count += vrpack_entry.vrpack.vrkai_count as usize; - } - for folder in &scope.vector_fs_folders { - let path = folder.path.clone(); - let folder_content = vector_fs.count_number_of_items_under_path(path, profile).await?; - count += folder_content; } - Ok(count) + Ok(collections) } - /// Helper method which fetches all local VRs, & directly linked FSItem Vector Resources specified in the given JobScope. - /// Returns all of them in a single list ready to be used. - /// Of note, this does not fetch resources inside of folders in the job scope, as those are not fetched in whole, - /// but instead have a deep vector search performed on them via the VectorFS itself separately. - pub async fn fetch_job_scope_direct_resources( - vector_fs: Arc, - job_scope: &JobScope, - profile: &ShinkaiName, - ) -> Result, SqliteManagerError> { - let mut resources = Vec::new(); - - // Add local resources to the list - for local_entry in &job_scope.local_vrkai { - resources.push(local_entry.vrkai.resource.clone()); - } - - for fs_item in &job_scope.vector_fs_items { - let reader = vector_fs - .new_reader(profile.clone(), fs_item.path.clone(), profile.clone()) - .await - .map_err(|e| SqliteManagerError::SomeError(format!("VectorFS error: {}", e)))?; - - let ret_resource = vector_fs - .retrieve_vector_resource(&reader) - .await - .map_err(|e| SqliteManagerError::SomeError(format!("VectorFS error: {}", e)))?; - resources.push(ret_resource); + /// Static function to retrieve file chunks for a given path. + pub async fn retrieve_file_chunks( + path: &ShinkaiPath, + sqlite_manager: &SqliteManager, + ) -> Result, SqliteManagerError> { + match sqlite_manager.get_parsed_file_by_shinkai_path(path) { + Ok(Some(parsed_file)) if parsed_file.embedding_model_used.is_some() => { + let chunks = sqlite_manager.get_chunks_for_parsed_file(parsed_file.id.unwrap())?; + let mut paths_map = HashMap::new(); + paths_map.insert(parsed_file.id.unwrap(), path.clone()); + Ok(Some(ShinkaiFileChunkCollection { chunks, paths: Some(paths_map) })) + } + Ok(Some(_)) => { + shinkai_log( + ShinkaiLogOption::JobExecution, + ShinkaiLogLevel::Info, + &format!("File has no embeddings: {}", path), + ); + Ok(None) + } + Ok(None) => { + shinkai_log( + ShinkaiLogOption::JobExecution, + ShinkaiLogLevel::Error, + &format!("File not found in database: {}", path), + ); + Ok(None) + } + Err(e) => { + shinkai_log( + ShinkaiLogOption::JobExecution, + ShinkaiLogLevel::Error, + &format!("Error retrieving file from database: {} with error: {:?}", path, e), + ); + Err(e) + } } - - Ok(resources) } } + +// TODO: implement tests under a cfg. \ No newline at end of file diff --git a/shinkai-bin/shinkai-node/src/llm_provider/execution/job_vector_search.rs b/shinkai-bin/shinkai-node/src/llm_provider/execution/job_vector_search.rs index e65a7f72a..2fded4f61 100644 --- a/shinkai-bin/shinkai-node/src/llm_provider/execution/job_vector_search.rs +++ b/shinkai-bin/shinkai-node/src/llm_provider/execution/job_vector_search.rs @@ -1,410 +1,647 @@ use crate::llm_provider::job_manager::JobManager; -use keyphrases::KeyPhraseExtractor; -use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; -use shinkai_message_primitives::shinkai_utils::job_scope::JobScope; +use shinkai_embedding::embedding_generator::{EmbeddingGenerator, RemoteEmbeddingGenerator}; +use shinkai_fs::shinkai_file_manager::ShinkaiFileManager; +use shinkai_message_primitives::schemas::shinkai_fs::{ShinkaiFileChunk, ShinkaiFileChunkCollection}; +use shinkai_message_primitives::shinkai_utils::job_scope::MinimalJobScope; +use shinkai_message_primitives::shinkai_utils::search_mode::VectorSearchMode; use shinkai_message_primitives::shinkai_utils::shinkai_logging::{shinkai_log, ShinkaiLogLevel, ShinkaiLogOption}; +use shinkai_message_primitives::shinkai_utils::shinkai_path::ShinkaiPath; use shinkai_sqlite::errors::SqliteManagerError; use shinkai_sqlite::SqliteManager; -use shinkai_vector_fs::vector_fs::vector_fs::VectorFS; -use shinkai_vector_fs::vector_fs::vector_fs_error::VectorFSError; -use shinkai_vector_resources::embedding_generator::{EmbeddingGenerator, RemoteEmbeddingGenerator}; -use shinkai_vector_resources::embeddings::Embedding; -use shinkai_vector_resources::vector_resource::{ - deep_search_scores_average_out, ResultsMode, RetrievedNode, ScoringMode, TraversalMethod, TraversalOption, - VectorSearchMode, -}; use std::collections::HashMap; +use std::collections::HashSet; use std::result::Result::Ok; use std::sync::Arc; -use tokio::sync::RwLock; impl JobManager { - /// Performs multiple proximity vector searches within the job scope based on extracting keywords from the query text. - /// Attempts to take at least 1 proximity group per keyword that is from a VR different than the highest scored node, to encourage wider diversity in results. - /// Returns the search results and the description/summary text of the VR the highest scored retrieved node is from. - #[allow(clippy::too_many_arguments)] - pub async fn keyword_chained_job_scope_vector_search( - db: Arc, - vector_fs: Arc, - job_scope: &JobScope, - query_text: String, - user_profile: &ShinkaiName, - generator: RemoteEmbeddingGenerator, - num_of_top_results: u64, - max_tokens_in_prompt: usize, - ) -> Result<(Vec, Option), SqliteManagerError> { - let mut master_intro_hashmap: HashMap> = HashMap::new(); - // First perform a standard job scope vector search using the whole query text - let query = generator.generate_embedding_default(&query_text).await?; - let (mut ret_groups, intro_hashmap) = JobManager::internal_job_scope_vector_search_groups( - db.clone(), - vector_fs.clone(), - job_scope, - query, - query_text.clone(), - num_of_top_results, - user_profile, - true, - generator.clone(), - max_tokens_in_prompt, - ) - .await?; - // Insert the contents of intro_hashmap into master_intro_hashmap - for (key, value) in intro_hashmap { - master_intro_hashmap.entry(key).or_insert(value); - } - - // Initialize included_vrs vector with the resource header id of the first node from each ret_node_group, if it exists - let mut included_vrs: Vec = Vec::new(); - for ret_node_group in ret_groups.iter() { - if let Some(first_node) = ret_node_group.first() { - included_vrs.push(first_node.resource_header.reference_string()); + // /// Performs multiple proximity vector searches within the job scope based on extracting keywords from the query text. + // /// Attempts to take at least 1 proximity group per keyword that is from a VR different than the highest scored node, to encourage wider diversity in results. + // /// Returns the search results and the description/summary text of the VR the highest scored retrieved node is from. + // #[allow(clippy::too_many_arguments)] + // pub async fn keyword_chained_job_scope_vector_search( + // db: Arc, + // job_scope: &MinimalJobScope, + // query_text: String, + // user_profile: &ShinkaiName, + // generator: RemoteEmbeddingGenerator, + // num_of_top_results: u64, + // max_tokens_in_prompt: usize, + // ) -> Result<(Vec, Option), SqliteManagerError> { + // let mut master_intro_hashmap: HashMap> = HashMap::new(); + // // First perform a standard job scope vector search using the whole query text + // let query = generator.generate_embedding_default(&query_text).await?; + // let (mut ret_groups, intro_hashmap) = JobManager::internal_job_scope_vector_search_groups( + // db.clone(), + // job_scope, + // query, + // query_text.clone(), + // num_of_top_results, + // user_profile, + // true, + // generator.clone(), + // max_tokens_in_prompt, + // ) + // .await?; + // // Insert the contents of intro_hashmap into master_intro_hashmap + // for (key, value) in intro_hashmap { + // master_intro_hashmap.entry(key).or_insert(value); + // } + + // // Initialize included_vrs vector with the resource header id of the first node from each ret_node_group, if it exists + // let mut included_vrs: Vec = Vec::new(); + // for ret_node_group in ret_groups.iter() { + // if let Some(first_node) = ret_node_group.first() { + // included_vrs.push(first_node.resource_header.reference_string()); + // } + // } + + // // Extract top 3 keywords from the query_text + // let keywords = Self::extract_keywords_from_text(&query_text, 0); + + // // Now we proceed to keyword search chaining logic. + // for keyword in keywords { + // let keyword_query = generator.generate_embedding_default(&keyword).await?; + // let (keyword_ret_nodes_groups, keyword_intro_hashmap) = + // JobManager::internal_job_scope_vector_search_groups( + // db.clone(), + // job_scope, + // keyword_query, + // keyword.clone(), + // num_of_top_results, + // user_profile, + // true, + // generator.clone(), + // max_tokens_in_prompt, + // ) + // .await?; + + // // Insert the contents into master_intro_hashmap + // for (key, value) in keyword_intro_hashmap { + // master_intro_hashmap.entry(key).or_insert(value); + // } + + // // Start looping through the vector search results for this keyword + // let mut keyword_node_inserted = false; + // for group in keyword_ret_nodes_groups.iter() { + // if let Some(first_group_node) = group.first() { + // if !ret_groups.iter().any(|ret_group| group == ret_group) { + // // If the node is unique and we haven't inserted any keyword node yet + // if !keyword_node_inserted { + // // Insert the first node that is not in ret_nodes + // if ret_groups.len() >= 3 { + // ret_groups.insert(3, group.clone()); // Insert at the 3rd position + // } else { + // ret_groups.push(group.clone()); // If less than 3 nodes, just append + // } + // keyword_node_inserted = true; + + // // Check if this keyword node is from a unique VR + // let from_unique_vr = + // !included_vrs.contains(&first_group_node.resource_header.reference_string()); + // // Update the included_vrs + // included_vrs.push(first_group_node.resource_header.reference_string()); + + // // If the first unique node is from a unique VR, no need to continue going through rest of the keyword_nodes + // if from_unique_vr { + // break; + // } + // } else { + // // If we're attempting to insert a unique VR node and found one + // if ret_groups.len() >= 4 { + // ret_groups.insert(4, group.clone()); // Insert at the 4th position if possible + // } else { + // ret_groups.push(group.clone()); // Otherwise, just append + // } + // // Once a unique VR node is inserted, no need to continue for this keyword + // break; + // } + // } + // } + // } + // } + + // // For the top N groups, fetch their VRs' intros and include them at the front of the list + // // We do this by iterating in reverse order (ex. 5th, 4th, 3rd, 2nd, 1st), so highest scored VR intro will be at the top. + // let num_groups = Self::determine_num_groups_for_intro_fetch(max_tokens_in_prompt); + // let mut final_nodes = Vec::new(); + // let mut added_intros = HashMap::new(); + // let mut first_intro_text = None; + + // for group in ret_groups.iter().take(num_groups).rev() { + // // Take the first 5 groups and reverse the order + // if let Some(first_node) = group.first() { + // // Take the first node of the group + // if let Some(intro_text_nodes) = master_intro_hashmap.get(&first_node.resource_header.reference_string()) + // { + // if !added_intros.contains_key(&first_node.resource_header.reference_string()) { + // // Add the intro nodes, and the ref string to added_intros + // for intro_node in intro_text_nodes.iter() { + // final_nodes.push(intro_node.clone()); + // added_intros.insert(first_node.resource_header.reference_string(), true); + // } + // } + // if first_intro_text.is_none() { + // if let Some(intro_text_node) = intro_text_nodes.first() { + // if let Ok(intro_text) = intro_text_node.node.get_text_content() { + // first_intro_text = Some(intro_text.to_string()); + // } + // } + // } + // } + // } + // } + + // // Now go through the groups and add the actual result nodes, skipping any that already are added up front from the intros + // for group in ret_groups.iter() { + // for node in group.iter() { + // if !final_nodes + // .iter() + // .take(10) + // .any(|result_node| result_node.node.content == node.node.content) + // { + // final_nodes.push(node.clone()); + // } + // } + // } + + // // println!( + // // "\n\n\nDone Vector Searching: {}\n------------------------------------------------", + // // query_text + // // ); + + // // for node in &final_nodes { + // // eprintln!("{:?} - {:?}\n", node.score as f32, node.format_for_prompt(3500)); + // // } + + // Ok((final_nodes, first_intro_text)) + // } + + // // /// Determines the number of grouped proximity retrieved nodes to check for intro fetching + // // fn determine_num_groups_for_intro_fetch(max_tokens_in_prompt: usize) -> usize { + // // if max_tokens_in_prompt < 5000 { + // // 5 + // // } else if max_tokens_in_prompt < 33000 { + // // 6 + // // } else { + // // 7 + // // } + // // } + + // /// Extracts top N keywords from the given text. + // fn extract_keywords_from_text(text: &str, num_keywords: usize) -> Vec { + // // Create a new KeyPhraseExtractor with a maximum of num_keywords keywords + // let extractor = KeyPhraseExtractor::new(text, num_keywords); + + // // Get the keywords and their scores + // let keywords = extractor.get_keywords(); + + // // Return only the keywords, discarding the scores + // keywords.into_iter().map(|(_score, keyword)| keyword).collect() + // } + + // //TODOs: + // // - Potentially check the top 10 group result VR, and if they were a pdf or docx, then include first 1-2 nodes of the pdf/docx to always have title/authors available + // // + // /// Perform a proximity vector search on all local & VectorFS-held Vector Resources specified in the JobScope. + // /// Returns the proximity groups of retrieved nodes. + // #[allow(clippy::too_many_arguments)] + // async fn internal_job_scope_vector_search_groups( + // _db: Arc, + // job_scope: &MinimalJobScope, + // query: Vec, + // query_text: String, + // num_of_top_results: u64, + // profile: &ShinkaiName, + // _include_description: bool, + // generator: RemoteEmbeddingGenerator, + // max_tokens_in_prompt: usize, + // ) -> Result< + // ( + // Vec>, + // HashMap>, + // ), + // SqliteManagerError, + // > { + // // Determine the vector search mode configured in the job scope. + // // Limit the maximum tokens to 25k (~ 10 pages of PDF) if the context window is greater than that. + // // If the length is < 25k, pass the entire context. + // // If the length is > 25k, pass the first page of the document and fill up to 25k tokens of context window. + // let max_tokens_in_prompt = + // if job_scope.vector_search_mode.contains(&VectorSearchMode::FillUpTo25k) && max_tokens_in_prompt > 25000 { + // 25000 + // } else { + // max_tokens_in_prompt + // }; + + // let average_out_deep_search_scores = true; + // let proximity_window_size = Self::determine_proximity_window_size(max_tokens_in_prompt); + // let total_num_of_results = (num_of_top_results * proximity_window_size * 2) + num_of_top_results; + // // Holds the intro text for each VR, where only the ones that have results with top scores will be used + // let mut intro_hashmap: HashMap> = HashMap::new(); + + // // Setup vars used across searches + // let deep_traversal_options = vec![ + // TraversalOption::SetScoringMode(ScoringMode::HierarchicalAverageScoring), + // TraversalOption::SetResultsMode(ResultsMode::ProximitySearch(proximity_window_size, num_of_top_results)), + // ]; + // let num_of_resources_to_search_into = 50; + // let mut retrieved_node_groups = Vec::new(); + + // // VRPack deep vector search + // for entry in &job_scope.local_vrpack { + // let vr_pack_results = entry + // .vrpack + // .dynamic_deep_vector_search_with_vrkai_path_customized( + // query_text.clone(), + // num_of_resources_to_search_into, + // &vec![], + // None, + // total_num_of_results, + // TraversalMethod::Exhaustive, + // &deep_traversal_options, + // generator.clone(), + // average_out_deep_search_scores, + // job_scope.vector_search_mode.clone(), + // ) + // .await?; + + // // Fetch the VRKai intros and add them to hashmap + // let mut bare_results = vec![]; + // for (ret_node, path) in vr_pack_results { + // let ref_string = ret_node.resource_header.reference_string(); + // if let std::collections::hash_map::Entry::Vacant(e) = intro_hashmap.entry(ref_string) { + // if let Ok(intro_nodes) = entry.vrpack.get_vrkai_intro_ret_nodes(path.clone()) { + // e.insert(intro_nodes); + // } + // } + // bare_results.push(ret_node); + // } + + // let mut groups = RetrievedNode::group_proximity_results(&bare_results)?; + // retrieved_node_groups.append(&mut groups); + // } + + // // Folder deep vector search + // { + // for folder in &job_scope.vector_fs_folders { + // let reader = vector_fs + // .new_reader(profile.clone(), folder.path.clone(), profile.clone()) + // .await + // .map_err(|e: VectorFSError| SqliteManagerError::SomeError(format!("VectorFS error: {}", e)))?; + + // let results = vector_fs + // .deep_vector_search_customized( + // &reader, + // query_text.clone(), + // num_of_resources_to_search_into, + // total_num_of_results, + // deep_traversal_options.clone(), + // average_out_deep_search_scores, + // job_scope.vector_search_mode.clone(), + // ) + // .await + // .map_err(|e: VectorFSError| SqliteManagerError::SomeError(format!("VectorFS error: {}", e)))?; + + // // Fetch the intros + // let mut bare_results = vec![]; + // for result in results { + // let ret_node = result.resource_retrieved_node.clone(); + // let ref_string = ret_node.resource_header.reference_string(); + // if let std::collections::hash_map::Entry::Vacant(e) = intro_hashmap.entry(ref_string) { + // let result_reader = reader + // .new_reader_copied_data(result.fs_item_path().clone(), &vector_fs) + // .await + // .map_err(|e: VectorFSError| { + // SqliteManagerError::SomeError(format!("VectorFS error: {}", e)) + // })?; + + // if let Ok(intro_nodes) = vector_fs._internal_get_vr_intro_ret_nodes(&result_reader).await { + // e.insert(intro_nodes); + // } + // } + // bare_results.push(ret_node); + // } + + // let mut groups = RetrievedNode::group_proximity_results(&mut bare_results)?; + + // retrieved_node_groups.append(&mut groups); + // } + // } + + // // Fetch rest of VRs directly + // let resources = JobManager::fetch_job_scope_direct_resources(vector_fs, job_scope, profile).await?; + // shinkai_log( + // ShinkaiLogOption::JobExecution, + // ShinkaiLogLevel::Info, + // &format!("Num of resources fetched: {}", resources.len()), + // ); + + // // Perform vector search on all direct resources + // for resource in &resources { + // // First get the resource embedding, and score vs the query + // let resource_embedding = resource.as_trait_object().resource_embedding(); + // let resource_score = query.score_similarity(resource_embedding); + + // // Do the search + // let mut results = resource.as_trait_object().vector_search_customized( + // query.clone(), + // total_num_of_results, + // TraversalMethod::Exhaustive, + // &deep_traversal_options, + // None, + // job_scope.vector_search_mode.clone(), + // ); + + // // Average out the node scores together with the resource_score + // if average_out_deep_search_scores { + // for ret_node in &mut results { + // ret_node.score = deep_search_scores_average_out( + // None, + // resource_score, + // resource.as_trait_object().description().unwrap_or("").to_string(), + // ret_node.score, + // ret_node.node.get_text_content().unwrap_or("").to_string(), + // ); + // } + // } + + // // Fetch the intros + // let mut bare_results = vec![]; + // for ret_node in results { + // let ref_string = ret_node.resource_header.reference_string(); + // if let std::collections::hash_map::Entry::Vacant(e) = intro_hashmap.entry(ref_string) { + // if let Ok(intro_nodes) = resource.as_trait_object().generate_intro_ret_nodes() { + // e.insert(intro_nodes); + // } + // } + // bare_results.push(ret_node); + // } + + // let mut groups = RetrievedNode::group_proximity_results(&mut bare_results)?; + // retrieved_node_groups.append(&mut groups); + // } + + // shinkai_log( + // ShinkaiLogOption::JobExecution, + // ShinkaiLogLevel::Info, + // &format!("Num of node groups retrieved: {}", retrieved_node_groups.len()), + // ); + + // // Sort the retrieved node groups by score, and generate a description if any direct VRs available + // let sorted_retrieved_node_groups = + // RetrievedNode::sort_by_score_groups(&retrieved_node_groups, total_num_of_results); + + // Ok((sorted_retrieved_node_groups, intro_hashmap)) + // } + + // /// Determines the proximity window size based on the max tokens supported by the model + // fn determine_proximity_window_size(max_tokens_in_prompt: usize) -> u64 { + // if max_tokens_in_prompt < 5000 { + // 1 + // } else if max_tokens_in_prompt < 33000 { + // 2 + // } else { + // 3 + // } + // } + + /// Helper function to process folders and collect file information + async fn process_folder_contents( + folder: &ShinkaiPath, + sqlite_manager: &SqliteManager, + parsed_file_ids: &mut Vec, + paths_map: &mut HashMap, + total_tokens: &mut i64, + all_files_have_token_count: &mut bool, + ) -> Result<(), SqliteManagerError> { + let files = match ShinkaiFileManager::list_directory_contents(folder.clone(), sqlite_manager) { + Ok(files) => files, + Err(e) => { + shinkai_log( + ShinkaiLogOption::JobExecution, + ShinkaiLogLevel::Error, + &format!("Error listing directory contents: {:?}", e), + ); + return Err(SqliteManagerError::SomeError(format!("ShinkaiFsError: {:?}", e))); + } + }; + + for file_info in files { + if !file_info.is_directory && file_info.has_embeddings { + let file_path = ShinkaiPath::from_string(file_info.path); + if let Some(parsed_file) = sqlite_manager.get_parsed_file_by_shinkai_path(&file_path).unwrap() { + let file_id = parsed_file.id.unwrap(); + parsed_file_ids.push(file_id); + paths_map.insert(file_id, file_path); + + // Count tokens while we're here + if let Some(file_tokens) = parsed_file.total_tokens { + *total_tokens += file_tokens; + } else { + *all_files_have_token_count = false; + } + } } } + Ok(()) + } - // Extract top 3 keywords from the query_text - let keywords = Self::extract_keywords_from_text(&query_text, 0); - - // Now we proceed to keyword search chaining logic. - for keyword in keywords { - let keyword_query = generator.generate_embedding_default(&keyword).await?; - let (keyword_ret_nodes_groups, keyword_intro_hashmap) = - JobManager::internal_job_scope_vector_search_groups( - db.clone(), - vector_fs.clone(), - job_scope, - keyword_query, - keyword.clone(), - num_of_top_results, - user_profile, - true, - generator.clone(), - max_tokens_in_prompt, - ) - .await?; - - // Insert the contents into master_intro_hashmap - for (key, value) in keyword_intro_hashmap { - master_intro_hashmap.entry(key).or_insert(value); + /// Searches all resources in the given job scope and returns the search results. + pub async fn search_for_chunks_in_resources( + fs_files_paths: Vec, + fs_folder_paths: Vec, + job_filenames: Vec, + job_id: String, + scope: &MinimalJobScope, + sqlite_manager: Arc, + query_text: String, + num_of_top_results: usize, + max_tokens_in_prompt: usize, + embedding_generator: RemoteEmbeddingGenerator, + ) -> Result { + let mut parsed_file_ids = Vec::new(); + let mut paths_map = HashMap::new(); + let mut total_tokens: i64 = 0; + let mut all_files_have_token_count = true; + + let query_embedding = match embedding_generator.generate_embedding_default(&query_text).await { + Ok(embedding) => embedding, + Err(e) => { + return Err(SqliteManagerError::SomeError(e.to_string())); } - - // Start looping through the vector search results for this keyword - let mut keyword_node_inserted = false; - for group in keyword_ret_nodes_groups.iter() { - if let Some(first_group_node) = group.first() { - if !ret_groups.iter().any(|ret_group| group == ret_group) { - // If the node is unique and we haven't inserted any keyword node yet - if !keyword_node_inserted { - // Insert the first node that is not in ret_nodes - if ret_groups.len() >= 3 { - ret_groups.insert(3, group.clone()); // Insert at the 3rd position - } else { - ret_groups.push(group.clone()); // If less than 3 nodes, just append - } - keyword_node_inserted = true; - - // Check if this keyword node is from a unique VR - let from_unique_vr = - !included_vrs.contains(&first_group_node.resource_header.reference_string()); - // Update the included_vrs - included_vrs.push(first_group_node.resource_header.reference_string()); - - // If the first unique node is from a unique VR, no need to continue going through rest of the keyword_nodes - if from_unique_vr { - break; - } - } else { - // If we're attempting to insert a unique VR node and found one - if ret_groups.len() >= 4 { - ret_groups.insert(4, group.clone()); // Insert at the 4th position if possible - } else { - ret_groups.push(group.clone()); // Otherwise, just append - } - // Once a unique VR node is inserted, no need to continue for this keyword - break; - } - } + }; + + // Process fs_files_paths + for path in &fs_files_paths { + if let Some(parsed_file) = sqlite_manager.get_parsed_file_by_shinkai_path(path).unwrap() { + let file_id = parsed_file.id.unwrap(); + parsed_file_ids.push(file_id); + paths_map.insert(file_id, path.clone()); + + if let Some(file_tokens) = parsed_file.total_tokens { + total_tokens += file_tokens; + } else { + all_files_have_token_count = false; } } } - // For the top N groups, fetch their VRs' intros and include them at the front of the list - // We do this by iterating in reverse order (ex. 5th, 4th, 3rd, 2nd, 1st), so highest scored VR intro will be at the top. - let num_groups = Self::determine_num_groups_for_intro_fetch(max_tokens_in_prompt); - let mut final_nodes = Vec::new(); - let mut added_intros = HashMap::new(); - let mut first_intro_text = None; - - for group in ret_groups.iter().take(num_groups).rev() { - // Take the first 5 groups and reverse the order - if let Some(first_node) = group.first() { - // Take the first node of the group - if let Some(intro_text_nodes) = master_intro_hashmap.get(&first_node.resource_header.reference_string()) - { - if !added_intros.contains_key(&first_node.resource_header.reference_string()) { - // Add the intro nodes, and the ref string to added_intros - for intro_node in intro_text_nodes.iter() { - final_nodes.push(intro_node.clone()); - added_intros.insert(first_node.resource_header.reference_string(), true); - } - } - if first_intro_text.is_none() { - if let Some(intro_text_node) = intro_text_nodes.first() { - if let Ok(intro_text) = intro_text_node.node.get_text_content() { - first_intro_text = Some(intro_text.to_string()); - } - } - } + // Process job_filenames + for filename in &job_filenames { + let file_path = + match ShinkaiFileManager::construct_job_file_path(&job_id, filename, &sqlite_manager) { + Ok(path) => path, + Err(_) => continue, + }; + + if let Some(parsed_file) = sqlite_manager.get_parsed_file_by_shinkai_path(&file_path).unwrap() { + let file_id = parsed_file.id.unwrap(); + parsed_file_ids.push(file_id); + paths_map.insert(file_id, file_path); + + if let Some(file_tokens) = parsed_file.total_tokens { + total_tokens += file_tokens; + } else { + all_files_have_token_count = false; } } } - // Now go through the groups and add the actual result nodes, skipping any that already are added up front from the intros - for group in ret_groups.iter() { - for node in group.iter() { - if !final_nodes - .iter() - .take(10) - .any(|result_node| result_node.node.content == node.node.content) - { - final_nodes.push(node.clone()); + // Retrieve each file in the job scope + for path in &scope.vector_fs_items { + if let Some(parsed_file) = sqlite_manager.get_parsed_file_by_shinkai_path(path).unwrap() { + let file_id = parsed_file.id.unwrap(); + parsed_file_ids.push(file_id); + paths_map.insert(file_id, path.clone()); + + // Count tokens while we're here + if let Some(file_tokens) = parsed_file.total_tokens { + total_tokens += file_tokens; + } else { + all_files_have_token_count = false; } } } - // println!( - // "\n\n\nDone Vector Searching: {}\n------------------------------------------------", - // query_text - // ); - - // for node in &final_nodes { - // eprintln!("{:?} - {:?}\n", node.score as f32, node.format_for_prompt(3500)); - // } - - Ok((final_nodes, first_intro_text)) - } - - /// Determines the number of grouped proximity retrieved nodes to check for intro fetching - fn determine_num_groups_for_intro_fetch(max_tokens_in_prompt: usize) -> usize { - if max_tokens_in_prompt < 5000 { - 5 - } else if max_tokens_in_prompt < 33000 { - 6 - } else { - 7 + // Process fs_folder_paths + for folder in &fs_folder_paths { + Self::process_folder_contents( + folder, + &sqlite_manager, + &mut parsed_file_ids, + &mut paths_map, + &mut total_tokens, + &mut all_files_have_token_count, + ) + .await?; } - } - /// Extracts top N keywords from the given text. - fn extract_keywords_from_text(text: &str, num_keywords: usize) -> Vec { - // Create a new KeyPhraseExtractor with a maximum of num_keywords keywords - let extractor = KeyPhraseExtractor::new(text, num_keywords); - - // Get the keywords and their scores - let keywords = extractor.get_keywords(); - - // Return only the keywords, discarding the scores - keywords.into_iter().map(|(_score, keyword)| keyword).collect() - } + // Retrieve files inside vector_fs_folders + for folder in &scope.vector_fs_folders { + Self::process_folder_contents( + folder, + &sqlite_manager, + &mut parsed_file_ids, + &mut paths_map, + &mut total_tokens, + &mut all_files_have_token_count, + ) + .await?; + } - //TODOs: - // - Potentially check the top 10 group result VR, and if they were a pdf or docx, then include first 1-2 nodes of the pdf/docx to always have title/authors available - // - /// Perform a proximity vector search on all local & VectorFS-held Vector Resources specified in the JobScope. - /// Returns the proximity groups of retrieved nodes. - #[allow(clippy::too_many_arguments)] - async fn internal_job_scope_vector_search_groups( - _db: Arc, - vector_fs: Arc, - job_scope: &JobScope, - query: Embedding, - query_text: String, - num_of_top_results: u64, - profile: &ShinkaiName, - _include_description: bool, - generator: RemoteEmbeddingGenerator, - max_tokens_in_prompt: usize, - ) -> Result<(Vec>, HashMap>), SqliteManagerError> { // Determine the vector search mode configured in the job scope. - // Limit the maximum tokens to 25k (~ 10 pages of PDF) if the context window is greater than that. - // If the length is < 25k, pass the entire context. - // If the length is > 25k, pass the first page of the document and fill up to 25k tokens of context window. let max_tokens_in_prompt = - if job_scope.vector_search_mode.contains(&VectorSearchMode::FillUpTo25k) && max_tokens_in_prompt > 25000 { + if scope.vector_search_mode == VectorSearchMode::FillUpTo25k && max_tokens_in_prompt > 25000 { 25000 } else { max_tokens_in_prompt }; - let average_out_deep_search_scores = true; - let proximity_window_size = Self::determine_proximity_window_size(max_tokens_in_prompt); - let total_num_of_results = (num_of_top_results * proximity_window_size * 2) + num_of_top_results; - // Holds the intro text for each VR, where only the ones that have results with top scores will be used - let mut intro_hashmap: HashMap> = HashMap::new(); - - // Setup vars used across searches - let deep_traversal_options = vec![ - TraversalOption::SetScoringMode(ScoringMode::HierarchicalAverageScoring), - TraversalOption::SetResultsMode(ResultsMode::ProximitySearch(proximity_window_size, num_of_top_results)), - ]; - let num_of_resources_to_search_into = 50; - let mut retrieved_node_groups = Vec::new(); - - // VRPack deep vector search - for entry in &job_scope.local_vrpack { - let vr_pack_results = entry - .vrpack - .dynamic_deep_vector_search_with_vrkai_path_customized( - query_text.clone(), - num_of_resources_to_search_into, - &vec![], - None, - total_num_of_results, - TraversalMethod::Exhaustive, - &deep_traversal_options, - generator.clone(), - average_out_deep_search_scores, - job_scope.vector_search_mode.clone(), - ) - .await?; - - // Fetch the VRKai intros and add them to hashmap - let mut bare_results = vec![]; - for (ret_node, path) in vr_pack_results { - let ref_string = ret_node.resource_header.reference_string(); - if let std::collections::hash_map::Entry::Vacant(e) = intro_hashmap.entry(ref_string) { - if let Ok(intro_nodes) = entry.vrpack.get_vrkai_intro_ret_nodes(path.clone()) { - e.insert(intro_nodes); - } - } - bare_results.push(ret_node); + // If we have token counts for all files and they fit within the limit, + // we can include all chunks from all files + if all_files_have_token_count && total_tokens <= max_tokens_in_prompt as i64 { + let mut all_chunks = Vec::new(); + for file_id in parsed_file_ids { + let file_chunks = sqlite_manager.get_chunks_for_parsed_file(file_id)?; + all_chunks.extend(file_chunks); } - let mut groups = RetrievedNode::group_proximity_results(&bare_results)?; - retrieved_node_groups.append(&mut groups); + return Ok(ShinkaiFileChunkCollection { + chunks: all_chunks, + paths: Some(paths_map), + }); } - // Folder deep vector search - { - for folder in &job_scope.vector_fs_folders { - let reader = vector_fs - .new_reader(profile.clone(), folder.path.clone(), profile.clone()) - .await - .map_err(|e: VectorFSError| SqliteManagerError::SomeError(format!("VectorFS error: {}", e)))?; - - let results = vector_fs - .deep_vector_search_customized( - &reader, - query_text.clone(), - num_of_resources_to_search_into, - total_num_of_results, - deep_traversal_options.clone(), - average_out_deep_search_scores, - job_scope.vector_search_mode.clone(), - ) - .await - .map_err(|e: VectorFSError| SqliteManagerError::SomeError(format!("VectorFS error: {}", e)))?; - - // Fetch the intros - let mut bare_results = vec![]; - for result in results { - let ret_node = result.resource_retrieved_node.clone(); - let ref_string = ret_node.resource_header.reference_string(); - if let std::collections::hash_map::Entry::Vacant(e) = intro_hashmap.entry(ref_string) { - let result_reader = reader - .new_reader_copied_data(result.fs_item_path().clone(), &vector_fs) - .await - .map_err(|e: VectorFSError| { - SqliteManagerError::SomeError(format!("VectorFS error: {}", e)) - })?; - - if let Ok(intro_nodes) = vector_fs._internal_get_vr_intro_ret_nodes(&result_reader).await { - e.insert(intro_nodes); - } - } - bare_results.push(ret_node); - } + // Perform a vector search on all parsed files + let search_results = sqlite_manager.search_chunks(&parsed_file_ids, query_embedding, num_of_top_results)?; - let mut groups = RetrievedNode::group_proximity_results(&mut bare_results)?; - - retrieved_node_groups.append(&mut groups); - } + // If there are no initial results, just return early + if search_results.is_empty() { + eprintln!("No initial results found for search"); + return Ok(ShinkaiFileChunkCollection { + chunks: vec![], + paths: Some(paths_map), + }); } - // Fetch rest of VRs directly - let resources = JobManager::fetch_job_scope_direct_resources(vector_fs, job_scope, profile).await?; - shinkai_log( - ShinkaiLogOption::JobExecution, - ShinkaiLogLevel::Info, - &format!("Num of resources fetched: {}", resources.len()), - ); - - // Perform vector search on all direct resources - for resource in &resources { - // First get the resource embedding, and score vs the query - let resource_embedding = resource.as_trait_object().resource_embedding(); - let resource_score = query.score_similarity(resource_embedding); - - // Do the search - let mut results = resource.as_trait_object().vector_search_customized( - query.clone(), - total_num_of_results, - TraversalMethod::Exhaustive, - &deep_traversal_options, - None, - job_scope.vector_search_mode.clone(), - ); - - // Average out the node scores together with the resource_score - if average_out_deep_search_scores { - for ret_node in &mut results { - ret_node.score = deep_search_scores_average_out( - None, - resource_score, - resource.as_trait_object().description().unwrap_or("").to_string(), - ret_node.score, - ret_node.node.get_text_content().unwrap_or("").to_string(), - ); + // Count the total number of characters in the search results using map-reduce + let total_characters: usize = search_results + .iter() + .map(|(chunk, _distance)| chunk.content.len()) + .sum(); + + // Calculate the average chunk size + let average_chunk_size = total_characters / search_results.len(); + + // Calculate the total amount of extra chunks we need to fetch to fill up to max_tokens_in_prompt + let extra_chunks_needed = (max_tokens_in_prompt - total_characters) / average_chunk_size; + + // Distribute the extra chunks across the search results + let total_results = search_results.len(); + let chunk_needed_per_result = extra_chunks_needed / total_results; + let remainder = extra_chunks_needed % total_results; + + // Use a HashSet to avoid duplicate chunks + let mut expanded_results_set = HashSet::new(); + let mut total_characters = 0; + + // Expand results to fill the context window + for (i, (chunk, _distance)) in search_results.into_iter().enumerate() { + // Always include the chunk itself + let chunk_length = chunk.content.len(); + total_characters += chunk_length; + expanded_results_set.insert(chunk.clone()); + + // Determine how many neighbors to fetch for this chunk + let this_result_window_size = chunk_needed_per_result + if i < remainder { 1 } else { 0 }; + + // Now use that as the "proximity window" for this particular chunk + let mut neighbors = + sqlite_manager.get_neighboring_chunks(chunk.parsed_file_id, chunk.position, this_result_window_size)?; + + // Insert neighbors one at a time until we hit max_tokens_in_prompt + while total_characters < max_tokens_in_prompt { + if let Some(neighbor) = neighbors.pop() { + total_characters += neighbor.content.len(); + expanded_results_set.insert(neighbor); + } else { + // No more neighbors for this chunk + break; } } - // Fetch the intros - let mut bare_results = vec![]; - for ret_node in results { - let ref_string = ret_node.resource_header.reference_string(); - if let std::collections::hash_map::Entry::Vacant(e) = intro_hashmap.entry(ref_string) { - if let Ok(intro_nodes) = resource.as_trait_object().generate_intro_ret_nodes() { - e.insert(intro_nodes); - } - } - bare_results.push(ret_node); + // If we've filled the window, no need to keep going + if total_characters >= max_tokens_in_prompt { + break; } - - let mut groups = RetrievedNode::group_proximity_results(&mut bare_results)?; - retrieved_node_groups.append(&mut groups); } - shinkai_log( - ShinkaiLogOption::JobExecution, - ShinkaiLogLevel::Info, - &format!("Num of node groups retrieved: {}", retrieved_node_groups.len()), - ); + // Convert HashSet to Vec + let expanded_results: Vec = expanded_results_set.into_iter().collect(); - // Sort the retrieved node groups by score, and generate a description if any direct VRs available - let sorted_retrieved_node_groups = - RetrievedNode::sort_by_score_groups(&retrieved_node_groups, total_num_of_results); - - Ok((sorted_retrieved_node_groups, intro_hashmap)) - } - - /// Determines the proximity window size based on the max tokens supported by the model - fn determine_proximity_window_size(max_tokens_in_prompt: usize) -> u64 { - if max_tokens_in_prompt < 5000 { - 1 - } else if max_tokens_in_prompt < 33000 { - 2 - } else { - 3 - } + Ok(ShinkaiFileChunkCollection { + chunks: expanded_results, + paths: Some(paths_map), + }) } } diff --git a/shinkai-bin/shinkai-node/src/llm_provider/execution/user_message_parser.rs b/shinkai-bin/shinkai-node/src/llm_provider/execution/user_message_parser.rs index 15ce8f4f5..47d0685c4 100644 --- a/shinkai-bin/shinkai-node/src/llm_provider/execution/user_message_parser.rs +++ b/shinkai-bin/shinkai-node/src/llm_provider/execution/user_message_parser.rs @@ -1,9 +1,11 @@ use serde::{Deserialize, Serialize}; -use shinkai_vector_resources::{ - embedding_generator::{EmbeddingGenerator, RemoteEmbeddingGenerator}, - embeddings::Embedding, - resource_errors::VRError, -}; +use shinkai_embedding::embedding_generator::{EmbeddingGenerator, RemoteEmbeddingGenerator}; +use shinkai_fs::shinkai_fs_error::ShinkaiFsError; +// use shinkai_vector_resources::{ +// embedding_generator::{EmbeddingGenerator, RemoteEmbeddingGenerator}, +// embeddings::Embedding, +// resource_errors::VRError, +// }; /// Represents an analyzed/parsed initial message which triggered the job to run (aka. user message) /// Holds an ordered list of elements, which are pieces of the original user message string with parsed metadata about them @@ -57,12 +59,6 @@ impl ParsedUserMessage { } } - // TODO: Fix - // // Parses the list point elements out of the text elements, and preserves ordering - // let elements = parse_list_point_elements_from_text_elements(elements); - - //TODO: Convert list points to ListTaskElement - elements } @@ -139,7 +135,7 @@ impl ParsedUserMessage { } /// Generates an embedding for the user message using it's entire output string, with a default empty id - pub async fn generate_embedding(&self, generator: RemoteEmbeddingGenerator) -> Result { + pub async fn generate_embedding(&self, generator: RemoteEmbeddingGenerator) -> Result, ShinkaiFsError> { let embedding = generator.generate_embedding_default(&self.get_output_string()).await?; Ok(embedding) } @@ -150,7 +146,7 @@ impl ParsedUserMessage { generator: RemoteEmbeddingGenerator, remove_text: bool, remove_code_blocks: bool, - ) -> Result { + ) -> Result, ShinkaiFsError> { let embedding = generator .generate_embedding_default(&self.get_output_string_filtered(remove_text, remove_code_blocks)) .await?; @@ -360,62 +356,3 @@ fn get_list_item_patterns() -> Vec { patterns } - -// TODO: Fix later -fn parse_list_point_elements_from_text_elements(elements: Vec) -> Vec { - let mut new_elements = Vec::new(); - let list_item_patterns = get_list_item_patterns(); - - for element in elements.into_iter() { - match element { - JobTaskElement::Text(text_element) => { - let text = text_element.content.clone(); - let mut last_pos = 0; - let mut list_items = Vec::new(); - - for pattern in &list_item_patterns { - let mut pos = text[last_pos..].find(pattern); - while let Some(p) = pos { - let start = last_pos + p; - // Find the end of the list item or use the end of the string if no newline is found - let end = text[start..].find('\n').map_or(text.len(), |p| start + p); - // Ensure start is not beyond the end of the string - if start < text.len() { - let item_content = text[start + pattern.len()..end].trim().to_string(); - if !item_content.is_empty() { - list_items.push((start, item_content, pattern.len())); - } - } - last_pos = end + 1; // Move past the newline character for the next search - pos = text[last_pos..].find(pattern); - } - } - - list_items.sort_by(|a, b| a.0.cmp(&b.0)); - let mut current_pos = 0; - - for (start, item_content, pattern_length) in list_items { - if start > current_pos && current_pos < text.len() { - // Ensure slicing does not go beyond the string's length - let slice_end = std::cmp::min(start, text.len()); - new_elements.push(JobTaskElement::Text(TextTaskElement::new( - text[current_pos..slice_end].to_string(), - ))); - } - new_elements.push(JobTaskElement::ListPoint(ListPoint::new(item_content.clone()))); - current_pos = start + item_content.len() + pattern_length; - } - - // Handle any remaining text after the last list item - if current_pos < text.len() { - new_elements.push(JobTaskElement::Text(TextTaskElement::new( - text[current_pos..].to_string(), - ))); - } - } - _ => new_elements.push(element), - } - } - - new_elements -} diff --git a/shinkai-bin/shinkai-node/src/llm_provider/job_callback_manager.rs b/shinkai-bin/shinkai-node/src/llm_provider/job_callback_manager.rs index 4b9f8a5e5..514fb2065 100644 --- a/shinkai-bin/shinkai-node/src/llm_provider/job_callback_manager.rs +++ b/shinkai-bin/shinkai-node/src/llm_provider/job_callback_manager.rs @@ -116,7 +116,7 @@ impl JobCallbackManager { let shinkai_message = ShinkaiMessageBuilder::job_message_unencrypted( job_id.to_string(), error_message, - "".to_string(), + vec![], "".to_string(), identity_secret_key_clone, user_profile.node_name.clone(), diff --git a/shinkai-bin/shinkai-node/src/llm_provider/job_manager.rs b/shinkai-bin/shinkai-node/src/llm_provider/job_manager.rs index 8766b0cf8..1e5f30d63 100644 --- a/shinkai-bin/shinkai-node/src/llm_provider/job_manager.rs +++ b/shinkai-bin/shinkai-node/src/llm_provider/job_manager.rs @@ -8,6 +8,7 @@ use crate::network::agent_payments_manager::external_agent_offerings_manager::Ex use crate::network::agent_payments_manager::my_agent_offerings_manager::MyAgentOfferingsManager; use ed25519_dalek::SigningKey; use futures::Future; +use shinkai_embedding::embedding_generator::RemoteEmbeddingGenerator; use shinkai_job_queue_manager::job_queue_manager::{JobForProcessing, JobQueueManager}; use shinkai_message_primitives::schemas::inbox_name::InboxName; use shinkai_message_primitives::schemas::job::JobLike; @@ -23,8 +24,6 @@ use shinkai_message_primitives::{ shinkai_utils::signatures::clone_signature_secret_key, }; use shinkai_sqlite::SqliteManager; -use shinkai_vector_fs::vector_fs::vector_fs::VectorFS; -use shinkai_vector_resources::embedding_generator::RemoteEmbeddingGenerator; use std::collections::HashSet; use std::env; use std::pin::Pin; @@ -32,6 +31,7 @@ use std::result::Result::Ok; use std::sync::Weak; use std::{collections::HashMap, sync::Arc}; use tokio::sync::{Mutex, Semaphore}; +use shinkai_fs::shinkai_file_manager::ShinkaiFileManager; const NUM_THREADS: usize = 4; @@ -70,7 +70,6 @@ impl JobManager { identity_manager: Arc>, identity_secret_key: SigningKey, node_profile_name: ShinkaiName, - vector_fs: Weak, embedding_generator: RemoteEmbeddingGenerator, ws_manager: Option>>, tool_router: Option>, @@ -91,9 +90,13 @@ impl JobManager { } let db_prefix = "job_manager_abcdeprefix_"; - let job_queue = JobQueueManager::::new(db.clone(), Some(db_prefix.to_string())) - .await - .unwrap(); + let job_queue_result = JobQueueManager::::new(db.clone(), Some(db_prefix.to_string())).await; + + if let Err(ref e) = job_queue_result { + eprintln!("Error initializing JobQueueManager: {:?}", e); + } + + let job_queue = job_queue_result.unwrap(); let job_queue_manager = Arc::new(Mutex::new(job_queue)); let thread_number = env::var("JOB_MANAGER_THREADS") @@ -105,7 +108,6 @@ impl JobManager { let job_queue_handler = JobManager::process_job_queue( job_queue_manager.clone(), db.clone(), - vector_fs.clone(), node_profile_name.clone(), thread_number, clone_signature_secret_key(&identity_secret_key), @@ -120,7 +122,6 @@ impl JobManager { llm_stopper.clone(), |job, db, - vector_fs, node_profile_name, identity_sk, generator, @@ -136,7 +137,6 @@ impl JobManager { Box::pin(JobManager::process_job_message_queued( job, db, - vector_fs, node_profile_name, identity_sk, generator, @@ -170,7 +170,6 @@ impl JobManager { pub async fn process_job_queue( job_queue_manager: Arc>>, db: Weak, - vector_fs: Weak, node_profile_name: ShinkaiName, max_parallel_jobs: usize, identity_sk: SigningKey, @@ -186,7 +185,6 @@ impl JobManager { job_processing_fn: impl Fn( JobForProcessing, Weak, - Weak, ShinkaiName, SigningKey, RemoteEmbeddingGenerator, @@ -207,7 +205,6 @@ impl JobManager { let job_queue_manager = Arc::clone(&job_queue_manager); let mut receiver = job_queue_manager.lock().await.subscribe_to_all().await; let db_clone = db.clone(); - let vector_fs_clone = vector_fs.clone(); let identity_sk = clone_signature_secret_key(&identity_sk); let job_processing_fn = Arc::new(job_processing_fn); // let sqlite_logger = sqlite_logger.clone(); @@ -268,7 +265,6 @@ impl JobManager { let processing_jobs = Arc::clone(&processing_jobs); let semaphore = Arc::clone(&semaphore); let db_clone_2 = db_clone.clone(); - let vector_fs_clone_2 = vector_fs_clone.clone(); let identity_sk_clone = clone_signature_secret_key(&identity_sk); let job_processing_fn = Arc::clone(&job_processing_fn); let cloned_generator = generator.clone(); @@ -298,7 +294,6 @@ impl JobManager { let result = (job_processing_fn)( job, db_clone_2, - vector_fs_clone_2, node_profile_name, identity_sk_clone, cloned_generator, @@ -466,6 +461,40 @@ impl JobManager { } } + async fn update_job_folder_name( + &self, + job_id: &str, + content: &str, + db_arc: &SqliteManager, + ) -> Result<(), LLMProviderError> { + // Parse the inbox name to check if it's a job inbox + let inbox_name = InboxName::get_job_inbox_name_from_params(job_id.to_string())?; + + // Get the current folder name before updating + let old_folder = db_arc.get_job_folder_name(job_id) + .map_err(|e| LLMProviderError::ShinkaiDB(e))?; + + // Update the inbox name + let mut truncated_content = content.to_string(); + if truncated_content.chars().count() > 120 { + truncated_content = format!("{}...", truncated_content.chars().take(120).collect::()); + } + db_arc.unsafe_update_smart_inbox_name(&inbox_name.to_string(), &truncated_content) + .map_err(|e| LLMProviderError::ShinkaiDB(e))?; + + // Get the new folder name after updating + let new_folder = db_arc.get_job_folder_name(job_id) + .map_err(|e| LLMProviderError::ShinkaiDB(e))?; + + // Move the folder if it exists + if old_folder.exists() { + ShinkaiFileManager::move_folder(old_folder, new_folder, db_arc) + .map_err(|e| LLMProviderError::SomeError(format!("Failed to move folder: {}", e)))?; + } + + Ok(()) + } + pub async fn add_to_job_processing_queue( &mut self, message: ShinkaiMessage, @@ -486,13 +515,7 @@ impl JobManager { let db_arc = self.db.upgrade().ok_or("Failed to upgrade shinkai_db").unwrap(); let is_empty = db_arc.is_job_inbox_empty(&job_message.job_id.clone())?; if is_empty { - let mut content = job_message.clone().content; - if content.chars().count() > 120 { - let truncated_content: String = content.chars().take(120).collect(); - content = format!("{}...", truncated_content); - } - let inbox_name = InboxName::get_job_inbox_name_from_params(job_message.job_id.to_string())?.to_string(); - db_arc.update_smart_inbox_name(&inbox_name.to_string(), &content)?; + self.update_job_folder_name(&job_message.job_id, &job_message.content, &db_arc).await?; } db_arc diff --git a/shinkai-bin/shinkai-node/src/llm_provider/parsing_helper.rs b/shinkai-bin/shinkai-node/src/llm_provider/parsing_helper.rs index 28fbf6ae0..984072f00 100644 --- a/shinkai-bin/shinkai-node/src/llm_provider/parsing_helper.rs +++ b/shinkai-bin/shinkai-node/src/llm_provider/parsing_helper.rs @@ -2,22 +2,18 @@ use super::error::LLMProviderError; use super::execution::prompts::general_prompts::JobPromptGenerator; use super::job_manager::JobManager; use super::llm_stopper::LLMStopper; +use shinkai_embedding::embedding_generator::EmbeddingGenerator; +use shinkai_fs::simple_parser::file_parser_helper::ShinkaiFileParser; +use shinkai_fs::simple_parser::text_group::TextGroup; use shinkai_message_primitives::schemas::llm_providers::common_agent_llm_provider::ProviderOrAgent; -use shinkai_message_primitives::shinkai_utils::shinkai_logging::{shinkai_log, ShinkaiLogLevel, ShinkaiLogOption}; use shinkai_sqlite::SqliteManager; -use shinkai_vector_resources::embedding_generator::EmbeddingGenerator; -use shinkai_vector_resources::file_parser::file_parser::ShinkaiFileParser; -use shinkai_vector_resources::file_parser::file_parser_types::TextGroup; -use shinkai_vector_resources::source::{DistributionInfo, SourceFile, SourceFileMap, TextChunkingStrategy}; -use shinkai_vector_resources::vector_resource::{BaseVectorResource, SourceFileType, VRKai, VRPath}; -use shinkai_vector_resources::{data_tags::DataTag, source::VRSourceReference}; use std::collections::HashMap; use std::sync::Arc; -use tokio::sync::RwLock; pub struct ParsingHelper {} impl ParsingHelper { + // TODO: maybe rescue this one /// Given a list of TextGroup, generates a description using the Agent's LLM pub async fn generate_description( text_groups: &Vec, @@ -67,117 +63,4 @@ impl ParsingHelper { Ok(desc) } } - - /// Processes the file buffer through our hierarchical structuring algo, - /// generates all embeddings, uses LLM to generate desc and improve overall structure quality, - /// and returns a finalized BaseVectorResource. If no agent is provided, description defaults to first text in elements. - /// Note: Requires file_name to include the extension ie. `*.pdf` or url `http://...` - #[allow(clippy::too_many_arguments)] - pub async fn process_file_into_resource_gen_desc( - file_buffer: Vec, - generator: &dyn EmbeddingGenerator, - file_name: String, - parsing_tags: &Vec, - agent: Option, - max_node_text_size: u64, - distribution_info: DistributionInfo, - db: Arc, - ) -> Result { - let cleaned_name = ShinkaiFileParser::clean_name(&file_name); - let source = VRSourceReference::from_file(&file_name, TextChunkingStrategy::V1)?; - let text_groups = ShinkaiFileParser::process_file_into_text_groups( - file_buffer, - file_name, - max_node_text_size, - source.clone(), - ) - .await?; - - let mut desc = None; - if let Some(actual_agent) = agent { - desc = Some(Self::generate_description(&text_groups, actual_agent, max_node_text_size, db.clone()).await?); - } else { - let description_text = ShinkaiFileParser::process_groups_into_description( - &text_groups, - max_node_text_size as usize, - max_node_text_size.checked_div(2).unwrap_or(100) as usize, - ); - if !description_text.trim().is_empty() { - desc = Some(description_text); - } - } - - Ok(ShinkaiFileParser::process_groups_into_resource( - text_groups, - generator, - cleaned_name, - desc, - source, - parsing_tags, - max_node_text_size, - distribution_info, - ) - .await?) - } - - /// Processes the list of files into VRKai structs ready to be used/saved/etc. - /// Supports both `.vrkai` files, and standard doc/html/etc which get generated into VRs. - pub async fn process_files_into_vrkai( - files: Vec<(String, Vec, DistributionInfo)>, - generator: &dyn EmbeddingGenerator, - agent: Option, - db: Arc, - ) -> Result, LLMProviderError> { - #[allow(clippy::type_complexity)] - let (vrkai_files, other_files): ( - Vec<(String, Vec, DistributionInfo)>, - Vec<(String, Vec, DistributionInfo)>, - ) = files - .into_iter() - .partition(|(name, _, _dist_info)| name.ends_with(".vrkai")); - let mut processed_vrkais = vec![]; - - // Parse the `.vrkai` files - for vrkai_file in vrkai_files { - let filename = vrkai_file.0; - shinkai_log( - ShinkaiLogOption::JobExecution, - ShinkaiLogLevel::Debug, - &format!("Processing file: {}", filename), - ); - - processed_vrkais.push((filename, VRKai::from_bytes(&vrkai_file.1)?)) - } - - // Parse the other files by generating a Vector Resource from scratch - for file in other_files { - let filename = file.0.clone(); - shinkai_log( - ShinkaiLogOption::JobExecution, - ShinkaiLogLevel::Debug, - &format!("Processing file: {}", filename), - ); - - let resource = ParsingHelper::process_file_into_resource_gen_desc( - file.1.clone(), - generator, - filename.clone(), - &vec![], - agent.clone(), - (generator.model_type().max_input_token_count() - 20) as u64, - file.2.clone(), - db.clone(), - ) - .await?; - - let file_type = SourceFileType::detect_file_type(&file.0)?; - let source = SourceFile::new_standard_source_file(file.0, file_type, file.1, None); - let mut source_map = SourceFileMap::new(HashMap::new()); - source_map.add_source_file(VRPath::root(), source); - - processed_vrkais.push((filename, VRKai::new(resource, Some(source_map)))) - } - - Ok(processed_vrkais) - } } diff --git a/shinkai-bin/shinkai-node/src/llm_provider/providers/ollama.rs b/shinkai-bin/shinkai-node/src/llm_provider/providers/ollama.rs index bc077cc5b..f08d75d9d 100644 --- a/shinkai-bin/shinkai-node/src/llm_provider/providers/ollama.rs +++ b/shinkai-bin/shinkai-node/src/llm_provider/providers/ollama.rs @@ -701,6 +701,5 @@ fn add_options_to_payload( // Add options to payload if not empty if !options.is_empty() { payload["options"] = serde_json::Value::Object(options); - eprintln!("options: {:?}", payload); } } diff --git a/shinkai-bin/shinkai-node/src/llm_provider/providers/shared/shared_model_logic.rs b/shinkai-bin/shinkai-node/src/llm_provider/providers/shared/shared_model_logic.rs index 57efd7b28..c1528429c 100644 --- a/shinkai-bin/shinkai-node/src/llm_provider/providers/shared/shared_model_logic.rs +++ b/shinkai-bin/shinkai-node/src/llm_provider/providers/shared/shared_model_logic.rs @@ -1,7 +1,7 @@ use base64::decode; -use shinkai_message_primitives::schemas::{ +use shinkai_message_primitives::{schemas::{ llm_providers::serialized_llm_provider::LLMProviderInterface, prompts::Prompt, -}; +}, shinkai_utils::utils::count_tokens_from_message_llama3}; use crate::{ llm_provider::error::LLMProviderError, @@ -17,7 +17,7 @@ pub fn llama_prepare_messages( let messages_string = prompt.generate_genericapi_messages(Some(total_tokens), &ModelCapabilitiesManager::num_tokens_from_llama3)?; - let used_tokens = ModelCapabilitiesManager::count_tokens_from_message_llama3(&messages_string); + let used_tokens = count_tokens_from_message_llama3(&messages_string); Ok(PromptResult { messages: PromptResultEnum::Text(messages_string.clone()), diff --git a/shinkai-bin/shinkai-node/src/managers/model_capabilities_manager.rs b/shinkai-bin/shinkai-node/src/managers/model_capabilities_manager.rs index 4876c1904..155c2d330 100644 --- a/shinkai-bin/shinkai-node/src/managers/model_capabilities_manager.rs +++ b/shinkai-bin/shinkai-node/src/managers/model_capabilities_manager.rs @@ -2,7 +2,7 @@ use crate::llm_provider::{ error::LLMProviderError, providers::shared::{openai_api::openai_prepare_messages, shared_model_logic::llama_prepare_messages}, }; -use shinkai_message_primitives::schemas::{ +use shinkai_message_primitives::{schemas::{ llm_message::LlmMessage, llm_providers::{ common_agent_llm_provider::ProviderOrAgent, @@ -10,7 +10,7 @@ use shinkai_message_primitives::schemas::{ }, prompts::Prompt, shinkai_name::ShinkaiName, -}; +}, shinkai_utils::utils::count_tokens_from_message_llama3}; use shinkai_sqlite::SqliteManager; use std::{ fmt, @@ -566,49 +566,6 @@ impl ModelCapabilitiesManager { (buffered_token_count as f64 * 2.6).floor() as usize } - /// Counts the number of tokens from a single message string for llama3 model, - /// where every three normal letters (a-zA-Z) allow an empty space to not be counted, - /// and other symbols are counted as 1 token. - /// This implementation avoids floating point arithmetic by scaling counts. - pub fn count_tokens_from_message_llama3(message: &str) -> usize { - let mut token_count = 0; - let mut alphabetic_count = 0; // Total count of alphabetic characters - let mut space_count = 0; // Total count of spaces - // ^ need to fix this - - // First pass: count alphabetic characters and spaces - for c in message.chars() { - if c.is_ascii_alphabetic() { - alphabetic_count += 1; - } else if c.is_whitespace() { - space_count += 1; - } - } - - // Calculate how many spaces can be ignored - let spaces_to_ignore = alphabetic_count / 3; - - // Determine the alphabetic token weight based on the number of alphabetic characters - let alphabetic_token_weight = if alphabetic_count > 500 { 8 } else { 10 }; - - // Second pass: count tokens, adjusting for spaces that can be ignored - for c in message.chars() { - if c.is_ascii_alphabetic() { - token_count += alphabetic_token_weight; // Counting as 1/3, so add 1 to the scaled count - } else if c.is_whitespace() { - if spaces_to_ignore > 0 { - space_count -= 10; // Reduce the count of spaces to ignore by the scaling factor - } else { - token_count += 30; // Count the space as a full token if not enough alphabetic characters - } - } else { - token_count += 30; // Non-alphabetic characters count as a full token, add 3 to the scaled count - } - } - - (token_count / 30) + 1 // Divide the scaled count by 30 and floor the result, add 1 to account for any remainder - } - /// Counts the number of tokens from the list of messages for llama3 model, /// where every three normal letters (a-zA-Z) allow an empty space to not be counted, /// and other symbols are counted as 1 token. @@ -628,7 +585,7 @@ impl ModelCapabilitiesManager { role_prefix, message.content.as_ref().unwrap_or(&"".to_string()) ); - Self::count_tokens_from_message_llama3(&full_message) + count_tokens_from_message_llama3(&full_message) }) .sum(); diff --git a/shinkai-bin/shinkai-node/src/managers/sheet_manager.rs b/shinkai-bin/shinkai-node/src/managers/sheet_manager.rs index c6cc995ec..812643b0f 100644 --- a/shinkai-bin/shinkai-node/src/managers/sheet_manager.rs +++ b/shinkai-bin/shinkai-node/src/managers/sheet_manager.rs @@ -8,7 +8,7 @@ use shinkai_message_primitives::schemas::ws_types::{WSMessageType, WSUpdateHandl use shinkai_message_primitives::shinkai_message::shinkai_message_schemas::{ CallbackAction, JobCreationInfo, JobMessage, SheetJobAction, SheetManagerAction, WSTopic, }; -use shinkai_message_primitives::shinkai_utils::job_scope::JobScope; +use shinkai_message_primitives::shinkai_utils::job_scope::MinimalJobScope; use shinkai_sheet::cell_name_converter::CellNameConverter; use shinkai_sheet::sheet::{Sheet, SheetUpdate}; use shinkai_sqlite::errors::SqliteManagerError; @@ -209,7 +209,7 @@ impl SheetManager { for job_data in jobs { let job_creation_info = JobCreationInfo { - scope: JobScope::new_default(), + scope: MinimalJobScope::default(), is_hidden: Some(true), associated_ui: None, }; @@ -224,12 +224,13 @@ impl SheetManager { let job_message = JobMessage { job_id: job_id.clone(), content: "".to_string(), // it could be in the sheet_job_data (indirectly through reading the cell) - files_inbox: "".to_string(), // it could be in the sheet_job_data (indirectly through reading the cell) parent: None, sheet_job_data: Some(serde_json::to_string(&job_data).unwrap()), callback: None, metadata: None, tool_key: None, + fs_files_paths: vec![], + job_filenames: vec![], }; job_messages.push((job_message, job_data)); diff --git a/shinkai-bin/shinkai-node/src/managers/tool_router.rs b/shinkai-bin/shinkai-node/src/managers/tool_router.rs index f825797de..30c9d45c3 100644 --- a/shinkai-bin/shinkai-node/src/managers/tool_router.rs +++ b/shinkai-bin/shinkai-node/src/managers/tool_router.rs @@ -4,13 +4,16 @@ use std::time::Instant; use crate::llm_provider::error::LLMProviderError; use crate::llm_provider::execution::chains::inference_chain_trait::{FunctionCall, InferenceChainContextTrait}; +use crate::llm_provider::job_manager::JobManager; use crate::network::v2_api::api_v2_commands_app_files::get_app_folder_path; use crate::network::Node; use crate::tools::tool_definitions::definition_generation::{generate_tool_definitions, get_rust_tools}; +use crate::tools::tool_execution::execution_custom::execute_custom_tool; use crate::tools::tool_execution::execution_header_generator::{check_tool_config, generate_execution_environment}; use crate::utils::environment::fetch_node_environment; use serde::{Deserialize, Serialize}; use serde_json::Value; +use shinkai_embedding::embedding_generator::EmbeddingGenerator; use shinkai_message_primitives::schemas::indexable_version::IndexableVersion; use shinkai_message_primitives::schemas::invoices::{Invoice, InvoiceStatusEnum}; use shinkai_message_primitives::schemas::job::JobLike; @@ -33,11 +36,21 @@ use shinkai_tools_primitives::tools::rust_tools::RustTool; use shinkai_tools_primitives::tools::shinkai_tool::{ShinkaiTool, ShinkaiToolHeader}; use shinkai_tools_primitives::tools::tool_config::ToolConfig; use shinkai_tools_primitives::tools::tool_output_arg::ToolOutputArg; -use shinkai_vector_resources::embedding_generator::EmbeddingGenerator; +use tokio::sync::Mutex; + +use ed25519_dalek::SigningKey; +use x25519_dalek::{PublicKey as EncryptionPublicKey, StaticSecret as EncryptionStaticKey}; + +use super::IdentityManager; #[derive(Clone)] pub struct ToolRouter { pub sqlite_manager: Arc, + pub identity_manager: Arc>, + pub encryption_secret_key: EncryptionStaticKey, + pub encryption_public_key: EncryptionPublicKey, + pub signing_secret_key: SigningKey, + pub job_manager: Option>>, } #[derive(Debug, Clone, Deserialize, Serialize)] @@ -47,8 +60,22 @@ pub struct ToolCallFunctionResponse { } impl ToolRouter { - pub fn new(sqlite_manager: Arc) -> Self { - ToolRouter { sqlite_manager } + pub fn new( + sqlite_manager: Arc, + identity_manager: Arc>, + encryption_secret_key: EncryptionStaticKey, + encryption_public_key: EncryptionPublicKey, + signing_secret_key: SigningKey, + job_manager: Option>>, + ) -> Self { + ToolRouter { + sqlite_manager, + identity_manager, + encryption_secret_key, + encryption_public_key, + signing_secret_key, + job_manager, + } } pub async fn initialization(&self, generator: Box) -> Result<(), ToolError> { @@ -117,6 +144,9 @@ impl ToolRouter { return Ok(()); } + // Start timing before the HTTP request + let start_time = Instant::now(); + let url = env::var("SHINKAI_TOOLS_DIRECTORY_URL") .map_err(|_| ToolError::MissingConfigError("SHINKAI_TOOLS_DIRECTORY_URL not set".to_string()))?; @@ -184,6 +214,10 @@ impl ToolRouter { futures::future::join_all(futures).await; + // Calculate and print the duration + let duration = start_time.elapsed(); + println!("Total time taken to import tools: {:?}", duration); + Ok(()) } @@ -453,7 +487,7 @@ impl ToolRouter { let function_args = function_call.arguments.clone(); match shinkai_tool { - ShinkaiTool::Python(python_tool, _) => { + ShinkaiTool::Python(python_tool, _is_enabled) => { let function_config = shinkai_tool.get_config_from_env(); let function_config_vec: Vec = function_config.into_iter().collect(); @@ -520,25 +554,54 @@ impl ToolRouter { function_call, }); } - ShinkaiTool::Rust(_, _) => { - unimplemented!("Rust tool calls are not supported yet"); - // if let Some(rust_function) = RustToolFunctions::get_tool_function(&function_name) { - // let args: Vec> = RustTool::convert_args_from_fn_call(function_args)?; - // let result = rust_function(context, args) - // .map_err(|e| LLMProviderError::FunctionExecutionError(e.to_string()))?; - // let result_str = result - // .downcast_ref::() - // .ok_or_else(|| { - // LLMProviderError::InvalidFunctionResult(format!("Invalid result: {:?}", result)) - // })? - // .clone(); - // return Ok(ToolCallFunctionResponse { - // response: result_str, - // function_call, - // }); - // } + ShinkaiTool::Rust(_rust_tool, _is_enabled) => { + let app_id = context.full_job().job_id().to_string(); + let tool_id = shinkai_tool.tool_router_key().to_string_without_version().clone(); + let function_config = shinkai_tool.get_config_from_env(); + let function_config_vec: Vec = function_config.into_iter().collect(); + + let db = context.db(); + let llm_provider = context.agent().get_llm_provider_id().to_string(); + let bearer = db.read_api_v2_key().unwrap_or_default().unwrap_or_default(); + + + let job_callback_manager = context.job_callback_manager(); + let mut job_manager: Option>> = None; + if let Some(job_callback_manager) = &job_callback_manager { + let job_callback_manager = job_callback_manager.lock().await; + job_manager = job_callback_manager.job_manager.clone(); + } + + if job_manager.is_none() { + return Err(LLMProviderError::FunctionExecutionError("Job manager is not available".to_string())); + } + + let result = execute_custom_tool( + &shinkai_tool.tool_router_key().to_string_without_version().clone(), + function_args, + tool_id, + app_id, + function_config_vec, + bearer, + db.clone(), + llm_provider, + node_name, + self.identity_manager.clone(), + job_manager.unwrap(), + self.encryption_secret_key.clone(), + self.encryption_public_key.clone(), + self.signing_secret_key.clone(), + ) + .await?; + + let result_str = serde_json::to_string(&result) + .map_err(|e| LLMProviderError::FunctionExecutionError(e.to_string()))?; + return Ok(ToolCallFunctionResponse { + response: result_str, + function_call, + }); } - ShinkaiTool::Deno(deno_tool, _) => { + ShinkaiTool::Deno(deno_tool, _is_enabled) => { let function_config = shinkai_tool.get_config_from_env(); let function_config_vec: Vec = function_config.into_iter().collect(); @@ -605,7 +668,7 @@ impl ToolRouter { function_call, }); } - ShinkaiTool::Network(network_tool, _) => { + ShinkaiTool::Network(network_tool, _is_enabled) => { eprintln!("network tool with name {:?}", network_tool.name); let agent_payments_manager = context.my_agent_payments_manager(); diff --git a/shinkai-bin/shinkai-node/src/network/agent_payments_manager/external_agent_offerings_manager.rs b/shinkai-bin/shinkai-node/src/network/agent_payments_manager/external_agent_offerings_manager.rs index fb9be06c2..e6c243412 100644 --- a/shinkai-bin/shinkai-node/src/network/agent_payments_manager/external_agent_offerings_manager.rs +++ b/shinkai-bin/shinkai-node/src/network/agent_payments_manager/external_agent_offerings_manager.rs @@ -20,7 +20,6 @@ use shinkai_message_primitives::shinkai_utils::shinkai_logging::{shinkai_log, Sh use shinkai_message_primitives::shinkai_utils::shinkai_message_builder::ShinkaiMessageBuilder; use shinkai_message_primitives::shinkai_utils::signatures::clone_signature_secret_key; use shinkai_sqlite::SqliteManager; -use shinkai_vector_fs::vector_fs::vector_fs::VectorFS; use std::collections::HashSet; use std::pin::Pin; use std::result::Result::Ok; @@ -106,7 +105,6 @@ impl ExtAgentOfferingsManager { /// * `Self` - A new instance of `ExtAgentOfferingsManager`. pub async fn new( db: Weak, - vector_fs: Weak, identity_manager: Weak>, node_name: ShinkaiName, my_signature_secret_key: SigningKey, @@ -131,7 +129,6 @@ impl ExtAgentOfferingsManager { let offering_queue_handler = ExtAgentOfferingsManager::process_offerings_queue( offerings_queue_manager.clone(), db.clone(), - vector_fs.clone(), node_name.clone(), my_signature_secret_key.clone(), my_encryption_secret_key.clone(), @@ -141,7 +138,6 @@ impl ExtAgentOfferingsManager { tool_router.clone(), |invoice_payment, db, - vector_fs, node_name, my_signature_secret_key, my_encryption_secret_key, @@ -151,7 +147,6 @@ impl ExtAgentOfferingsManager { ExtAgentOfferingsManager::process_invoice_payment( invoice_payment, db, - vector_fs, node_name, my_signature_secret_key, my_encryption_secret_key, @@ -202,7 +197,6 @@ impl ExtAgentOfferingsManager { pub async fn process_offerings_queue( offering_queue_manager: Arc>>, db: Weak, - vector_fs: Weak, node_name: ShinkaiName, my_signature_secret_key: SigningKey, my_encryption_secret_key: EncryptionStaticKey, @@ -214,7 +208,6 @@ impl ExtAgentOfferingsManager { process_job: impl Fn( Invoice, Weak, - Weak, ShinkaiName, SigningKey, EncryptionStaticKey, @@ -285,7 +278,6 @@ impl ExtAgentOfferingsManager { let processing_jobs = Arc::clone(&processing_jobs); let semaphore = semaphore.clone(); let db = db.clone(); - let vector_fs = vector_fs.clone(); let node_name = node_name.clone(); let my_signature_secret_key = my_signature_secret_key.clone(); let my_encryption_secret_key = my_encryption_secret_key.clone(); @@ -303,7 +295,6 @@ impl ExtAgentOfferingsManager { let result = process_job( invoice.clone(), db.clone(), - vector_fs.clone(), node_name.clone(), my_signature_secret_key.clone(), my_encryption_secret_key.clone(), @@ -396,7 +387,6 @@ impl ExtAgentOfferingsManager { fn process_invoice_payment( _invoice: Invoice, _db: Weak, - _vector_fs: Weak, _node_name: ShinkaiName, _my_signature_secret_key: SigningKey, _my_encryption_secret_key: EncryptionStaticKey, diff --git a/shinkai-bin/shinkai-node/src/network/agent_payments_manager/my_agent_offerings_manager.rs b/shinkai-bin/shinkai-node/src/network/agent_payments_manager/my_agent_offerings_manager.rs index 877d75117..955042107 100644 --- a/shinkai-bin/shinkai-node/src/network/agent_payments_manager/my_agent_offerings_manager.rs +++ b/shinkai-bin/shinkai-node/src/network/agent_payments_manager/my_agent_offerings_manager.rs @@ -21,7 +21,6 @@ use shinkai_sqlite::SqliteManager; use shinkai_tools_primitives::tools::{ network_tool::NetworkTool, parameters::Parameters, shinkai_tool::ShinkaiToolHeader, tool_output_arg::ToolOutputArg, }; -use shinkai_vector_fs::vector_fs::vector_fs::VectorFS; use tokio::sync::{Mutex, RwLock}; use x25519_dalek::StaticSecret as EncryptionStaticKey; @@ -38,7 +37,6 @@ use super::external_agent_offerings_manager::AgentOfferingManagerError; pub struct MyAgentOfferingsManager { pub db: Weak, - pub vector_fs: Weak, pub identity_manager: Weak>, pub node_name: ShinkaiName, // The secret key used for signing operations. @@ -58,7 +56,6 @@ impl MyAgentOfferingsManager { #[allow(clippy::too_many_arguments)] pub async fn new( db: Weak, - vector_fs: Weak, identity_manager: Weak>, node_name: ShinkaiName, my_signature_secret_key: SigningKey, @@ -69,7 +66,6 @@ impl MyAgentOfferingsManager { ) -> Self { Self { db, - vector_fs, node_name, my_signature_secret_key, my_encryption_secret_key, diff --git a/shinkai-bin/shinkai-node/src/network/handle_commands_list.rs b/shinkai-bin/shinkai-node/src/network/handle_commands_list.rs index 74e23d36a..67f4f101c 100644 --- a/shinkai-bin/shinkai-node/src/network/handle_commands_list.rs +++ b/shinkai-bin/shinkai-node/src/network/handle_commands_list.rs @@ -300,7 +300,6 @@ impl Node { } NodeCommand::APIUseRegistrationCode { msg, res } => { let db_clone = Arc::clone(&self.db); - let vec_fs_clone = self.vector_fs.clone(); let identity_manager_clone = self.identity_manager.clone(); let node_name_clone = self.node_name.clone(); let encryption_secret_key_clone = self.encryption_secret_key.clone(); @@ -317,7 +316,6 @@ impl Node { tokio::spawn(async move { let _ = Node::api_handle_registration_code_usage( db_clone, - vec_fs_clone, node_name_clone, encryption_secret_key_clone, first_device_needs_registration_code, @@ -546,67 +544,6 @@ impl Node { .await; }); } - // NodeCommand::APICreateFilesInboxWithSymmetricKey { msg, res } => self.api_create_files_inbox_with_symmetric_key(msg, res).await, - NodeCommand::APICreateFilesInboxWithSymmetricKey { msg, res } => { - let db_clone = Arc::clone(&self.db); - let identity_manager_clone = self.identity_manager.clone(); - let node_name_clone = self.node_name.clone(); - let encryption_secret_key_clone = self.encryption_secret_key.clone(); - let encryption_public_key_clone = self.encryption_public_key; - tokio::spawn(async move { - let _ = Node::api_create_files_inbox_with_symmetric_key( - db_clone, - node_name_clone, - identity_manager_clone, - encryption_secret_key_clone, - encryption_public_key_clone, - msg, - res, - ) - .await; - }); - } - // NodeCommand::APIGetFilenamesInInbox { msg, res } => self.api_get_filenames_in_inbox(msg, res).await, - NodeCommand::APIGetFilenamesInInbox { msg, res } => { - let db_clone = Arc::clone(&self.db); - let identity_manager_clone = self.identity_manager.clone(); - let node_name_clone = self.node_name.clone(); - let encryption_secret_key_clone = self.encryption_secret_key.clone(); - let encryption_public_key_clone = self.encryption_public_key; - tokio::spawn(async move { - let _ = Node::api_get_filenames_in_inbox( - db_clone, - node_name_clone, - identity_manager_clone, - encryption_secret_key_clone, - encryption_public_key_clone, - msg, - res, - ) - .await; - }); - } - // NodeCommand::APIAddFileToInboxWithSymmetricKey { filename, file, public_key, encrypted_nonce, res } => self.api_add_file_to_inbox_with_symmetric_key(filename, file, public_key, encrypted_nonce, res).await, - NodeCommand::APIAddFileToInboxWithSymmetricKey { - filename, - file, - public_key, - encrypted_nonce, - res, - } => { - let db_clone = Arc::clone(&self.db); - tokio::spawn(async move { - let _ = Node::api_add_file_to_inbox_with_symmetric_key( - db_clone, - filename, - file, - public_key, - encrypted_nonce, - res, - ) - .await; - }); - } // NodeCommand::APIGetAllSmartInboxesForProfile { msg, res } => self.api_get_all_smart_inboxes_for_profile(msg, res).await, NodeCommand::APIGetAllSmartInboxesForProfile { msg, res } => { let db_clone = Arc::clone(&self.db); @@ -1034,14 +971,12 @@ impl Node { // NodeCommand::APIVecFSRetrievePathSimplifiedJson { msg, res } => self.api_vec_fs_retrieve_path_simplified_json(msg, res).await, NodeCommand::APIVecFSRetrievePathSimplifiedJson { msg, res } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); let node_name_clone = self.node_name.clone(); let identity_manager_clone = self.identity_manager.clone(); let encryption_secret_key_clone = self.encryption_secret_key.clone(); tokio::spawn(async move { let _ = Node::api_vec_fs_retrieve_path_simplified_json( db_clone, - vector_fs_clone, node_name_clone, identity_manager_clone, encryption_secret_key_clone, @@ -1054,14 +989,12 @@ impl Node { // NodeCommand::APIVecFSRetrievePathMinimalJson { msg, res } => self.api_vec_fs_retrieve_path_minimal_json(msg, res).await, NodeCommand::APIVecFSRetrievePathMinimalJson { msg, res } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); let node_name_clone = self.node_name.clone(); let identity_manager_clone = self.identity_manager.clone(); let encryption_secret_key_clone = self.encryption_secret_key.clone(); tokio::spawn(async move { let _ = Node::api_vec_fs_retrieve_path_minimal_json( db_clone, - vector_fs_clone, node_name_clone, identity_manager_clone, encryption_secret_key_clone, @@ -1071,39 +1004,15 @@ impl Node { .await; }); } - // NodeCommand::APIConvertFilesAndSaveToFolder { msg, res } => self.api_convert_files_and_save_to_folder(msg, res).await, - NodeCommand::APIConvertFilesAndSaveToFolder { msg, res } => { - let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); - let node_name_clone = self.node_name.clone(); - let identity_manager_clone = self.identity_manager.clone(); - let encryption_secret_key_clone = self.encryption_secret_key.clone(); - let embedding_generator_clone = self.embedding_generator.clone(); - tokio::spawn(async move { - let _ = Node::api_convert_files_and_save_to_folder( - db_clone, - vector_fs_clone, - node_name_clone, - identity_manager_clone, - encryption_secret_key_clone, - Arc::new(embedding_generator_clone), - msg, - res, - ) - .await; - }); - } // NodeCommand::APIVecFSRetrieveVectorSearchSimplifiedJson { msg, res } => self.api_vec_fs_retrieve_vector_search_simplified_json(msg, res).await, NodeCommand::APIVecFSRetrieveVectorSearchSimplifiedJson { msg, res } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); let node_name_clone = self.node_name.clone(); let identity_manager_clone = self.identity_manager.clone(); let encryption_secret_key_clone = self.encryption_secret_key.clone(); tokio::spawn(async move { let _ = Node::api_vec_fs_retrieve_vector_search_simplified_json( db_clone, - vector_fs_clone, node_name_clone, identity_manager_clone, encryption_secret_key_clone, @@ -1116,14 +1025,12 @@ impl Node { // NodeCommand::APIVecFSSearchItems { msg, res } => self.api_vec_fs_search_items(msg, res).await, NodeCommand::APIVecFSSearchItems { msg, res } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); let node_name_clone = self.node_name.clone(); let identity_manager_clone = self.identity_manager.clone(); let encryption_secret_key_clone = self.encryption_secret_key.clone(); tokio::spawn(async move { let _ = Node::api_vec_fs_search_items( db_clone, - vector_fs_clone, node_name_clone, identity_manager_clone, encryption_secret_key_clone, @@ -1136,14 +1043,12 @@ impl Node { // NodeCommand::APIVecFSCreateFolder { msg, res } => self.api_vec_fs_create_folder(msg, res).await, NodeCommand::APIVecFSCreateFolder { msg, res } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); let node_name_clone = self.node_name.clone(); let identity_manager_clone = self.identity_manager.clone(); let encryption_secret_key_clone = self.encryption_secret_key.clone(); tokio::spawn(async move { let _ = Node::api_vec_fs_create_folder( db_clone, - vector_fs_clone, node_name_clone, identity_manager_clone, encryption_secret_key_clone, @@ -1156,14 +1061,12 @@ impl Node { // NodeCommand::APIVecFSMoveItem { msg, res } => self.api_vec_fs_move_item(msg, res).await, NodeCommand::APIVecFSMoveItem { msg, res } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); let node_name_clone = self.node_name.clone(); let identity_manager_clone = self.identity_manager.clone(); let encryption_secret_key_clone = self.encryption_secret_key.clone(); tokio::spawn(async move { let _ = Node::api_vec_fs_move_item( db_clone, - vector_fs_clone, node_name_clone, identity_manager_clone, encryption_secret_key_clone, @@ -1176,14 +1079,12 @@ impl Node { // NodeCommand::APIVecFSCopyItem { msg, res } => self.api_vec_fs_copy_item(msg, res).await, NodeCommand::APIVecFSCopyItem { msg, res } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); let node_name_clone = self.node_name.clone(); let identity_manager_clone = self.identity_manager.clone(); let encryption_secret_key_clone = self.encryption_secret_key.clone(); tokio::spawn(async move { let _ = Node::api_vec_fs_copy_item( db_clone, - vector_fs_clone, node_name_clone, identity_manager_clone, encryption_secret_key_clone, @@ -1196,14 +1097,12 @@ impl Node { // NodeCommand::APIVecFSMoveFolder { msg, res } => self.api_vec_fs_move_folder(msg, res).await, NodeCommand::APIVecFSMoveFolder { msg, res } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); let node_name_clone = self.node_name.clone(); let identity_manager_clone = self.identity_manager.clone(); let encryption_secret_key_clone = self.encryption_secret_key.clone(); tokio::spawn(async move { let _ = Node::api_vec_fs_move_folder( db_clone, - vector_fs_clone, node_name_clone, identity_manager_clone, encryption_secret_key_clone, @@ -1216,14 +1115,12 @@ impl Node { // NodeCommand::APIVecFSCopyFolder { msg, res } => self.api_vec_fs_copy_folder(msg, res).await, NodeCommand::APIVecFSCopyFolder { msg, res } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); let node_name_clone = self.node_name.clone(); let identity_manager_clone = self.identity_manager.clone(); let encryption_secret_key_clone = self.encryption_secret_key.clone(); tokio::spawn(async move { let _ = Node::api_vec_fs_copy_folder( db_clone, - vector_fs_clone, node_name_clone, identity_manager_clone, encryption_secret_key_clone, @@ -1236,14 +1133,12 @@ impl Node { // NodeCommand::APIVecFSRetrieveVectorResource { msg, res } => self.api_vec_fs_retrieve_vector_resource(msg, res).await, NodeCommand::APIVecFSRetrieveVectorResource { msg, res } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); let node_name_clone = self.node_name.clone(); let identity_manager_clone = self.identity_manager.clone(); let encryption_secret_key_clone = self.encryption_secret_key.clone(); tokio::spawn(async move { let _ = Node::api_vec_fs_retrieve_vector_resource( db_clone, - vector_fs_clone, node_name_clone, identity_manager_clone, encryption_secret_key_clone, @@ -1256,14 +1151,12 @@ impl Node { // NodeCommand::APIVecFSDeleteFolder { msg, res } => self.api_vec_fs_delete_folder(msg, res).await, NodeCommand::APIVecFSDeleteFolder { msg, res } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); let node_name_clone = self.node_name.clone(); let identity_manager_clone = self.identity_manager.clone(); let encryption_secret_key_clone = self.encryption_secret_key.clone(); tokio::spawn(async move { let _ = Node::api_vec_fs_delete_folder( db_clone, - vector_fs_clone, node_name_clone, identity_manager_clone, encryption_secret_key_clone, @@ -1276,14 +1169,12 @@ impl Node { // NodeCommand::APIVecFSDeleteItem { msg, res } => self.api_vec_fs_delete_item(msg, res).await, NodeCommand::APIVecFSDeleteItem { msg, res } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); let node_name_clone = self.node_name.clone(); let identity_manager_clone = self.identity_manager.clone(); let encryption_secret_key_clone = self.encryption_secret_key.clone(); tokio::spawn(async move { let _ = Node::api_vec_fs_delete_item( db_clone, - vector_fs_clone, node_name_clone, identity_manager_clone, encryption_secret_key_clone, @@ -1296,14 +1187,12 @@ impl Node { // NodeCommand::RetrieveVRKai { msg, res } => self.retrieve_vr_kai(msg, res).await, NodeCommand::RetrieveVRKai { msg, res } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); let node_name_clone = self.node_name.clone(); let identity_manager_clone = self.identity_manager.clone(); let encryption_secret_key_clone = self.encryption_secret_key.clone(); tokio::spawn(async move { let _ = Node::retrieve_vr_kai( db_clone, - vector_fs_clone, node_name_clone, identity_manager_clone, encryption_secret_key_clone, @@ -1316,14 +1205,13 @@ impl Node { // NodeCommand::RetrieveVRPack { msg, res } => self.retrieve_vr_pack(msg, res).await, NodeCommand::RetrieveVRPack { msg, res } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); + let node_name_clone = self.node_name.clone(); let identity_manager_clone = self.identity_manager.clone(); let encryption_secret_key_clone = self.encryption_secret_key.clone(); tokio::spawn(async move { let _ = Node::retrieve_vr_pack( db_clone, - vector_fs_clone, node_name_clone, identity_manager_clone, encryption_secret_key_clone, @@ -1372,26 +1260,6 @@ impl Node { .await; }); } - // NodeCommand::APIUpdateSupportedEmbeddingModels { msg, res } => self.api_update_supported_embedding_models(msg, res).await, - NodeCommand::APIUpdateSupportedEmbeddingModels { msg, res } => { - let db = self.db.clone(); - let vector_fs = self.vector_fs.clone(); - let node_name_clone = self.node_name.clone(); - let identity_manager_clone = self.identity_manager.clone(); - let encryption_secret_key_clone = self.encryption_secret_key.clone(); - tokio::spawn(async move { - let _ = Node::api_update_supported_embedding_models( - db, - vector_fs, - node_name_clone, - identity_manager_clone, - encryption_secret_key_clone, - msg, - res, - ) - .await; - }); - } // // V2 API // @@ -1404,7 +1272,7 @@ impl Node { } NodeCommand::V2ApiInitialRegistration { payload, res } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); + let identity_manager_clone = self.identity_manager.clone(); let node_name_clone = self.node_name.clone(); let first_device_needs_registration_code = self.first_device_needs_registration_code; @@ -1425,7 +1293,6 @@ impl Node { payload, public_https_certificate, res, - vector_fs_clone, first_device_needs_registration_code, embedding_generator_clone, job_manager, @@ -1603,12 +1470,11 @@ impl Node { } NodeCommand::V2ApiVecFSRetrievePathSimplifiedJson { bearer, payload, res } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); + let identity_manager_clone = self.identity_manager.clone(); tokio::spawn(async move { let _ = Node::v2_api_vec_fs_retrieve_path_simplified_json( db_clone, - vector_fs_clone, identity_manager_clone, payload, bearer, @@ -1617,151 +1483,117 @@ impl Node { .await; }); } - NodeCommand::V2ApiConvertFilesAndSaveToFolder { payload, bearer, res } => { - let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); - let identity_manager_clone = self.identity_manager.clone(); - let embedding_generator_clone = self.embedding_generator.clone(); - tokio::spawn(async move { - let _ = Node::v2_convert_files_and_save_to_folder( - db_clone, - vector_fs_clone, - identity_manager_clone, - payload, - Arc::new(embedding_generator_clone), - bearer, - res, - ) - .await; - }); - } NodeCommand::V2ApiVecFSCreateFolder { bearer, payload, res } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); + let identity_manager_clone = self.identity_manager.clone(); tokio::spawn(async move { - let _ = - Node::v2_create_folder(db_clone, vector_fs_clone, identity_manager_clone, payload, bearer, res) - .await; + let _ = Node::v2_create_folder(db_clone, identity_manager_clone, payload, bearer, res).await; }); } NodeCommand::V2ApiMoveItem { bearer, payload, res } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); + let identity_manager_clone = self.identity_manager.clone(); tokio::spawn(async move { - let _ = Node::v2_move_item(db_clone, vector_fs_clone, identity_manager_clone, payload, bearer, res) - .await; + let _ = Node::v2_move_item(db_clone, identity_manager_clone, payload, bearer, res).await; }); } NodeCommand::V2ApiCopyItem { bearer, payload, res } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); + let identity_manager_clone = self.identity_manager.clone(); tokio::spawn(async move { - let _ = Node::v2_copy_item(db_clone, vector_fs_clone, identity_manager_clone, payload, bearer, res) - .await; + let _ = Node::v2_copy_item(db_clone, identity_manager_clone, payload, bearer, res).await; }); } NodeCommand::V2ApiMoveFolder { bearer, payload, res } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); + let identity_manager_clone = self.identity_manager.clone(); tokio::spawn(async move { - let _ = - Node::v2_move_folder(db_clone, vector_fs_clone, identity_manager_clone, payload, bearer, res) - .await; + let _ = Node::v2_move_folder(db_clone, identity_manager_clone, payload, bearer, res).await; }); } NodeCommand::V2ApiCopyFolder { bearer, payload, res } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); + let identity_manager_clone = self.identity_manager.clone(); tokio::spawn(async move { - let _ = - Node::v2_copy_folder(db_clone, vector_fs_clone, identity_manager_clone, payload, bearer, res) - .await; + let _ = Node::v2_copy_folder(db_clone, identity_manager_clone, payload, bearer, res).await; }); } NodeCommand::V2ApiDeleteFolder { bearer, payload, res } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); + let identity_manager_clone = self.identity_manager.clone(); tokio::spawn(async move { - let _ = - Node::v2_delete_folder(db_clone, vector_fs_clone, identity_manager_clone, payload, bearer, res) - .await; + let _ = Node::v2_delete_folder(db_clone, identity_manager_clone, payload, bearer, res).await; }); } NodeCommand::V2ApiDeleteItem { bearer, payload, res } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); + let identity_manager_clone = self.identity_manager.clone(); tokio::spawn(async move { - let _ = - Node::v2_delete_item(db_clone, vector_fs_clone, identity_manager_clone, payload, bearer, res) - .await; + let _ = Node::v2_delete_item(db_clone, identity_manager_clone, payload, bearer, res).await; }); } NodeCommand::V2ApiSearchItems { bearer, payload, res } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); - let identity_manager_clone = self.identity_manager.clone(); - tokio::spawn(async move { - let _ = - Node::v2_search_items(db_clone, vector_fs_clone, identity_manager_clone, payload, bearer, res) - .await; - }); - } - NodeCommand::V2ApiVecFSRetrieveVectorResource { bearer, path, res } => { - let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); + let embedding_generator_clone = self.embedding_generator.clone(); + let identity_manager_clone = self.identity_manager.clone(); tokio::spawn(async move { - let _ = Node::v2_retrieve_vector_resource( + let _ = Node::v2_search_items( db_clone, - vector_fs_clone, identity_manager_clone, - path, + payload, + Arc::new(embedding_generator_clone), bearer, res, ) .await; }); } - NodeCommand::V2ApiUpdateSmartInboxName { - bearer, - inbox_name, - custom_name, - res, - } => { + NodeCommand::V2ApiVecFSRetrieveVectorResource { bearer, path, res } => { let db_clone = Arc::clone(&self.db); + + let identity_manager_clone = self.identity_manager.clone(); tokio::spawn(async move { - let _ = Node::v2_update_smart_inbox_name(db_clone, bearer, inbox_name, custom_name, res).await; + let _ = + Node::v2_retrieve_vector_resource(db_clone, identity_manager_clone, path, bearer, res).await; }); } - NodeCommand::V2ApiCreateFilesInbox { bearer, res } => { + NodeCommand::V2ApiVecFSRetrieveFilesForJob { bearer, job_id, res } => { let db_clone = Arc::clone(&self.db); + let identity_manager_clone = self.identity_manager.clone(); tokio::spawn(async move { - let _ = Node::v2_create_files_inbox(db_clone, bearer, res).await; + let _ = Node::v2_api_vec_fs_retrieve_files_for_job(db_clone, identity_manager_clone, job_id, bearer, res).await; }); } - NodeCommand::V2ApiAddFileToInbox { - file_inbox_name, - filename, - file, + NodeCommand::V2ApiVecFSGetFolderNameForJob { bearer, job_id, res } => { + let db_clone = Arc::clone(&self.db); + let identity_manager_clone = self.identity_manager.clone(); + tokio::spawn(async move { + let _ = Node::v2_api_vec_fs_get_folder_name_for_job(db_clone, identity_manager_clone, job_id, bearer, res).await; + }); + } + NodeCommand::V2ApiUpdateSmartInboxName { bearer, + inbox_name, + custom_name, res, } => { let db_clone = Arc::clone(&self.db); tokio::spawn(async move { - let _ = Node::v2_add_file_to_inbox(db_clone, file_inbox_name, filename, file, bearer, res).await; + let _ = Node::v2_update_smart_inbox_name(db_clone, bearer, inbox_name, custom_name, res).await; }); } NodeCommand::V2ApiUploadFileToFolder { @@ -1773,13 +1605,12 @@ impl Node { res, } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); + let identity_manager_clone = self.identity_manager.clone(); let embedding_generator_clone = self.embedding_generator.clone(); tokio::spawn(async move { let _ = Node::v2_upload_file_to_folder( db_clone, - vector_fs_clone, identity_manager_clone, Arc::new(embedding_generator_clone), bearer, @@ -1792,22 +1623,40 @@ impl Node { .await; }); } - NodeCommand::V2ApiRetrieveSourceFile { bearer, payload, res } => { + NodeCommand::V2ApiUploadFileToJob { + bearer, + job_id, + filename, + file, + file_datetime, + res, + } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); let identity_manager_clone = self.identity_manager.clone(); + let embedding_generator_clone = self.embedding_generator.clone(); tokio::spawn(async move { - let _ = Node::v2_retrieve_source_file( + let _ = Node::v2_upload_file_to_job( db_clone, - vector_fs_clone, identity_manager_clone, - payload, + Arc::new(embedding_generator_clone), bearer, + job_id, + filename, + file, + file_datetime, res, ) .await; }); } + NodeCommand::V2ApiRetrieveFile { bearer, payload, res } => { + let db_clone = Arc::clone(&self.db); + + let identity_manager_clone = self.identity_manager.clone(); + tokio::spawn(async move { + let _ = Node::v2_retrieve_file(db_clone, identity_manager_clone, payload, bearer, res).await; + }); + } NodeCommand::V2ApiGetDefaultEmbeddingModel { bearer, res } => { let db = self.db.clone(); tokio::spawn(async move { @@ -1830,22 +1679,6 @@ impl Node { let _ = Node::v2_api_update_default_embedding_model(db, bearer, model_name, res).await; }); } - NodeCommand::V2ApiUpdateSupportedEmbeddingModels { bearer, models, res } => { - let db = self.db.clone(); - let vector_fs = self.vector_fs.clone(); - let identity_manager_clone = self.identity_manager.clone(); - tokio::spawn(async move { - let _ = Node::v2_api_update_supported_embedding_models( - db, - vector_fs, - identity_manager_clone, - bearer, - models, - res, - ) - .await; - }); - } NodeCommand::V2ApiAddLlmProvider { bearer, agent, res } => { let db_clone = Arc::clone(&self.db); let identity_manager_clone = self.identity_manager.clone(); @@ -2036,27 +1869,28 @@ impl Node { .await; }); } - NodeCommand::V2ApiDownloadFileFromInbox { - bearer, - inbox_name, - filename, - res, - } => { - let db_clone = Arc::clone(&self.db); - tokio::spawn(async move { - let _ = Node::v2_api_download_file_from_inbox(db_clone, bearer, inbox_name, filename, res).await; - }); - } - NodeCommand::V2ApiListFilesInInbox { - bearer, - inbox_name, - res, - } => { - let db_clone = Arc::clone(&self.db); - tokio::spawn(async move { - let _ = Node::v2_api_list_files_in_inbox(db_clone, bearer, inbox_name, res).await; - }); - } + // TODO: repurpose + // NodeCommand::V2ApiDownloadFileFromInbox { + // bearer, + // inbox_name, + // filename, + // res, + // } => { + // let db_clone = Arc::clone(&self.db); + // tokio::spawn(async move { + // let _ = Node::v2_api_download_file_from_inbox(db_clone, bearer, inbox_name, filename, res).await; + // }); + // } + // NodeCommand::V2ApiListFilesInInbox { + // bearer, + // inbox_name, + // res, + // } => { + // let db_clone = Arc::clone(&self.db); + // tokio::spawn(async move { + // let _ = Node::v2_api_list_files_in_inbox(db_clone, bearer, inbox_name, res).await; + // }); + // } NodeCommand::V2ApiGetToolOffering { bearer, tool_key_name, @@ -2403,14 +2237,13 @@ impl Node { } NodeCommand::V2ApiSetSheetUploadedFiles { bearer, payload, res } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); + let identity_manager_clone = self.identity_manager.clone(); let sheet_manager_clone = self.sheet_manager.clone(); tokio::spawn(async move { let _ = Node::v2_set_sheet_uploaded_files( db_clone, - vector_fs_clone, identity_manager_clone, sheet_manager_clone, payload, @@ -2432,7 +2265,7 @@ impl Node { res, } => { let db_clone = Arc::clone(&self.db); - let vector_fs_clone = self.vector_fs.clone(); + let node_name = self.node_name.clone(); let job_manager = self.job_manager.clone().unwrap(); let identity_manager = self.identity_manager.clone(); @@ -2445,7 +2278,6 @@ impl Node { bearer, node_name, db_clone, - vector_fs_clone, tool_router_key, parameters, tool_id, diff --git a/shinkai-bin/shinkai-node/src/network/network_manager/network_job_manager.rs b/shinkai-bin/shinkai-node/src/network/network_manager/network_job_manager.rs index b0751ecd0..fb6abd42b 100644 --- a/shinkai-bin/shinkai-node/src/network/network_manager/network_job_manager.rs +++ b/shinkai-bin/shinkai-node/src/network/network_manager/network_job_manager.rs @@ -18,7 +18,7 @@ use shinkai_message_primitives::shinkai_utils::encryption::clone_static_secret_k use shinkai_message_primitives::shinkai_utils::shinkai_logging::{shinkai_log, ShinkaiLogLevel, ShinkaiLogOption}; use shinkai_message_primitives::shinkai_utils::signatures::clone_signature_secret_key; use shinkai_sqlite::SqliteManager; -use shinkai_vector_fs::vector_fs::vector_fs::VectorFS; + use std::cmp::Ordering; use std::collections::HashSet; use std::net::SocketAddr; @@ -27,8 +27,8 @@ use std::result::Result::Ok; use std::sync::Weak; use std::{collections::HashMap, sync::Arc}; use std::{env, mem}; -use tokio::sync::RwLock; use tokio::sync::{Mutex, Semaphore}; + use x25519_dalek::StaticSecret as EncryptionStaticKey; use super::network_handlers::{ @@ -81,7 +81,6 @@ impl NetworkJobManager { // TODO: change to Weak> pub async fn new( db: Weak, - vector_fs: Weak, my_node_name: ShinkaiName, my_encryption_secret_key: EncryptionStaticKey, my_signature_secret_key: SigningKey, @@ -116,7 +115,6 @@ impl NetworkJobManager { // Start processing the job queue let job_queue_handler = NetworkJobManager::process_job_queue( db.clone(), - vector_fs.clone(), my_node_name.clone(), clone_static_secret_key(&my_encryption_secret_key), clone_signature_secret_key(&my_signature_secret_key), @@ -129,7 +127,6 @@ impl NetworkJobManager { ws_manager.clone(), |job, db, - vector_fs, my_node_profile_name, my_encryption_secret_key, my_signature_secret_key, @@ -141,7 +138,6 @@ impl NetworkJobManager { Box::pin(NetworkJobManager::process_network_request_queued( job, db, - vector_fs, my_node_profile_name, my_encryption_secret_key, my_signature_secret_key, @@ -164,7 +160,6 @@ impl NetworkJobManager { #[allow(clippy::too_many_arguments)] pub async fn process_job_queue( db: Weak, - vector_fs: Weak, my_node_profile_name: ShinkaiName, my_encryption_secret_key: EncryptionStaticKey, my_signature_secret_key: SigningKey, @@ -177,8 +172,7 @@ impl NetworkJobManager { ws_manager: Option>>, job_processing_fn: impl Fn( NetworkJobQueue, // job to process - Weak, // db - Weak, // vector_fs + Weak, // db ShinkaiName, // my_profile_name EncryptionStaticKey, // my_encryption_secret_key SigningKey, // my_signature_secret_key @@ -195,7 +189,6 @@ impl NetworkJobManager { let job_queue_manager = Arc::clone(&job_queue_manager); let mut receiver = job_queue_manager.lock().await.subscribe_to_all().await; let db_clone = db.clone(); - let vector_fs_clone = vector_fs.clone(); let my_node_profile_name_clone = my_node_profile_name.clone(); let my_encryption_sk_clone = clone_static_secret_key(&my_encryption_secret_key); let my_signature_sk_clone = clone_signature_secret_key(&my_signature_secret_key); @@ -256,7 +249,6 @@ impl NetworkJobManager { let processing_jobs = Arc::clone(&processing_jobs); let semaphore = Arc::clone(&semaphore); let db_clone_2 = db_clone.clone(); - let vector_fs_clone_2 = vector_fs_clone.clone(); let my_node_profile_name_clone_2 = my_node_profile_name_clone.clone(); let my_encryption_sk_clone_2 = clone_static_secret_key(&my_encryption_sk_clone); let my_signature_sk_clone_2 = clone_signature_secret_key(&my_signature_sk_clone); @@ -297,7 +289,6 @@ impl NetworkJobManager { let result = job_processing_fn( job.clone(), db_clone_2, - vector_fs_clone_2, my_node_profile_name_clone_2, my_encryption_sk_clone_2, my_signature_sk_clone_2, @@ -390,7 +381,6 @@ impl NetworkJobManager { pub async fn process_network_request_queued( job: NetworkJobQueue, db: Weak, - vector_fs: Weak, my_node_profile_name: ShinkaiName, my_encryption_secret_key: EncryptionStaticKey, my_signature_secret_key: SigningKey, diff --git a/shinkai-bin/shinkai-node/src/network/network_manager/network_job_manager_error.rs b/shinkai-bin/shinkai-node/src/network/network_manager/network_job_manager_error.rs index 8e4bf88c1..0094440b7 100644 --- a/shinkai-bin/shinkai-node/src/network/network_manager/network_job_manager_error.rs +++ b/shinkai-bin/shinkai-node/src/network/network_manager/network_job_manager_error.rs @@ -1,8 +1,6 @@ use std::fmt; use shinkai_message_primitives::schemas::shinkai_name::ShinkaiNameError; -use shinkai_vector_fs::vector_fs::vector_fs_error::VectorFSError; - use crate::network::agent_payments_manager::external_agent_offerings_manager::AgentOfferingManagerError; // Define your new error type @@ -73,12 +71,6 @@ impl From<&str> for NetworkJobQueueError { } } -impl From for NetworkJobQueueError { - fn from(err: VectorFSError) -> NetworkJobQueueError { - NetworkJobQueueError::Other(format!("VectorFS error: {}", err)) - } -} - impl From for NetworkJobQueueError { fn from(err: AgentOfferingManagerError) -> NetworkJobQueueError { NetworkJobQueueError::Other(format!("AgentOfferingManager error: {}", err)) diff --git a/shinkai-bin/shinkai-node/src/network/node.rs b/shinkai-bin/shinkai-node/src/network/node.rs index 0e44ba398..01caafb9e 100644 --- a/shinkai-bin/shinkai-node/src/network/node.rs +++ b/shinkai-bin/shinkai-node/src/network/node.rs @@ -18,12 +18,15 @@ use crate::wallet::wallet_manager::WalletManager; use async_channel::Receiver; use chashmap::CHashMap; use chrono::Utc; +use shinkai_message_primitives::shinkai_utils::shinkai_path::ShinkaiPath; use core::panic; use ed25519_dalek::{Signer, SigningKey, VerifyingKey}; use futures::{future::FutureExt, pin_mut, prelude::*, select}; use rand::rngs::OsRng; use rand::RngCore; use reqwest::StatusCode; +use shinkai_embedding::embedding_generator::{EmbeddingGenerator, RemoteEmbeddingGenerator}; +use shinkai_embedding::model_type::EmbeddingModelType; use shinkai_http_api::node_api_router::APIError; use shinkai_http_api::node_commands::NodeCommand; use shinkai_message_primitives::schemas::llm_providers::serialized_llm_provider::SerializedLLMProvider; @@ -40,9 +43,6 @@ use shinkai_message_primitives::shinkai_utils::signatures::clone_signature_secre use shinkai_sqlite::errors::SqliteManagerError; use shinkai_sqlite::SqliteManager; use shinkai_tcp_relayer::NetworkMessage; -use shinkai_vector_fs::vector_fs::vector_fs::VectorFS; -use shinkai_vector_resources::embedding_generator::{EmbeddingGenerator, RemoteEmbeddingGenerator}; -use shinkai_vector_resources::model_type::EmbeddingModelType; use std::convert::TryInto; use std::sync::Arc; use std::{io, net::SocketAddr, time::Duration}; @@ -50,6 +50,8 @@ use tokio::io::{AsyncReadExt, AsyncWriteExt, ReadHalf, WriteHalf}; use tokio::net::{TcpListener, TcpStream}; use tokio::sync::Mutex; use x25519_dalek::{PublicKey as EncryptionPublicKey, StaticSecret as EncryptionStaticKey}; +use std::fs; +use std::path::Path; // A type alias for a string that represents a profile name. type ProfileName = String; @@ -102,8 +104,6 @@ pub struct Node { pub job_manager: Option>>, // Cron Manager pub cron_manager: Option>>, - // The Node's VectorFS - pub vector_fs: Arc, // An EmbeddingGenerator initialized with the Node's default embedding model + server info pub embedding_generator: RemoteEmbeddingGenerator, /// Rate Limiter @@ -161,7 +161,6 @@ impl Node { proxy_identity: Option, first_device_needs_registration_code: bool, initial_llm_providers: Vec, - vector_fs_db_path: String, embedding_generator: Option, ws_address: Option, default_embedding_model: EmbeddingModelType, @@ -206,27 +205,6 @@ impl Node { .unwrap(); let identity_manager = Arc::new(Mutex::new(subidentity_manager)); - // Fetch list of existing profiles from the node to push into the VectorFS - let profile_list = match db_arc.get_all_profiles(node_name.clone()) { - Ok(profiles) => profiles.iter().map(|p| p.full_identity_name.clone()).collect(), - Err(e) => panic!("Failed to fetch profiles: {}", e), - }; - - // Initialize/setup the VectorFS. - let vector_fs = VectorFS::new( - embedding_generator.clone(), - vec![embedding_generator.model_type.clone()], - profile_list, - db_arc.clone(), - node_name.clone(), - ) - .await - .unwrap_or_else(|e| { - eprintln!("Error: {:?}", e); - panic!("Failed to load VectorFS from database: {}", vector_fs_db_path) - }); - let vector_fs_arc = Arc::new(vector_fs); - let max_connections: u32 = std::env::var("MAX_CONNECTIONS") .unwrap_or_else(|_| "5".to_string()) .parse::() @@ -288,7 +266,14 @@ impl Node { }); // Initialize ToolRouter - let tool_router = ToolRouter::new(db_arc.clone()); + let tool_router = ToolRouter::new( + db_arc.clone(), + identity_manager.clone(), + clone_static_secret_key(&encryption_secret_key), + encryption_public_key, + clone_signature_secret_key(&identity_secret_key), + None, + ); // Read wallet_manager from db if it exists, if not, None let mut wallet_manager: Option = match db_arc.read_wallet_manager() { @@ -324,7 +309,6 @@ impl Node { let my_agent_payments_manager = Arc::new(Mutex::new( MyAgentOfferingsManager::new( Arc::downgrade(&db_arc), - Arc::downgrade(&vector_fs_arc), Arc::downgrade(&identity_manager_trait), node_name.clone(), clone_signature_secret_key(&identity_secret_key), @@ -339,7 +323,6 @@ impl Node { let ext_agent_payments_manager = Arc::new(Mutex::new( ExtAgentOfferingsManager::new( Arc::downgrade(&db_arc), - Arc::downgrade(&vector_fs_arc), Arc::downgrade(&identity_manager_trait), node_name.clone(), clone_signature_secret_key(&identity_secret_key), @@ -354,7 +337,6 @@ impl Node { // Create NetworkJobManager with a weak reference to this node let network_manager = NetworkJobManager::new( Arc::downgrade(&db_arc), - Arc::downgrade(&vector_fs_arc), node_name.clone(), clone_static_secret_key(&encryption_secret_key), clone_signature_secret_key(&identity_secret_key), @@ -417,7 +399,6 @@ impl Node { cron_manager: None, first_device_needs_registration_code, initial_llm_providers, - vector_fs: vector_fs_arc.clone(), embedding_generator, conn_limiter, network_job_manager: Arc::new(Mutex::new(network_manager)), @@ -442,7 +423,17 @@ impl Node { // Start the node's operations. pub async fn start(&mut self) -> Result<(), NodeError> { let db_weak = Arc::downgrade(&self.db); - let vector_fs_weak = Arc::downgrade(&self.vector_fs); + + { + let vr_path = ShinkaiPath::from_base_path(); + + // Check if the directory exists, and create it if it doesn't + if !Path::new(&vr_path.as_path()).exists() { + fs::create_dir_all(&vr_path.as_path()).map_err(|e| { + NodeError::from(format!("Failed to create directory {}: {}", vr_path.as_path().display(), e)) + })?; + } + } let job_manager = Arc::new(Mutex::new( JobManager::new( @@ -450,7 +441,6 @@ impl Node { Arc::clone(&self.identity_manager), clone_signature_secret_key(&self.identity_secret_key), self.node_name.clone(), - vector_fs_weak.clone(), self.embedding_generator.clone(), self.ws_manager_trait.clone(), self.tool_router.clone(), diff --git a/shinkai-bin/shinkai-node/src/network/node_error.rs b/shinkai-bin/shinkai-node/src/network/node_error.rs index a82075dc9..8a5e9dd0b 100644 --- a/shinkai-bin/shinkai-node/src/network/node_error.rs +++ b/shinkai-bin/shinkai-node/src/network/node_error.rs @@ -4,8 +4,6 @@ use shinkai_message_primitives::{ }; use shinkai_sqlite::errors::SqliteManagerError; use shinkai_tools_primitives::tools::error::ToolError; -use shinkai_vector_fs::vector_fs::vector_fs_error::VectorFSError; -use shinkai_vector_resources::resource_errors::VRError; use crate::llm_provider::error::LLMProviderError; @@ -46,22 +44,6 @@ impl From for NodeError { } } -impl From for NodeError { - fn from(err: VectorFSError) -> NodeError { - NodeError { - message: format!("{}", err), - } - } -} - -impl From for NodeError { - fn from(err: VRError) -> NodeError { - NodeError { - message: format!("{}", err), - } - } -} - impl From for NodeError { fn from(err: ShinkaiMessageError) -> NodeError { NodeError { @@ -115,3 +97,11 @@ impl From for NodeError { NodeError { message: error } } } + +impl From for NodeError { + fn from(err: serde_json::Error) -> NodeError { + NodeError { + message: format!("Serde JSON error: {}", err), + } + } +} diff --git a/shinkai-bin/shinkai-node/src/network/v1_api/api_v1_commands.rs b/shinkai-bin/shinkai-node/src/network/v1_api/api_v1_commands.rs index dc91a6f80..c7c89e1c0 100644 --- a/shinkai-bin/shinkai-node/src/network/v1_api/api_v1_commands.rs +++ b/shinkai-bin/shinkai-node/src/network/v1_api/api_v1_commands.rs @@ -18,6 +18,8 @@ use log::error; use reqwest::StatusCode; use serde_json::{json, Value as JsonValue}; +use shinkai_embedding::embedding_generator::RemoteEmbeddingGenerator; +use shinkai_embedding::model_type::EmbeddingModelType; use shinkai_http_api::api_v1::api_v1_handlers::APIUseRegistrationCodeSuccessResponse; use shinkai_http_api::node_api_router::{APIError, SendResponseBodyData}; use shinkai_message_primitives::schemas::identity::{ @@ -51,9 +53,7 @@ use shinkai_message_primitives::{ use shinkai_sqlite::errors::SqliteManagerError; use shinkai_sqlite::SqliteManager; use shinkai_tools_primitives::tools::shinkai_tool::ShinkaiTool; -use shinkai_vector_fs::vector_fs::vector_fs::VectorFS; -use shinkai_vector_resources::embedding_generator::RemoteEmbeddingGenerator; -use shinkai_vector_resources::model_type::EmbeddingModelType; + use std::{convert::TryInto, env, sync::Arc, time::Instant}; use tokio::sync::Mutex; use x25519_dalek::{PublicKey as EncryptionPublicKey, StaticSecret as EncryptionStaticKey}; @@ -617,7 +617,7 @@ impl Node { #[allow(clippy::too_many_arguments)] pub async fn api_handle_registration_code_usage( db: Arc, - vector_fs: Arc, + node_name: ShinkaiName, encryption_secret_key: EncryptionStaticKey, first_device_needs_registration_code: bool, @@ -711,7 +711,6 @@ impl Node { Self::handle_registration_code_usage( db, - vector_fs, node_name, first_device_needs_registration_code, embedding_generator, @@ -733,7 +732,6 @@ impl Node { #[allow(clippy::too_many_arguments)] pub async fn handle_registration_code_usage( db: Arc, - vector_fs: Arc, node_name: ShinkaiName, first_device_needs_registration_code: bool, embedding_generator: Arc, @@ -835,7 +833,7 @@ impl Node { // If any new profile has been created using the registration code, we update the VectorFS // to initialize the new profile - let profile_list = match db.get_all_profiles(node_name.clone()) { + let profile_list: Vec = match db.get_all_profiles(node_name.clone()) { Ok(profiles) => profiles.iter().map(|p| p.full_identity_name.clone()).collect(), Err(e) => panic!("Failed to fetch profiles: {}", e), }; @@ -844,15 +842,16 @@ impl Node { let models = supported_embedding_models.lock().await; models.clone() }; - vector_fs - .initialize_new_profiles( - &node_name, - profile_list, - embedding_generator.model_type.clone(), - supported_models, - create_default_folders, - ) - .await?; + // TODO: migrate + // vector_fs + // .initialize_new_profiles( + // &node_name, + // profile_list, + // embedding_generator.model_type.clone(), + // supported_models, + // create_default_folders, + // ) + // .await?; match result { Ok(success) => { @@ -2556,135 +2555,6 @@ impl Node { Ok(hash_hex) } - #[allow(clippy::too_many_arguments)] - pub async fn api_get_filenames_in_inbox( - db: Arc, - node_name: ShinkaiName, - identity_manager: Arc>, - encryption_secret_key: EncryptionStaticKey, - encryption_public_key: EncryptionPublicKey, - potentially_encrypted_msg: ShinkaiMessage, - res: Sender, APIError>>, - ) -> Result<(), NodeError> { - // Validate the message - let validation_result = Self::validate_message( - encryption_secret_key.clone(), - identity_manager.clone(), - &node_name, - potentially_encrypted_msg, - Some(MessageSchemaType::TextContent), - ) - .await; - let msg = match validation_result { - Ok((msg, _)) => msg, - Err(api_error) => { - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - // Decrypt the message - let decrypted_msg = msg.decrypt_outer_layer(&encryption_secret_key, &encryption_public_key)?; - - // Extract the content of the message - let hex_blake3_hash = decrypted_msg.get_message_content()?; - - match db.get_all_filenames_from_inbox(hex_blake3_hash) { - Ok(filenames) => { - let _ = res.send(Ok(filenames)).await; - Ok(()) - } - Err(err) => { - let _ = res - .send(Err(APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("{}", err), - })) - .await; - Ok(()) - } - } - } - - pub async fn api_add_file_to_inbox_with_symmetric_key( - db: Arc, - filename: String, - file_data: Vec, - hex_blake3_hash: String, - encrypted_nonce: String, - res: Sender>, - ) -> Result<(), NodeError> { - let private_key_array = { - match db.read_symmetric_key(&hex_blake3_hash) { - Ok(key) => key, - Err(_) => { - let _ = res - .send(Err(APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Invalid public key".to_string(), - })) - .await; - return Ok(()); - } - } - }; - - let private_key_slice = &private_key_array[..]; - let private_key_generic_array = GenericArray::from_slice(private_key_slice); - let cipher = Aes256Gcm::new(private_key_generic_array); - - // Assuming `encrypted_nonce` is a hex string of the nonce used in encryption - let nonce_bytes = hex::decode(&encrypted_nonce).unwrap(); - let nonce = GenericArray::from_slice(&nonce_bytes); - - // Decrypt file - let decrypted_file_result = cipher.decrypt(nonce, file_data.as_ref()); - let decrypted_file = match decrypted_file_result { - Ok(file) => file, - Err(_) => { - let _ = res - .send(Err(APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Failed to decrypt the file.".to_string(), - })) - .await; - return Ok(()); - } - }; - - shinkai_log( - ShinkaiLogOption::DetailedAPI, - ShinkaiLogLevel::Debug, - format!( - "api_add_file_to_inbox_with_symmetric_key> filename: {}, hex_blake3_hash: {}, decrypted_file.len(): {}", - filename, - hex_blake3_hash, - decrypted_file.len() - ) - .as_str(), - ); - - match db.add_file_to_files_message_inbox(hex_blake3_hash, filename, decrypted_file) { - Ok(_) => { - let _ = res.send(Ok("File added successfully".to_string())).await; - Ok(()) - } - Err(err) => { - let _ = res - .send(Err(APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("{}", err), - })) - .await; - Ok(()) - } - } - } - pub async fn api_is_pristine(db: Arc, res: Sender>) -> Result<(), NodeError> { let has_any_profile = db.has_any_profile().unwrap_or(false); let _ = res.send(Ok(!has_any_profile)).await; @@ -3095,81 +2965,6 @@ impl Node { } } - pub async fn api_update_supported_embedding_models( - db: Arc, - vector_fs: Arc, - node_name: ShinkaiName, - identity_manager: Arc>, - encryption_secret_key: EncryptionStaticKey, - potentially_encrypted_msg: ShinkaiMessage, - res: Sender>, - ) -> Result<(), NodeError> { - let (new_supported_models_str, requester_name) = match Self::validate_and_extract_payload::>( - node_name.clone(), - identity_manager.clone(), - encryption_secret_key, - potentially_encrypted_msg, - MessageSchemaType::UpdateSupportedEmbeddingModels, - ) - .await - { - Ok(data) => data, - Err(api_error) => { - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - // Validation: requester_name node should be me - if requester_name.get_node_name_string() != node_name.clone().get_node_name_string() { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Invalid node name provided".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - - // Convert the strings to EmbeddingModelType - let new_supported_models: Vec = new_supported_models_str - .into_iter() - .map(|s| EmbeddingModelType::from_string(&s).expect("Failed to parse embedding model")) - .collect(); - - // Update the supported embedding models in the database - if let Err(err) = db.update_supported_embedding_models(new_supported_models.clone()) { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to update supported embedding models: {}", err), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - - match vector_fs - .set_profile_supported_models(&requester_name, &requester_name, new_supported_models) - .await - { - Ok(_) => { - let _ = res - .send(Ok("Supported embedding models updated successfully".to_string())) - .await; - Ok(()) - } - Err(err) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to update supported embedding models: {}", err), - }; - let _ = res.send(Err(api_error)).await; - Ok(()) - } - } - } - #[allow(clippy::too_many_arguments)] pub async fn api_change_nodes_name( secret_file_path: &str, diff --git a/shinkai-bin/shinkai-node/src/network/v1_api/api_v1_internal_commands.rs b/shinkai-bin/shinkai-node/src/network/v1_api/api_v1_internal_commands.rs index dc1fb726b..7e4c3829f 100644 --- a/shinkai-bin/shinkai-node/src/network/v1_api/api_v1_internal_commands.rs +++ b/shinkai-bin/shinkai-node/src/network/v1_api/api_v1_internal_commands.rs @@ -12,14 +12,16 @@ use chrono::Utc; use ed25519_dalek::{SigningKey, VerifyingKey}; use log::{error, info}; use regex::Regex; +use shinkai_fs; use shinkai_message_primitives::schemas::identity::{Identity, StandardIdentity}; use shinkai_message_primitives::schemas::inbox_permission::InboxPermission; use shinkai_message_primitives::schemas::smart_inbox::SmartInbox; use shinkai_message_primitives::schemas::ws_types::WSUpdateHandler; use shinkai_message_primitives::shinkai_message::shinkai_message_schemas::JobCreationInfo; -use shinkai_message_primitives::shinkai_utils::job_scope::{JobScope, VectorFSFolderScopeEntry}; -use shinkai_message_primitives::shinkai_utils::shinkai_message_builder::ShinkaiMessageBuilder; +use shinkai_message_primitives::shinkai_utils::job_scope::MinimalJobScope; +use shinkai_message_primitives::shinkai_utils::search_mode::VectorSearchMode; +use shinkai_message_primitives::shinkai_utils::shinkai_path::ShinkaiPath; use shinkai_message_primitives::{ schemas::{ inbox_name::InboxName, @@ -34,8 +36,6 @@ use shinkai_message_primitives::{ }, }; use shinkai_sqlite::SqliteManager; -use shinkai_vector_fs::welcome_files::welcome_message::WELCOME_MESSAGE; -use shinkai_vector_resources::vector_resource::VRPath; use std::{io::Error, net::SocketAddr}; use std::{str::FromStr, sync::Arc}; use tokio::sync::Mutex; @@ -146,16 +146,35 @@ impl Node { inbox_id: String, new_name: String, ) -> Result<(), String> { - match db.update_smart_inbox_name(&inbox_id, &new_name) { - Ok(_) => Ok(()), - Err(e) => { - shinkai_log( - ShinkaiLogOption::Node, - ShinkaiLogLevel::Error, - format!("Failed to update inbox name: {}", e).as_str(), - ); - Err(format!("Failed to update inbox name: {}", e)) + // Parse the inbox name to check if it's a job inbox + let inbox_name = InboxName::new(inbox_id.clone()).map_err(|e| format!("Failed to parse inbox name: {}", e))?; + + // Get the job ID if it's a job inbox + let job_id = inbox_name.get_job_id(); + + if let Some(job_id) = job_id { + // Get the current folder name before updating + let old_folder = db.get_job_folder_name(&job_id).map_err(|e| format!("Failed to get old folder name: {}", e))?; + + // Update the inbox name + db.unsafe_update_smart_inbox_name(&inbox_id, &new_name) + .map_err(|e| format!("Failed to update inbox name: {}", e))?; + + // Get the new folder name after updating + let new_folder = db.get_job_folder_name(&job_id).map_err(|e| format!("Failed to get new folder name: {}", e))?; + + // Move the folder if it exists + if old_folder.exists() { + use shinkai_fs::shinkai_file_manager::ShinkaiFileManager; + ShinkaiFileManager::move_folder(old_folder, new_folder, &db) + .map_err(|e| format!("Failed to move folder: {}", e))?; } + + Ok(()) + } else { + // If it's not a job inbox, just update the name + db.unsafe_update_smart_inbox_name(&inbox_id, &new_name) + .map_err(|e| format!("Failed to update inbox name: {}", e)) } } @@ -364,7 +383,6 @@ impl Node { }) } }; - let result = match db.get_llm_providers_for_profile(profile_name) { Ok(llm_providers) => llm_providers, Err(e) => { @@ -426,17 +444,12 @@ impl Node { }; if !has_job_inbox && welcome_message { - let shinkai_folder_fs = VectorFSFolderScopeEntry { - name: "Shinkai".to_string(), - path: VRPath::from_string("/My Files (Private)").unwrap(), - }; + let shinkai_folder_fs = ShinkaiPath::from_string("/My Files (Private)".to_string()); - let job_scope = JobScope { - local_vrkai: vec![], - local_vrpack: vec![], + let job_scope = MinimalJobScope { vector_fs_items: vec![], vector_fs_folders: vec![shinkai_folder_fs], - vector_search_mode: vec![], + vector_search_mode: VectorSearchMode::FillUpTo25k, }; let job_creation = JobCreationInfo { scope: job_scope, @@ -469,29 +482,30 @@ impl Node { } }; db.add_permission(&inbox_name.to_string(), &sender_standard, InboxPermission::Admin)?; - db.update_smart_inbox_name( + db.unsafe_update_smart_inbox_name( &inbox_name.to_string(), "Welcome to Shinkai! Brief onboarding here.", )?; - { - // Add Two Message from "Agent" - let identity_secret_key_clone = clone_signature_secret_key(&identity_secret_key); - - let shinkai_message = ShinkaiMessageBuilder::job_message_from_llm_provider( - job_id.to_string(), - WELCOME_MESSAGE.to_string(), - "".to_string(), - None, - identity_secret_key_clone, - profile.node_name.clone(), - profile.node_name.clone(), - ) - .unwrap(); - - db.add_message_to_job_inbox(&job_id.clone(), &shinkai_message, None, ws_manager) - .await?; - } + // TODO: add back later + // { + // // Add Two Message from "Agent" + // let identity_secret_key_clone = clone_signature_secret_key(&identity_secret_key); + + // let shinkai_message = ShinkaiMessageBuilder::job_message_from_llm_provider( + // job_id.to_string(), + // WELCOME_MESSAGE.to_string(), + // "".to_string(), + // None, + // identity_secret_key_clone, + // profile.node_name.clone(), + // profile.node_name.clone(), + // ) + // .unwrap(); + + // db.add_message_to_job_inbox(&job_id.clone(), &shinkai_message, None, ws_manager) + // .await?; + // } } Ok(()) } @@ -697,3 +711,4 @@ impl Node { Ok(()) } } + diff --git a/shinkai-bin/shinkai-node/src/network/v1_api/api_v1_subscription_commands.rs b/shinkai-bin/shinkai-node/src/network/v1_api/api_v1_subscription_commands.rs deleted file mode 100644 index 700803fe5..000000000 --- a/shinkai-bin/shinkai-node/src/network/v1_api/api_v1_subscription_commands.rs +++ /dev/null @@ -1,827 +0,0 @@ -use std::{collections::HashMap, sync::Arc}; - -use crate::{ - managers::IdentityManager, - network::{ - network_manager::{ - external_subscriber_manager::ExternalSubscriberManager, my_subscription_manager::MySubscriptionsManager, - }, - node_error::NodeError, - Node, - }, -}; - -use async_channel::Sender; -use reqwest::StatusCode; -use serde_json::Value; - -use shinkai_http_api::node_api_router::APIError; -use shinkai_message_primitives::{ - schemas::{ - file_links::FolderSubscriptionWithPath, shinkai_name::ShinkaiName, shinkai_subscription::ShinkaiSubscription, - }, - shinkai_message::{ - shinkai_message::ShinkaiMessage, - shinkai_message_schemas::{ - APIAvailableSharedItems, APICreateShareableFolder, APIGetLastNotifications, APIGetMySubscribers, - APIGetNotificationsBeforeTimestamp, APISubscribeToSharedFolder, APIUnshareFolder, - APIUnsubscribeToSharedFolder, APIUpdateShareableFolder, MessageSchemaType, - }, - }, -}; -use shinkai_sqlite::SqliteManager; -use shinkai_vector_fs::vector_fs::vector_fs::VectorFS; -use tokio::sync::{Mutex, RwLock}; -use x25519_dalek::StaticSecret as EncryptionStaticKey; - -impl Node { - pub async fn api_unsubscribe_my_subscriptions( - node_name: ShinkaiName, - identity_manager: Arc>, - encryption_secret_key: EncryptionStaticKey, - my_subscription_manager: Arc>, - potentially_encrypted_msg: ShinkaiMessage, - res: Sender>, - ) -> Result<(), NodeError> { - let (input_payload, requester_name) = match Self::validate_and_extract_payload::( - node_name.clone(), - identity_manager.clone(), - encryption_secret_key, - potentially_encrypted_msg, - MessageSchemaType::UnsubscribeToSharedFolder, - ) - .await - { - Ok(data) => data, - Err(api_error) => { - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - // Validation: requester_name node should be me - if requester_name.get_node_name_string() != node_name.clone().get_node_name_string() { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Invalid node name provided".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - - let my_subscription_manager = my_subscription_manager.lock().await; - let sender_profile = requester_name.get_profile_name_string().unwrap_or("".to_string()); - - match ShinkaiName::from_node_and_profile_names( - input_payload.streamer_node_name.clone(), - input_payload.streamer_profile_name.clone(), - ) { - Ok(ext_node_name) => { - let result = my_subscription_manager - .unsubscribe_to_shared_folder( - ext_node_name, - input_payload.streamer_profile_name.clone(), - sender_profile, - input_payload.path, - ) - .await; - match result { - Ok(_) => { - let _ = res.send(Ok("Unsubscribed".to_string())).await.map_err(|_| ()); - } - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - } - Err(_) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Invalid node name provided".to_string(), - }; - let _ = res.send(Err(api_error)).await; - } - } - - Ok(()) - } - - pub async fn api_subscription_my_subscriptions( - db: Arc, - _vector_fs: Arc, - node_name: ShinkaiName, - identity_manager: Arc>, - encryption_secret_key: EncryptionStaticKey, - potentially_encrypted_msg: ShinkaiMessage, - res: Sender>, - ) -> Result<(), NodeError> { - let (_, requester_name) = match Self::validate_and_extract_payload::( - node_name.clone(), - identity_manager.clone(), - encryption_secret_key, - potentially_encrypted_msg, - MessageSchemaType::MySubscriptions, - ) - .await - { - Ok(data) => data, - Err(api_error) => { - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - // Validation: requester_name node should be me - if requester_name.get_node_name_string() != node_name.clone().get_node_name_string() { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Invalid node name provided".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - - let db_result = db.list_all_my_subscriptions(); - - match db_result { - Ok(subscriptions) => { - match serde_json::to_value(&subscriptions) { - Ok(json_value) => { - let _ = res.send(Ok(json_value)).await.map_err(|_| ()); - } - Err(e) => { - // Handle serialization error - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to serialize response: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - } - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to retrieve subscriptions: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - - Ok(()) - } - - #[allow(clippy::too_many_arguments)] - pub async fn api_subscription_available_shared_items( - _db: Arc, - _vector_fs: Arc, - node_name: ShinkaiName, - identity_manager: Arc>, - encryption_secret_key: EncryptionStaticKey, - ext_subscription_manager: Arc>, - my_subscription_manager: Arc>, - potentially_encrypted_msg: ShinkaiMessage, - res: Sender>, - ) -> Result<(), NodeError> { - let (input_payload, requester_name) = match Self::validate_and_extract_payload::( - node_name.clone(), - identity_manager.clone(), - encryption_secret_key, - potentially_encrypted_msg, - MessageSchemaType::AvailableSharedItems, - ) - .await - { - Ok(data) => data, - Err(api_error) => { - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - if input_payload.streamer_node_name == node_name.clone().get_node_name_string() { - if !requester_name.has_profile() { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Requester name does not have a profile".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - - let streamer_full_name = ShinkaiName::from_node_and_profile_names( - input_payload.streamer_node_name.clone(), - input_payload.streamer_profile_name.clone(), - ); - if streamer_full_name.is_err() { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Invalid origin node name or profile name provided".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - - let requester_profile = requester_name.get_profile_name_string().unwrap(); - - // Lock the mutex and handle the Option - let mut subscription_manager = ext_subscription_manager.lock().await; - let result = subscription_manager - .available_shared_folders( - streamer_full_name.unwrap().extract_node(), - input_payload.streamer_profile_name.clone(), - requester_name.extract_node(), - requester_profile.clone(), - input_payload.path, - ) - .await; - - match result { - Ok(result) => { - match serde_json::to_value(&result) { - Ok(json_value) => { - let _ = res.send(Ok(json_value)).await.map_err(|_| ()); - } - Err(e) => { - // Handle serialization error - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to serialize response: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - } - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - } else { - let mut my_subscription_manager = my_subscription_manager.lock().await; - - match ShinkaiName::from_node_and_profile_names( - input_payload.streamer_node_name.clone(), - input_payload.streamer_profile_name.clone(), - ) { - Ok(ext_node_name) => { - let result = my_subscription_manager.get_shared_folder(&ext_node_name).await; - match result { - Ok(result) => { - match serde_json::to_value(&result) { - Ok(json_value) => { - let _ = res.send(Ok(json_value)).await.map_err(|_| ()); - } - Err(e) => { - // Handle serialization error - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to serialize response: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - } - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - } - Err(_) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Invalid node name provided".to_string(), - }; - let _ = res.send(Err(api_error)).await; - } - } - } - - Ok(()) - } - - pub async fn api_subscription_available_shared_items_open( - node_name: ShinkaiName, - ext_subscription_manager: Arc>, - input_payload: APIAvailableSharedItems, - res: Sender>, - ) -> Result<(), NodeError> { - if input_payload.streamer_node_name == node_name.clone().get_node_name_string() { - let mut subscription_manager = ext_subscription_manager.lock().await; - // TODO: update. only feasible for root for now. - let path = "/"; - let shared_folder_infos = subscription_manager.get_cached_shared_folder_tree(path).await; - - match serde_json::to_value(&shared_folder_infos) { - Ok(json_value) => { - let _ = res.send(Ok(json_value)).await.map_err(|_| ()); - } - Err(e) => { - // Handle serialization error - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to serialize response: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - } else { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Streamer name doesn't match".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - - Ok(()) - } - - #[allow(clippy::too_many_arguments)] - pub async fn api_subscription_subscribe_to_shared_folder( - _db: Arc, - _vector_fs: Arc, - node_name: ShinkaiName, - identity_manager: Arc>, - encryption_secret_key: EncryptionStaticKey, - my_subscription_manager: Arc>, - potentially_encrypted_msg: ShinkaiMessage, - res: Sender>, - ) -> Result<(), NodeError> { - let (input_payload, requester_name) = match Self::validate_and_extract_payload::( - node_name.clone(), - identity_manager.clone(), - encryption_secret_key, - potentially_encrypted_msg, - MessageSchemaType::SubscribeToSharedFolder, - ) - .await - { - Ok(data) => data, - Err(api_error) => { - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let requester_profile = requester_name.get_profile_name_string().unwrap_or("".to_string()); - - let streamer_full_name = match ShinkaiName::from_node_and_profile_names( - input_payload.streamer_node_name.clone(), - input_payload.streamer_profile_name.clone(), - ) { - Ok(shinkai_name) => shinkai_name, - Err(_) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Invalid node name provided".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let mut subscription_manager = my_subscription_manager.lock().await; - let result = subscription_manager - .subscribe_to_shared_folder( - streamer_full_name.extract_node(), - input_payload.streamer_profile_name.clone(), - requester_profile, - input_payload.path, - input_payload.payment, - input_payload.base_folder, - input_payload.http_preferred, - ) - .await; - - match result { - Ok(_) => { - let _ = res.send(Ok("Subscription Requested".to_string())).await.map_err(|_| ()); - } - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to subscribe to shared folder: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - Ok(()) - } - - #[allow(clippy::too_many_arguments)] - pub async fn api_subscription_create_shareable_folder( - _db: Arc, - _vector_fs: Arc, - node_name: ShinkaiName, - identity_manager: Arc>, - encryption_secret_key: EncryptionStaticKey, - ext_subscription_manager: Arc>, - potentially_encrypted_msg: ShinkaiMessage, - res: Sender>, - ) -> Result<(), NodeError> { - let (input_payload, requester_name) = match Self::validate_and_extract_payload::( - node_name.clone(), - identity_manager.clone(), - encryption_secret_key, - potentially_encrypted_msg, - MessageSchemaType::CreateShareableFolder, - ) - .await - { - Ok(data) => data, - Err(api_error) => { - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - if !requester_name.has_profile() { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Requester name does not have a profile".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - - let mut subscription_manager = ext_subscription_manager.lock().await; - let result = subscription_manager - .create_shareable_folder( - input_payload.path, - requester_name, - input_payload.subscription_req, - input_payload.credentials, - ) - .await; - - match result { - Ok(_) => { - let _ = res - .send(Ok("Folder successfully made shareable".to_string())) - .await - .map_err(|_| ()); - } - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to create shareable folder: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - Ok(()) - } - - #[allow(clippy::too_many_arguments)] - pub async fn api_subscription_update_shareable_folder( - _db: Arc, - _vector_fs: Arc, - node_name: ShinkaiName, - identity_manager: Arc>, - encryption_secret_key: EncryptionStaticKey, - ext_subscription_manager: Arc>, - potentially_encrypted_msg: ShinkaiMessage, - res: Sender>, - ) -> Result<(), NodeError> { - let (input_payload, requester_name) = match Self::validate_and_extract_payload::( - node_name.clone(), - identity_manager.clone(), - encryption_secret_key, - potentially_encrypted_msg, - MessageSchemaType::UpdateShareableFolder, - ) - .await - { - Ok(data) => data, - Err(api_error) => { - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let subscription_manager = ext_subscription_manager.lock().await; - let result = subscription_manager - .update_shareable_folder_requirements(input_payload.path, requester_name, input_payload.subscription) - .await; - - match result { - Ok(_) => { - let _ = res - .send(Ok("Shareable folder requirements updated successfully".to_string())) - .await - .map_err(|_| ()); - } - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to update shareable folder requirements: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - - Ok(()) - } - - #[allow(clippy::too_many_arguments)] - pub async fn api_subscription_unshare_folder( - _db: Arc, - _vector_fs: Arc, - node_name: ShinkaiName, - identity_manager: Arc>, - encryption_secret_key: EncryptionStaticKey, - ext_subscription_manager: Arc>, - potentially_encrypted_msg: ShinkaiMessage, - res: Sender>, - ) -> Result<(), NodeError> { - let (input_payload, requester_name) = match Self::validate_and_extract_payload::( - node_name.clone(), - identity_manager.clone(), - encryption_secret_key, - potentially_encrypted_msg, - MessageSchemaType::UnshareFolder, - ) - .await - { - Ok(data) => data, - Err(api_error) => { - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let mut subscription_manager = ext_subscription_manager.lock().await; - let result = subscription_manager - .unshare_folder(input_payload.path, requester_name) - .await; - - match result { - Ok(_) => { - let _ = res - .send(Ok("Folder successfully unshared".to_string())) - .await - .map_err(|_| ()); - } - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to unshare folder: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - Ok(()) - } - - pub async fn api_get_my_subscribers( - node_name: ShinkaiName, - identity_manager: Arc>, - encryption_secret_key: EncryptionStaticKey, - ext_subscription_manager: Arc>, - potentially_encrypted_msg: ShinkaiMessage, - res: Sender>, APIError>>, - ) -> Result<(), NodeError> { - let (input_payload, _) = match Self::validate_and_extract_payload::( - node_name.clone(), - identity_manager.clone(), - encryption_secret_key, - potentially_encrypted_msg, - MessageSchemaType::GetMySubscribers, - ) - .await - { - Ok(data) => data, - Err(api_error) => { - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let subscription_manager = ext_subscription_manager.lock().await; - let subscribers_result = subscription_manager - .get_node_subscribers(Some(input_payload.path)) - .await; - - match subscribers_result { - Ok(subscribers) => { - let _ = res.send(Ok(subscribers)).await.map_err(|_| ()); - } - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to retrieve subscribers: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - - Ok(()) - } - - pub async fn api_get_http_free_subscription_links( - db: Arc, - _node_name: ShinkaiName, - ext_subscription_manager: Arc>, - subscription_id: String, - res: Sender>, - ) -> Result<(), NodeError> { - // Validate the format of subscription_id to be "PROFILE:::PATH" - let parts: Vec<&str> = subscription_id.split(":::").collect(); - if parts.len() != 2 { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Invalid subscription_id format. Expected format 'PROFILE:::PATH'.".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - - let _profile = parts[0].to_string(); - let path = parts[1].to_string(); - - let folder_subscription = match db.get_folder_requirements(&path) { - Ok(result) => result, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to retrieve folder requirements: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let folder_subs_with_path = FolderSubscriptionWithPath { - path: path.clone(), - folder_subscription, - }; - - let subscription_manager = ext_subscription_manager.lock().await; - let file_links = subscription_manager - .http_subscription_upload_manager - .get_cached_subscription_files_links(&folder_subs_with_path); - - match serde_json::to_value(&file_links) { - Ok(json_value) => { - let _ = res.send(Ok(json_value)).await.map_err(|_| ()); - } - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to serialize response: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - - Ok(()) - } - - pub async fn api_get_last_notifications( - db: Arc, - node_name: ShinkaiName, - identity_manager: Arc>, - encryption_secret_key: EncryptionStaticKey, - potentially_encrypted_msg: ShinkaiMessage, - res: Sender>, - ) -> Result<(), NodeError> { - let (input_payload, requester_name) = match Self::validate_and_extract_payload::( - node_name.clone(), - identity_manager.clone(), - encryption_secret_key, - potentially_encrypted_msg, - MessageSchemaType::GetLastNotifications, - ) - .await - { - Ok(data) => data, - Err(api_error) => { - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - if requester_name.get_node_name_string() != node_name.clone().get_node_name_string() { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Invalid node name provided".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - - match db.get_last_notifications( - requester_name.clone(), - input_payload.count, - input_payload.timestamp, - ) { - Ok(notifications) => { - let _ = res.send(Ok(serde_json::to_value(notifications).unwrap())).await; - } - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to get last notifications: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - - Ok(()) - } - - pub async fn api_get_notifications_before_timestamp( - db: Arc, - node_name: ShinkaiName, - identity_manager: Arc>, - encryption_secret_key: EncryptionStaticKey, - potentially_encrypted_msg: ShinkaiMessage, - res: Sender>, - ) -> Result<(), NodeError> { - let (input_payload, requester_name) = - match Self::validate_and_extract_payload::( - node_name.clone(), - identity_manager.clone(), - encryption_secret_key, - potentially_encrypted_msg, - MessageSchemaType::GetNotificationsBeforeTimestamp, - ) - .await - { - Ok(data) => data, - Err(api_error) => { - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - if requester_name.get_node_name_string() != node_name.clone().get_node_name_string() { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Invalid node name provided".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - - match db.get_notifications_before_timestamp( - requester_name.clone(), - input_payload.timestamp, - input_payload.count, - ) { - Ok(notifications) => { - let _ = res.send(Ok(serde_json::to_value(notifications).unwrap())).await; - } - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to get notifications before timestamp: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - - Ok(()) - } -} diff --git a/shinkai-bin/shinkai-node/src/network/v1_api/api_v1_vecfs_commands.rs b/shinkai-bin/shinkai-node/src/network/v1_api/api_v1_vecfs_commands.rs index 052448a12..f2900a148 100644 --- a/shinkai-bin/shinkai-node/src/network/v1_api/api_v1_vecfs_commands.rs +++ b/shinkai-bin/shinkai-node/src/network/v1_api/api_v1_vecfs_commands.rs @@ -1,15 +1,16 @@ use std::{env, fs, path::Path, sync::Arc}; use crate::{ - llm_provider::parsing_helper::ParsingHelper, managers::IdentityManager, network::{node_error::NodeError, Node}, }; use async_channel::Sender; use reqwest::StatusCode; -use serde::{de::DeserializeOwned, Serialize}; +use serde::de::DeserializeOwned; use serde_json::Value; +use shinkai_embedding::embedding_generator::EmbeddingGenerator; +use shinkai_fs::shinkai_file_manager::{FileProcessingMode, ShinkaiFileManager}; use shinkai_http_api::node_api_router::APIError; use shinkai_message_primitives::{ schemas::{identity::Identity, shinkai_name::ShinkaiName}, @@ -22,15 +23,10 @@ use shinkai_message_primitives::{ APIVecFsRetrieveVectorSearchSimplifiedJson, APIVecFsSearchItems, MessageSchemaType, }, }, + shinkai_utils::shinkai_path::ShinkaiPath, }; use shinkai_sqlite::SqliteManager; -use shinkai_vector_fs::vector_fs::vector_fs::VectorFS; -use shinkai_vector_resources::{ - embedding_generator::EmbeddingGenerator, - source::DistributionInfo, - vector_resource::{VRPack, VRPath}, -}; -use tokio::sync::{Mutex, RwLock}; +use tokio::sync::Mutex; use x25519_dalek::StaticSecret as EncryptionStaticKey; impl Node { @@ -84,7 +80,6 @@ impl Node { // Public function for simplified JSON pub async fn api_vec_fs_retrieve_path_simplified_json( _db: Arc, - vector_fs: Arc, node_name: ShinkaiName, identity_manager: Arc>, encryption_secret_key: EncryptionStaticKey, @@ -94,7 +89,6 @@ impl Node { Self::retrieve_path_json_common( // Pass parameters and false for is_minimal _db, - vector_fs, node_name, identity_manager, encryption_secret_key, @@ -109,7 +103,6 @@ impl Node { // Public function for minimal JSON pub async fn api_vec_fs_retrieve_path_minimal_json( _db: Arc, - vector_fs: Arc, node_name: ShinkaiName, identity_manager: Arc>, encryption_secret_key: EncryptionStaticKey, @@ -119,7 +112,6 @@ impl Node { Self::retrieve_path_json_common( // Pass parameters and true for is_minimal _db, - vector_fs, node_name, identity_manager, encryption_secret_key, @@ -133,16 +125,15 @@ impl Node { // Private method to abstract common logic #[allow(clippy::too_many_arguments)] async fn retrieve_path_json_common( - _db: Arc, - vector_fs: Arc, + db: Arc, node_name: ShinkaiName, identity_manager: Arc>, encryption_secret_key: EncryptionStaticKey, potentially_encrypted_msg: ShinkaiMessage, res: Sender>, - is_minimal: bool, // Determines which JSON representation to retrieve + _is_minimal: bool, // TODO: to remove ) -> Result<(), NodeError> { - let (input_payload, requester_name) = + let (input_payload, _requester_name) = match Self::validate_and_extract_payload::( node_name, identity_manager, @@ -159,61 +150,31 @@ impl Node { } }; - let vr_path = match VRPath::from_string(&input_payload.path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert path to VRPath: {}", e), - }; - // Immediately send the error and return from the function - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - let reader = match vector_fs - .new_reader(requester_name.clone(), vr_path, requester_name.clone()) - .await - { - Ok(reader) => reader, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to create reader: {}", e), - }; - // Immediately send the error and return from the function - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + let vr_path = ShinkaiPath::from_string(input_payload.path); - let result = if is_minimal { - vector_fs.retrieve_fs_path_minimal_json_value(&reader).await - } else { - vector_fs.retrieve_fs_path_simplified_json_value(&reader).await - }; + // Use list_directory_contents to get directory contents + let directory_contents = ShinkaiFileManager::list_directory_contents(vr_path, &db); - match result { - Ok(result) => { - let _ = res.send(Ok(result)).await.map_err(|_| ()); - } - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to retrieve fs path json: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } + if let Err(e) = directory_contents { + let api_error = APIError { + code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + error: "Internal Server Error".to_string(), + message: format!("Failed to retrieve directory contents: {}", e), + }; + let _ = res.send(Err(api_error)).await; + return Ok(()); } + + // Convert directory contents to JSON + let json_contents = serde_json::to_value(directory_contents.unwrap()).map_err(|e| NodeError::from(e))?; + + // Send the directory contents as a response + let _ = res.send(Ok(json_contents)).await.map_err(|_| ()); Ok(()) } pub async fn api_vec_fs_search_items( - _db: Arc, - vector_fs: Arc, + db: Arc, node_name: ShinkaiName, identity_manager: Arc>, encryption_secret_key: EncryptionStaticKey, @@ -236,63 +197,64 @@ impl Node { } }; - let vr_path = match input_payload.path { - Some(path) => match VRPath::from_string(&path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }, - None => VRPath::root(), - }; - let reader = vector_fs - .new_reader(requester_name.clone(), vr_path, requester_name.clone()) - .await; - let reader = match reader { - Ok(reader) => reader, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to create reader: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let max_resources_to_search = input_payload.max_files_to_scan.unwrap_or(100) as u64; - let max_results = input_payload.max_results.unwrap_or(100) as u64; - - let query_embedding = vector_fs - .generate_query_embedding_using_reader(input_payload.search, &reader) - .await - .unwrap(); - let search_results = vector_fs - .vector_search_fs_item(&reader, query_embedding, max_resources_to_search) - .await - .unwrap(); - - let results: Vec = search_results - .into_iter() - .map(|res| res.path.to_string()) - .take(max_results as usize) - .collect(); - - let _ = res.send(Ok(results)).await.map_err(|_| ()); - Ok(()) + unimplemented!(); + + // let vr_path = match input_payload.path { + // Some(path) => match ShinkaiPath::from_string(&path) { + // Ok(path) => path, + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::BAD_REQUEST.as_u16(), + // error: "Bad Request".to_string(), + // message: format!("Failed to convert path to VRPath: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }, + // None => VRPath::root(), + // }; + // let reader = vector_fs + // .new_reader(requester_name.clone(), vr_path, requester_name.clone()) + // .await; + // let reader = match reader { + // Ok(reader) => reader, + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + // error: "Internal Server Error".to_string(), + // message: format!("Failed to create reader: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + + // let max_resources_to_search = input_payload.max_files_to_scan.unwrap_or(100) as u64; + // let max_results = input_payload.max_results.unwrap_or(100) as u64; + + // let query_embedding = vector_fs + // .generate_query_embedding_using_reader(input_payload.search, &reader) + // .await + // .unwrap(); + // let search_results = vector_fs + // .vector_search_fs_item(&reader, query_embedding, max_resources_to_search) + // .await + // .unwrap(); + + // let results: Vec = search_results + // .into_iter() + // .map(|res| res.path.to_string()) + // .take(max_results as usize) + // .collect(); + + // let _ = res.send(Ok(results)).await.map_err(|_| ()); + // Ok(()) } // TODO: implement a vector search endpoint for finding FSItems (we'll need for the search UI in Visor for the FS) and one for the VRKai returned too pub async fn api_vec_fs_retrieve_vector_search_simplified_json( _db: Arc, - vector_fs: Arc, node_name: ShinkaiName, identity_manager: Arc>, encryption_secret_key: EncryptionStaticKey, @@ -317,90 +279,66 @@ impl Node { }; let vr_path = match input_payload.path { - Some(path) => match VRPath::from_string(&path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }, - None => VRPath::root(), - }; - let reader = vector_fs - .new_reader(requester_name.clone(), vr_path, requester_name.clone()) - .await; - let reader = match reader { - Ok(reader) => reader, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to create reader: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let max_resources_to_search = input_payload.max_files_to_scan.unwrap_or(100) as u64; - let max_results = input_payload.max_results.unwrap_or(100) as u64; - let search_results = match vector_fs - .deep_vector_search( - &reader, - input_payload.search.clone(), - max_resources_to_search, - max_results, - vec![], - ) - .await - { - Ok(results) => results, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to perform deep vector search: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } + Some(path) => ShinkaiPath::from_string(path), + None => ShinkaiPath::from_str(""), }; - // TODO: Change path to be a single output string. - // - Also return the source metadata, potentially using the format output method - // that is used for showing search results to LLMs - let results: Vec<(String, Vec, f32)> = search_results - .into_iter() - .map(|res| { - let content = match res.resource_retrieved_node.node.get_text_content() { - Ok(text) => text.to_string(), - Err(_) => "".to_string(), - }; - let path_ids = res.clone().fs_item_path().path_ids; - let score = res.resource_retrieved_node.score; - (content, path_ids, score) - }) - .collect(); - - let _ = res.send(Ok(results)).await.map_err(|_| ()); - Ok(()) + unimplemented!(); + + // let max_resources_to_search = input_payload.max_files_to_scan.unwrap_or(100) as u64; + // let max_results = input_payload.max_results.unwrap_or(100) as u64; + + // let search_results = match vector_fs + // .deep_vector_search( + // &reader, + // input_payload.search.clone(), + // max_resources_to_search, + // max_results, + // vec![], + // ) + // .await + // { + // Ok(results) => results, + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + // error: "Internal Server Error".to_string(), + // message: format!("Failed to perform deep vector search: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + + // // TODO: Change path to be a single output string. + // // - Also return the source metadata, potentially using the format output method + // // that is used for showing search results to LLMs + // let results: Vec<(String, Vec, f32)> = search_results + // .into_iter() + // .map(|res| { + // let content = match res.resource_retrieved_node.node.get_text_content() { + // Ok(text) => text.to_string(), + // Err(_) => "".to_string(), + // }; + // let path_ids = res.clone().fs_item_path().path_ids; + // let score = res.resource_retrieved_node.score; + // (content, path_ids, score) + // }) + // .collect(); + + // let _ = res.send(Ok(results)).await.map_err(|_| ()); + // Ok(()) } pub async fn api_vec_fs_create_folder( _db: Arc, - vector_fs: Arc, node_name: ShinkaiName, identity_manager: Arc>, encryption_secret_key: EncryptionStaticKey, potentially_encrypted_msg: ShinkaiMessage, res: Sender>, ) -> Result<(), NodeError> { - let (input_payload, requester_name) = match Self::validate_and_extract_payload::( + let (input_payload, _requester_name) = match Self::validate_and_extract_payload::( node_name, identity_manager, encryption_secret_key, @@ -416,63 +354,63 @@ impl Node { } }; - let vr_path = match VRPath::from_string(&input_payload.path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + let base_path = ShinkaiPath::from_string(input_payload.path.clone()); + if !base_path.exists() { + let api_error = APIError { + code: StatusCode::BAD_REQUEST.as_u16(), + error: "Bad Request".to_string(), + message: format!("Base path does not exist: {}", input_payload.path), + }; + let _ = res.send(Err(api_error)).await; + return Ok(()); + } - let writer = match vector_fs - .new_writer(requester_name.clone(), vr_path, requester_name.clone()) - .await - { - Ok(writer) => writer, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to create writer: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } + let full_path_str = if input_payload.path == "/" { + format!("/{}", input_payload.folder_name) + } else { + format!("{}/{}", input_payload.path, input_payload.folder_name) }; + let full_path = ShinkaiPath::from_string(full_path_str); + + if full_path.exists() { + let api_error = APIError { + code: StatusCode::BAD_REQUEST.as_u16(), + error: "Bad Request".to_string(), + message: format!( + "Path already exists: {}/{}", + input_payload.path, input_payload.folder_name + ), + }; + let _ = res.send(Err(api_error)).await; + return Ok(()); + } - match vector_fs.create_new_folder(&writer, &input_payload.folder_name).await { + match ShinkaiFileManager::create_folder(full_path) { Ok(_) => { - let success_message = format!("Folder '{}' created successfully.", input_payload.folder_name); - let _ = res.send(Ok(success_message)).await.map_err(|_| ()); - Ok(()) + let _ = res.send(Ok("Folder created successfully".to_string())).await; } Err(e) => { let api_error = APIError { code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), error: "Internal Server Error".to_string(), - message: format!("Failed to create new folder: {}", e), + message: format!("Failed to create folder: {:?}", e), }; let _ = res.send(Err(api_error)).await; - Ok(()) } } + + Ok(()) } pub async fn api_vec_fs_move_folder( - _db: Arc, - vector_fs: Arc, + db: Arc, node_name: ShinkaiName, identity_manager: Arc>, encryption_secret_key: EncryptionStaticKey, potentially_encrypted_msg: ShinkaiMessage, res: Sender>, ) -> Result<(), NodeError> { - let (input_payload, requester_name) = match Self::validate_and_extract_payload::( + let (input_payload, _requester_name) = match Self::validate_and_extract_payload::( node_name, identity_manager, encryption_secret_key, @@ -488,68 +426,48 @@ impl Node { } }; - let folder_path = match VRPath::from_string(&input_payload.origin_path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to convert item path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - let destination_path = match VRPath::from_string(&input_payload.destination_path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to convert destination path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + let origin_path = ShinkaiPath::from_string(input_payload.origin_path.clone()); + if !origin_path.exists() { + let api_error = APIError { + code: StatusCode::BAD_REQUEST.as_u16(), + error: "Bad Request".to_string(), + message: format!("Origin path does not exist: {}", input_payload.origin_path), + }; + let _ = res.send(Err(api_error)).await; + return Ok(()); + } - let orig_writer = match vector_fs - .new_writer(requester_name.clone(), folder_path, requester_name.clone()) - .await - { - Ok(writer) => writer, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to create writer for original folder: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + let destination_path = ShinkaiPath::from_string(input_payload.destination_path.clone()); + if destination_path.exists() { + let api_error = APIError { + code: StatusCode::BAD_REQUEST.as_u16(), + error: "Bad Request".to_string(), + message: format!("Destination path already exists: {}", input_payload.destination_path), + }; + let _ = res.send(Err(api_error)).await; + return Ok(()); + } - match vector_fs.move_folder(&orig_writer, destination_path).await { + match ShinkaiFileManager::move_folder(origin_path, destination_path, &db) { Ok(_) => { let success_message = format!("Folder moved successfully to {}", input_payload.destination_path); - let _ = res.send(Ok(success_message)).await.map_err(|_| ()); - Ok(()) + let _ = res.send(Ok(success_message)).await; } Err(e) => { let api_error = APIError { code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), error: "Internal Server Error".to_string(), - message: format!("Failed to move folder: {}", e), + message: format!("Failed to move folder: {:?}", e), }; let _ = res.send(Err(api_error)).await; - Ok(()) } } + + Ok(()) } pub async fn api_vec_fs_copy_folder( _db: Arc, - vector_fs: Arc, node_name: ShinkaiName, identity_manager: Arc>, encryption_secret_key: EncryptionStaticKey, @@ -572,69 +490,70 @@ impl Node { } }; - let folder_path = match VRPath::from_string(&input_payload.origin_path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert folder path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let destination_path = match VRPath::from_string(&input_payload.destination_path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert destination path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let orig_writer = match vector_fs - .new_writer(requester_name.clone(), folder_path, requester_name.clone()) - .await - { - Ok(writer) => writer, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to create writer for original folder: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - match vector_fs.copy_folder(&orig_writer, destination_path).await { - Ok(_) => { - let success_message = format!("Folder copied successfully to {}", input_payload.destination_path); - let _ = res.send(Ok(success_message)).await.map_err(|_| ()); - Ok(()) - } - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to copy folder: {}", e), - }; - let _ = res.send(Err(api_error)).await; - Ok(()) - } - } + unimplemented!(); + + // let folder_path = match ShinkaiPath::from_string(&input_payload.origin_path) { + // Ok(path) => path, + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::BAD_REQUEST.as_u16(), + // error: "Bad Request".to_string(), + // message: format!("Failed to convert folder path to VRPath: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + + // let destination_path = match ShinkaiPath::from_string(&input_payload.destination_path) { + // Ok(path) => path, + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::BAD_REQUEST.as_u16(), + // error: "Bad Request".to_string(), + // message: format!("Failed to convert destination path to VRPath: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + + // let orig_writer = match vector_fs + // .new_writer(requester_name.clone(), folder_path, requester_name.clone()) + // .await + // { + // Ok(writer) => writer, + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + // error: "Internal Server Error".to_string(), + // message: format!("Failed to create writer for original folder: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + + // match vector_fs.copy_folder(&orig_writer, destination_path).await { + // Ok(_) => { + // let success_message = format!("Folder copied successfully to {}", input_payload.destination_path); + // let _ = res.send(Ok(success_message)).await.map_err(|_| ()); + // Ok(()) + // } + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + // error: "Internal Server Error".to_string(), + // message: format!("Failed to copy folder: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // Ok(()) + // } + // } } pub async fn api_vec_fs_delete_item( _db: Arc, - vector_fs: Arc, node_name: ShinkaiName, identity_manager: Arc>, encryption_secret_key: EncryptionStaticKey, @@ -657,63 +576,64 @@ impl Node { } }; - let item_path = match VRPath::from_string(&input_payload.path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert item path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let orig_writer = match vector_fs - .new_writer(requester_name.clone(), item_path, requester_name.clone()) - .await - { - Ok(writer) => writer, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to create writer for item: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - match vector_fs.delete_item(&orig_writer).await { - Ok(_) => { - let success_message = format!("Item successfully deleted: {}", input_payload.path); - let _ = res.send(Ok(success_message)).await.map_err(|_| ()); - Ok(()) - } - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to move item: {}", e), - }; - let _ = res.send(Err(api_error)).await; - Ok(()) - } - } + unimplemented!(); + + // let item_path = match ShinkaiPath::from_string(&input_payload.path) { + // Ok(path) => path, + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::BAD_REQUEST.as_u16(), + // error: "Bad Request".to_string(), + // message: format!("Failed to convert item path to VRPath: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + + // let orig_writer = match vector_fs + // .new_writer(requester_name.clone(), item_path, requester_name.clone()) + // .await + // { + // Ok(writer) => writer, + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + // error: "Internal Server Error".to_string(), + // message: format!("Failed to create writer for item: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + + // match vector_fs.delete_item(&orig_writer).await { + // Ok(_) => { + // let success_message = format!("Item successfully deleted: {}", input_payload.path); + // let _ = res.send(Ok(success_message)).await.map_err(|_| ()); + // Ok(()) + // } + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + // error: "Internal Server Error".to_string(), + // message: format!("Failed to move item: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // Ok(()) + // } + // } } pub async fn api_vec_fs_delete_folder( - _db: Arc, - vector_fs: Arc, + db: Arc, node_name: ShinkaiName, identity_manager: Arc>, encryption_secret_key: EncryptionStaticKey, potentially_encrypted_msg: ShinkaiMessage, res: Sender>, ) -> Result<(), NodeError> { - let (input_payload, requester_name) = match Self::validate_and_extract_payload::( + let (input_payload, _requester_name) = match Self::validate_and_extract_payload::( node_name, identity_manager, encryption_secret_key, @@ -729,63 +649,44 @@ impl Node { } }; - let item_path = match VRPath::from_string(&input_payload.path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert folder path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let orig_writer = match vector_fs - .new_writer(requester_name.clone(), item_path, requester_name.clone()) - .await - { - Ok(writer) => writer, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to create writer for item: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + let folder_path = ShinkaiPath::from_string(input_payload.path.clone()); + if !folder_path.exists() { + let api_error = APIError { + code: StatusCode::BAD_REQUEST.as_u16(), + error: "Bad Request".to_string(), + message: format!("Folder path does not exist: {}", input_payload.path), + }; + let _ = res.send(Err(api_error)).await; + return Ok(()); + } - match vector_fs.delete_folder(&orig_writer).await { + match ShinkaiFileManager::remove_folder(folder_path, &db) { Ok(_) => { let success_message = format!("Folder successfully deleted: {}", input_payload.path); - let _ = res.send(Ok(success_message)).await.map_err(|_| ()); - Ok(()) + let _ = res.send(Ok(success_message)).await; } Err(e) => { let api_error = APIError { code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), error: "Internal Server Error".to_string(), - message: format!("Failed to move item: {}", e), + message: format!("Failed to delete folder: {:?}", e), }; let _ = res.send(Err(api_error)).await; - Ok(()) } } + + Ok(()) } pub async fn api_vec_fs_move_item( - _db: Arc, - vector_fs: Arc, + db: Arc, node_name: ShinkaiName, identity_manager: Arc>, encryption_secret_key: EncryptionStaticKey, potentially_encrypted_msg: ShinkaiMessage, res: Sender>, ) -> Result<(), NodeError> { - let (input_payload, requester_name) = match Self::validate_and_extract_payload::( + let (input_payload, _requester_name) = match Self::validate_and_extract_payload::( node_name, identity_manager, encryption_secret_key, @@ -801,76 +702,55 @@ impl Node { } }; - let item_path = match VRPath::from_string(&input_payload.origin_path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert item path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let destination_path = match VRPath::from_string(&input_payload.destination_path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert destination path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + let origin_path = ShinkaiPath::from_string(input_payload.origin_path.clone()); + if !origin_path.exists() { + let api_error = APIError { + code: StatusCode::BAD_REQUEST.as_u16(), + error: "Bad Request".to_string(), + message: format!("Origin path does not exist: {}", input_payload.origin_path), + }; + let _ = res.send(Err(api_error)).await; + return Ok(()); + } - let orig_writer = match vector_fs - .new_writer(requester_name.clone(), item_path, requester_name.clone()) - .await - { - Ok(writer) => writer, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to create writer for original item: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + let destination_path = ShinkaiPath::from_string(input_payload.destination_path.clone()); + if destination_path.exists() { + let api_error = APIError { + code: StatusCode::BAD_REQUEST.as_u16(), + error: "Bad Request".to_string(), + message: format!("Destination path already exists: {}", input_payload.destination_path), + }; + let _ = res.send(Err(api_error)).await; + return Ok(()); + } - match vector_fs.move_item(&orig_writer, destination_path).await { + match ShinkaiFileManager::move_file(origin_path, destination_path, &db) { Ok(_) => { let success_message = format!("Item moved successfully to {}", input_payload.destination_path); - let _ = res.send(Ok(success_message)).await.map_err(|_| ()); - Ok(()) + let _ = res.send(Ok(success_message)).await; } Err(e) => { let api_error = APIError { code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), error: "Internal Server Error".to_string(), - message: format!("Failed to move item: {}", e), + message: format!("Failed to move item: {:?}", e), }; let _ = res.send(Err(api_error)).await; - Ok(()) } } + + Ok(()) } pub async fn api_vec_fs_copy_item( _db: Arc, - vector_fs: Arc, node_name: ShinkaiName, identity_manager: Arc>, encryption_secret_key: EncryptionStaticKey, potentially_encrypted_msg: ShinkaiMessage, res: Sender>, ) -> Result<(), NodeError> { - let (input_payload, requester_name) = match Self::validate_and_extract_payload::( + let (input_payload, _requester_name) = match Self::validate_and_extract_payload::( node_name, identity_manager, encryption_secret_key, @@ -886,68 +766,48 @@ impl Node { } }; - let item_path = match VRPath::from_string(&input_payload.origin_path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to convert item path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - let destination_path = match VRPath::from_string(&input_payload.destination_path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to convert destination path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + let origin_path = ShinkaiPath::from_string(input_payload.origin_path.clone()); + if !origin_path.exists() { + let api_error = APIError { + code: StatusCode::BAD_REQUEST.as_u16(), + error: "Bad Request".to_string(), + message: format!("Origin path does not exist: {}", input_payload.origin_path), + }; + let _ = res.send(Err(api_error)).await; + return Ok(()); + } - let orig_writer = match vector_fs - .new_writer(requester_name.clone(), item_path, requester_name.clone()) - .await - { - Ok(writer) => writer, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to create writer for original item: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + let destination_path = ShinkaiPath::from_string(input_payload.destination_path.clone()); + if destination_path.exists() { + let api_error = APIError { + code: StatusCode::BAD_REQUEST.as_u16(), + error: "Bad Request".to_string(), + message: format!("Destination path already exists: {}", input_payload.destination_path), + }; + let _ = res.send(Err(api_error)).await; + return Ok(()); + } - match vector_fs.copy_item(&orig_writer, destination_path).await { + match ShinkaiFileManager::copy_file(origin_path, destination_path) { Ok(_) => { let success_message = format!("Item copied successfully to {}", input_payload.destination_path); - let _ = res.send(Ok(success_message)).await.map_err(|_| ()); - Ok(()) + let _ = res.send(Ok(success_message)).await; } Err(e) => { let api_error = APIError { code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), error: "Internal Server Error".to_string(), - message: format!("Failed to copy item: {}", e), + message: format!("Failed to copy item: {:?}", e), }; let _ = res.send(Err(api_error)).await; - Ok(()) } } + + Ok(()) } pub async fn api_vec_fs_retrieve_vector_resource( _db: Arc, - vector_fs: Arc, node_name: ShinkaiName, identity_manager: Arc>, encryption_secret_key: EncryptionStaticKey, @@ -970,229 +830,69 @@ impl Node { return Ok(()); } }; - let vr_path = match VRPath::from_string(&input_payload.path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - let reader = vector_fs - .new_reader(requester_name.clone(), vr_path, requester_name.clone()) - .await; - let reader = match reader { - Ok(reader) => reader, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to create reader: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let result = vector_fs.retrieve_vector_resource(&reader).await; - let result = match result { - Ok(result) => result, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to retrieve vector resource: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let json_resp = match result.to_json_value() { - Ok(result) => result, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to convert vector resource to json: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - let _ = res.send(Ok(json_resp)).await.map_err(|_| ()); - Ok(()) - } - - #[allow(clippy::too_many_arguments)] - pub async fn api_convert_files_and_save_to_folder( - db: Arc, - vector_fs: Arc, - node_name: ShinkaiName, - identity_manager: Arc>, - encryption_secret_key: EncryptionStaticKey, - embedding_generator: Arc, - potentially_encrypted_msg: ShinkaiMessage, - res: Sender, APIError>>, - ) -> Result<(), NodeError> { - let (input_payload, requester_name) = - match Self::validate_and_extract_payload::( - node_name, - identity_manager, - encryption_secret_key, - potentially_encrypted_msg, - MessageSchemaType::ConvertFilesAndSaveToFolder, - ) - .await - { - Ok(data) => data, - Err(api_error) => { - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - Self::process_and_save_files(db, vector_fs, input_payload, requester_name, embedding_generator, res).await - } - - #[allow(clippy::too_many_arguments)] - pub async fn process_and_save_files( - db: Arc, - vector_fs: Arc, - input_payload: APIConvertFilesAndSaveToFolder, - requester_name: ShinkaiName, - embedding_generator: Arc, - res: Sender, APIError>>, - ) -> Result<(), NodeError> { - let destination_path = match VRPath::from_string(&input_payload.path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let files = { - match db.get_all_files_from_inbox(input_payload.file_inbox.clone()) { - Ok(files) => files, - Err(err) => { - let _ = res - .send(Err(APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("{}", err), - })) - .await; - return Ok(()); - } - } - }; - - type FileData = (String, Vec); - type FileDataVec = Vec; - - // Sort out the vrpacks from the rest - let (vr_packs, other_files): (FileDataVec, FileDataVec) = - files.into_iter().partition(|(name, _)| name.ends_with(".vrpack")); - - let mut dist_files = vec![]; - for file in other_files { - let distribution_info = DistributionInfo::new_auto(&file.0, input_payload.file_datetime); - dist_files.push((file.0, file.1, distribution_info)); - } - - // TODO: provide a default agent so that an LLM can be used to generate description of the VR for document files - let processed_vrkais = - ParsingHelper::process_files_into_vrkai(dist_files, &*embedding_generator, None, db.clone()).await?; - - // Save the vrkais into VectorFS - let mut success_messages = Vec::new(); - for (filename, vrkai) in processed_vrkais { - let folder_path = destination_path.clone(); - let writer = vector_fs - .new_writer(requester_name.clone(), folder_path.clone(), requester_name.clone()) - .await?; - - let save_result = vector_fs.save_vrkai_in_folder(&writer, vrkai).await; - let fs_item = match save_result { - Ok(fs_item) => fs_item, - Err(e) => { - let _ = res - .send(Err(APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Error saving '{}' in folder: {}", filename, e), - })) - .await; - return Ok(()); - } - }; - - #[derive(Serialize, Debug)] - struct VectorResourceInfo { - name: String, - path: String, - merkle_hash: String, - } - - let resource_info = VectorResourceInfo { - name: filename.to_string(), - path: fs_item.path.to_string(), - merkle_hash: fs_item.merkle_hash, - }; - - let success_message = match serde_json::to_value(&resource_info) { - Ok(json) => json, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to convert vector resource info to JSON: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - success_messages.push(success_message); - } - - // Extract the vrpacks into the VectorFS - for (filename, vrpack_bytes) in vr_packs { - let vrpack = VRPack::from_bytes(&vrpack_bytes)?; - - let folder_path = destination_path.clone(); - let writer = vector_fs - .new_writer(requester_name.clone(), folder_path.clone(), requester_name.clone()) - .await?; - - if let Err(e) = vector_fs.extract_vrpack_in_folder(&writer, vrpack).await { - let _ = res - .send(Err(APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Error extracting/saving '{}' into folder: {}", filename, e), - })) - .await; - return Ok(()); - } - } - let _ = res.send(Ok(success_messages)).await.map_err(|_| ()); - Ok(()) + unimplemented!(); + // let vr_path = match ShinkaiPath::from_string(&input_payload.path) { + // Ok(path) => path, + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::BAD_REQUEST.as_u16(), + // error: "Bad Request".to_string(), + // message: format!("Failed to convert path to VRPath: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + // let reader = vector_fs + // .new_reader(requester_name.clone(), vr_path, requester_name.clone()) + // .await; + // let reader = match reader { + // Ok(reader) => reader, + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + // error: "Internal Server Error".to_string(), + // message: format!("Failed to create reader: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + + // let result = vector_fs.retrieve_vector_resource(&reader).await; + // let result = match result { + // Ok(result) => result, + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + // error: "Internal Server Error".to_string(), + // message: format!("Failed to retrieve vector resource: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + + // let json_resp = match result.to_json_value() { + // Ok(result) => result, + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + // error: "Internal Server Error".to_string(), + // message: format!("Failed to convert vector resource to json: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + // let _ = res.send(Ok(json_resp)).await.map_err(|_| ()); + // Ok(()) } #[allow(clippy::too_many_arguments)] pub async fn retrieve_vr_kai( _db: Arc, - vector_fs: Arc, node_name: ShinkaiName, identity_manager: Arc>, encryption_secret_key: EncryptionStaticKey, @@ -1214,78 +914,79 @@ impl Node { return Ok(()); } }; - let vr_path = match VRPath::from_string(&input_payload.path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - let reader = vector_fs - .new_reader(requester_name.clone(), vr_path, requester_name.clone()) - .await; - let reader = match reader { - Ok(reader) => reader, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to create reader: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let result = vector_fs.retrieve_vrkai(&reader).await; - let result = match result { - Ok(result) => result, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to retrieve vector resource: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - if env::var("DEBUG_VRKAI").is_ok() { - let debug_content = result.resource.resource_contents_by_hierarchy_to_string(); - let file_name = format!("tmp/{}.txt", input_payload.path.replace("/", "_")); - let path = Path::new(&file_name); - if let Some(parent) = path.parent() { - fs::create_dir_all(parent).unwrap(); - } - fs::write(path, debug_content).unwrap(); - } - let json_resp = match result.encode_as_base64() { - Ok(result) => result, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to convert vector resource to json: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - let _ = res.send(Ok(json_resp)).await.map_err(|_| ()); - Ok(()) + unimplemented!(); + // let vr_path = match ShinkaiPath::from_string(&input_payload.path) { + // Ok(path) => path, + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::BAD_REQUEST.as_u16(), + // error: "Bad Request".to_string(), + // message: format!("Failed to convert path to VRPath: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + // let reader = vector_fs + // .new_reader(requester_name.clone(), vr_path, requester_name.clone()) + // .await; + // let reader = match reader { + // Ok(reader) => reader, + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + // error: "Internal Server Error".to_string(), + // message: format!("Failed to create reader: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + + // let result = vector_fs.retrieve_vrkai(&reader).await; + // let result = match result { + // Ok(result) => result, + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + // error: "Internal Server Error".to_string(), + // message: format!("Failed to retrieve vector resource: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + + // if env::var("DEBUG_VRKAI").is_ok() { + // let debug_content = result.resource.resource_contents_by_hierarchy_to_string(); + // let file_name = format!("tmp/{}.txt", input_payload.path.replace("/", "_")); + // let path = Path::new(&file_name); + // if let Some(parent) = path.parent() { + // fs::create_dir_all(parent).unwrap(); + // } + // fs::write(path, debug_content).unwrap(); + // } + + // let json_resp = match result.encode_as_base64() { + // Ok(result) => result, + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + // error: "Internal Server Error".to_string(), + // message: format!("Failed to convert vector resource to json: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + // let _ = res.send(Ok(json_resp)).await.map_err(|_| ()); + // Ok(()) } #[allow(clippy::too_many_arguments)] pub async fn retrieve_vr_pack( _db: Arc, - vector_fs: Arc, node_name: ShinkaiName, identity_manager: Arc>, encryption_secret_key: EncryptionStaticKey, @@ -1307,61 +1008,62 @@ impl Node { return Ok(()); } }; - let vr_path = match VRPath::from_string(&input_payload.path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - let reader = vector_fs - .new_reader(requester_name.clone(), vr_path, requester_name.clone()) - .await; - let reader = match reader { - Ok(reader) => reader, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to create reader: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let result = vector_fs.retrieve_vrpack(&reader).await; - let result = match result { - Ok(result) => result, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to retrieve vector resource: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let resp = match result.encode_as_base64() { - Ok(result) => result, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to convert vector resource to json: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - let _ = res.send(Ok(resp)).await.map_err(|_| ()); - Ok(()) + unimplemented!(); + // let vr_path = match ShinkaiPath::from_string(&input_payload.path) { + // Ok(path) => path, + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::BAD_REQUEST.as_u16(), + // error: "Bad Request".to_string(), + // message: format!("Failed to convert path to VRPath: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + // let reader = vector_fs + // .new_reader(requester_name.clone(), vr_path, requester_name.clone()) + // .await; + // let reader = match reader { + // Ok(reader) => reader, + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + // error: "Internal Server Error".to_string(), + // message: format!("Failed to create reader: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + + // let result = vector_fs.retrieve_vrpack(&reader).await; + // let result = match result { + // Ok(result) => result, + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + // error: "Internal Server Error".to_string(), + // message: format!("Failed to retrieve vector resource: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + + // let resp = match result.encode_as_base64() { + // Ok(result) => result, + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + // error: "Internal Server Error".to_string(), + // message: format!("Failed to convert vector resource to json: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + // let _ = res.send(Ok(resp)).await.map_err(|_| ()); + // Ok(()) } } diff --git a/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands.rs b/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands.rs index 162bcc3a6..b50cf30ff 100644 --- a/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands.rs +++ b/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands.rs @@ -10,14 +10,16 @@ use async_channel::Sender; use ed25519_dalek::{SigningKey, VerifyingKey}; use reqwest::StatusCode; +use shinkai_embedding::{embedding_generator::RemoteEmbeddingGenerator, model_type::EmbeddingModelType}; use shinkai_http_api::{ api_v1::api_v1_handlers::APIUseRegistrationCodeSuccessResponse, api_v2::api_v2_handlers_general::InitialRegistrationRequest, node_api_router::{APIError, GetPublicKeysResponse}, }; use shinkai_message_primitives::{ - schemas::ws_types::WSUpdateHandler, shinkai_message::shinkai_message_schemas::JobCreationInfo, - shinkai_utils::job_scope::JobScope, + schemas::ws_types::WSUpdateHandler, + shinkai_message::shinkai_message_schemas::JobCreationInfo, + shinkai_utils::{job_scope::MinimalJobScope, shinkai_time::ShinkaiStringTime}, }; use shinkai_message_primitives::{ schemas::{ @@ -39,10 +41,6 @@ use shinkai_message_primitives::{ }, }; use shinkai_sqlite::SqliteManager; -use shinkai_vector_fs::vector_fs::vector_fs::VectorFS; -use shinkai_vector_resources::{ - embedding_generator::RemoteEmbeddingGenerator, model_type::EmbeddingModelType, shinkai_time::ShinkaiStringTime, -}; use tokio::sync::Mutex; use x25519_dalek::PublicKey as EncryptionPublicKey; @@ -241,7 +239,7 @@ impl Node { payload: InitialRegistrationRequest, public_https_certificate: Option, res: Sender>, - vector_fs: Arc, + first_device_needs_registration_code: bool, embedding_generator: Arc, job_manager: Arc>, @@ -265,7 +263,6 @@ impl Node { match Self::handle_registration_code_usage( db, - vector_fs, node_name, first_device_needs_registration_code, embedding_generator, @@ -397,71 +394,6 @@ impl Node { } } - pub async fn v2_api_update_supported_embedding_models( - db: Arc, - vector_fs: Arc, - identity_manager: Arc>, - bearer: String, - models: Vec, - res: Sender>, - ) -> Result<(), NodeError> { - // Validate the bearer token - if Self::validate_bearer_token(&bearer, db.clone(), &res).await.is_err() { - return Ok(()); - } - - let requester_name = match identity_manager.lock().await.get_main_identity() { - Some(Identity::Standard(std_identity)) => std_identity.clone().full_identity_name, - _ => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Wrong identity type. Expected Standard identity.".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - // Convert the strings to EmbeddingModelType - let new_supported_models: Vec = models - .into_iter() - .map(|s| EmbeddingModelType::from_string(&s).expect("Failed to parse embedding model")) - .collect(); - - // Update the supported embedding models in the database - if let Err(err) = db.update_supported_embedding_models(new_supported_models.clone()) { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to update supported embedding models: {}", err), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - - match vector_fs - .set_profile_supported_models(&requester_name, &requester_name, new_supported_models) - .await - { - Ok(_) => { - let _ = res - .send(Ok("Supported embedding models updated successfully".to_string())) - .await; - Ok(()) - } - Err(err) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to update supported embedding models: {}", err), - }; - let _ = res.send(Err(api_error)).await; - Ok(()) - } - } - } - pub async fn v2_api_add_llm_provider( db: Arc, identity_manager: Arc>, @@ -905,72 +837,6 @@ impl Node { } } - pub async fn v2_api_download_file_from_inbox( - db: Arc, - bearer: String, - inbox_name: String, - filename: String, - res: Sender, APIError>>, - ) -> Result<(), NodeError> { - // Validate the bearer token - if Self::validate_bearer_token(&bearer, db.clone(), &res).await.is_err() { - return Ok(()); - } - - // Try to decode the filename first to check if it's already encoded - let encoded_filename = if urlencoding::decode(&filename).is_ok() { - filename.clone() - } else { - urlencoding::encode(&filename).into_owned() - }; - - // Retrieve the file from the inbox - match db.get_file_from_inbox(inbox_name, encoded_filename) { - Ok(file_data) => { - let _ = res.send(Ok(file_data)).await; - } - Err(err) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to retrieve file from inbox: {}", err), - }; - let _ = res.send(Err(api_error)).await; - } - } - - Ok(()) - } - - pub async fn v2_api_list_files_in_inbox( - db: Arc, - bearer: String, - inbox_name: String, - res: Sender, APIError>>, - ) -> Result<(), NodeError> { - // Validate the bearer token - if Self::validate_bearer_token(&bearer, db.clone(), &res).await.is_err() { - return Ok(()); - } - - // List the files in the inbox - match db.get_all_filenames_from_inbox(inbox_name) { - Ok(file_list) => { - let _ = res.send(Ok(file_list)).await; - } - Err(err) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to list files in inbox: {}", err), - }; - let _ = res.send(Err(api_error)).await; - } - } - - Ok(()) - } - pub async fn v2_api_stop_llm( db: Arc, stopper: Arc, @@ -1264,6 +1130,10 @@ impl Node { .map_or(existing_agent.knowledge.clone(), |v| { v.iter().filter_map(|s| s.as_str().map(String::from)).collect() }), + scope: partial_agent + .get("scope") + .map(|v| serde_json::from_value::(v.clone()).unwrap_or(existing_agent.scope.clone())) + .unwrap_or(existing_agent.scope.clone()), storage_path: partial_agent .get("storage_path") .and_then(|v| v.as_str()) @@ -1452,7 +1322,7 @@ impl Node { match tool_generation::v2_create_and_send_job_message( bearer.clone(), JobCreationInfo { - scope: JobScope::new_default(), + scope: MinimalJobScope::default(), is_hidden: Some(true), associated_ui: None, }, diff --git a/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_ext_agent_offers.rs b/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_ext_agent_offers.rs index 4e331033d..ced676111 100644 --- a/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_ext_agent_offers.rs +++ b/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_ext_agent_offers.rs @@ -157,7 +157,7 @@ impl Node { } // Get the tool from the database - match db.tool_exists(&tool_offering.tool_key) { + match db.tool_exists(&tool_offering.tool_key, None) { Ok(exists) => { if !exists { let api_error = APIError { diff --git a/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_jobs.rs b/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_jobs.rs index 9c444afb8..dd1dfd716 100644 --- a/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_jobs.rs +++ b/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_jobs.rs @@ -1,8 +1,4 @@ -use std::{ - collections::{HashMap, HashSet}, - sync::Arc, - usize, -}; +use std::{collections::HashMap, sync::Arc, usize}; use async_channel::Sender; use ed25519_dalek::SigningKey; @@ -28,7 +24,8 @@ use shinkai_message_primitives::{ }, }, shinkai_utils::{ - job_scope::JobScope, shinkai_message_builder::ShinkaiMessageBuilder, signatures::clone_signature_secret_key, + job_scope::MinimalJobScope, shinkai_message_builder::ShinkaiMessageBuilder, + signatures::clone_signature_secret_key, shinkai_path::ShinkaiPath, }, }; @@ -43,7 +40,6 @@ use crate::{ }; use x25519_dalek::StaticSecret as EncryptionStaticKey; - impl Node { pub fn convert_smart_inbox_to_v2_smart_inbox(smart_inbox: SmartInbox) -> Result { let last_message = match smart_inbox.last_message { @@ -206,7 +202,7 @@ impl Node { }; // Retrieve the job to get the llm_provider - let llm_provider = match db.get_job_with_options(&job_message.job_id, false, false) { + let llm_provider = match db.get_job_with_options(&job_message.job_id, false) { Ok(job) => job.parent_agent_or_llm_provider_id.clone(), Err(err) => { let api_error = APIError { @@ -529,77 +525,94 @@ impl Node { return Ok(()); } - // Update the smart inbox name - match db.update_smart_inbox_name(&inbox_name, &custom_name) { - Ok(_) => { - let _ = res.send(Ok(())).await; - } + // Parse the inbox name to check if it's a job inbox + let inbox = match InboxName::new(inbox_name.clone()) { + Ok(inbox) => inbox, Err(e) => { + let api_error = APIError { + code: StatusCode::BAD_REQUEST.as_u16(), + error: "Bad Request".to_string(), + message: format!("Failed to parse inbox name: {}", e), + }; + let _ = res.send(Err(api_error)).await; + return Ok(()); + } + }; + + // Get the job ID if it's a job inbox + if let Some(job_id) = inbox.get_job_id() { + // Get the current folder name before updating + let old_folder = match db.get_job_folder_name(&job_id) { + Ok(folder) => folder, + Err(e) => { + let api_error = APIError { + code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + error: "Internal Server Error".to_string(), + message: format!("Failed to get old folder name: {}", e), + }; + let _ = res.send(Err(api_error)).await; + return Ok(()); + } + }; + + // Update the inbox name + if let Err(e) = db.unsafe_update_smart_inbox_name(&inbox_name, &custom_name) { let api_error = APIError { code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), error: "Internal Server Error".to_string(), message: format!("Failed to update inbox name: {}", e), }; let _ = res.send(Err(api_error)).await; + return Ok(()); } - } - - Ok(()) - } - // TODO: Remove this endpoint. No need to create inboxes in SQLite, they are managed in the VectorFSDB - pub async fn v2_create_files_inbox( - db: Arc, - bearer: String, - res: Sender>, - ) -> Result<(), APIError> { - // Validate the bearer token - if Self::validate_bearer_token(&bearer, db.clone(), &res).await.is_err() { - return Ok(()); - } - - let hash_hex = uuid::Uuid::new_v4().to_string(); - - if let Err(_) = res.send(Ok(hash_hex)).await { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: "Failed to send response".to_string(), + // Get the new folder name after updating + let new_folder = match db.get_job_folder_name(&job_id) { + Ok(folder) => folder, + Err(e) => { + let api_error = APIError { + code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + error: "Internal Server Error".to_string(), + message: format!("Failed to get new folder name: {}", e), + }; + let _ = res.send(Err(api_error)).await; + return Ok(()); + } }; - let _ = res.send(Err(api_error)).await; - } - Ok(()) - } - pub async fn v2_add_file_to_inbox( - db: Arc, - file_inbox_name: String, - filename: String, - file: Vec, - bearer: String, - res: Sender>, - ) -> Result<(), APIError> { - // Validate the bearer token - if Self::validate_bearer_token(&bearer, db.clone(), &res).await.is_err() { - return Ok(()); - } - - match db.add_file_to_files_message_inbox(file_inbox_name, filename, file) { - Ok(_) => { - let _ = res.send(Ok("File added successfully".to_string())).await; - Ok(()) + // Move the folder if it exists + if old_folder.exists() { + use shinkai_fs::shinkai_file_manager::ShinkaiFileManager; + if let Err(e) = ShinkaiFileManager::move_folder(old_folder, new_folder, &db) { + let api_error = APIError { + code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + error: "Internal Server Error".to_string(), + message: format!("Failed to move folder: {}", e), + }; + let _ = res.send(Err(api_error)).await; + return Ok(()); + } } - Err(err) => { - let _ = res - .send(Err(APIError { + + let _ = res.send(Ok(())).await; + } else { + // If it's not a job inbox, just update the name + match db.unsafe_update_smart_inbox_name(&inbox_name, &custom_name) { + Ok(_) => { + let _ = res.send(Ok(())).await; + } + Err(e) => { + let api_error = APIError { code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), error: "Internal Server Error".to_string(), - message: format!("Failed to add file to inbox: {}", err), - })) - .await; - Ok(()) + message: format!("Failed to update inbox name: {}", e), + }; + let _ = res.send(Err(api_error)).await; + } } } + + Ok(()) } pub async fn v2_api_change_job_llm_provider( @@ -646,7 +659,7 @@ impl Node { } // Check if the job exists - match db.get_job_with_options(&job_id, false, false) { + match db.get_job_with_options(&job_id, false) { Ok(_) => { // Job exists, proceed with updating the config match db.update_job_config(&job_id, config) { @@ -692,7 +705,7 @@ impl Node { // TODO: Get default values for Ollama // Check if the job exists - match db.get_job_with_options(&job_id, false, false) { + match db.get_job_with_options(&job_id, false) { Ok(job) => { let config = job.config().cloned().unwrap_or_else(|| JobConfig { custom_system_prompt: None, @@ -975,7 +988,7 @@ impl Node { db: Arc, bearer: String, job_id: String, - job_scope: JobScope, + job_scope: MinimalJobScope, res: Sender>, ) -> Result<(), NodeError> { // Validate the bearer token @@ -984,7 +997,7 @@ impl Node { } // Check if the job exists - match db.get_job_with_options(&job_id, false, false) { + match db.get_job_with_options(&job_id, false) { Ok(_) => { // Job exists, proceed with updating the job scope match db.update_job_scope(job_id.clone(), job_scope.clone()) { @@ -1039,7 +1052,7 @@ impl Node { } // Check if the job exists - match db.get_job_with_options(&job_id, false, false) { + match db.get_job_with_options(&job_id, false) { Ok(job) => { // Job exists, proceed with getting the job scope let job_scope = job.scope(); @@ -1102,7 +1115,7 @@ impl Node { }; // Retrieve the job - let source_job = match db.get_job_with_options(&job_id, false, true) { + let source_job = match db.get_job_with_options(&job_id, false) { Ok(job) => job, Err(err) => { let api_error = APIError { @@ -1184,7 +1197,7 @@ impl Node { match db.create_new_job( forked_job_id.clone(), source_job.parent_agent_or_llm_provider_id, - source_job.scope_with_files.clone().unwrap(), + source_job.scope.clone(), source_job.is_hidden, source_job.associated_ui, source_job.config, @@ -1344,14 +1357,6 @@ impl Node { } }; - // Retrieve the file inboxes - let file_inboxes = v2_chat_messages - .iter() - .flatten() - .map(|message| message.job_message.files_inbox.clone()) - .filter(|inbox| !inbox.is_empty()) - .collect::>(); - // Remove the job match db.remove_job(&job_id) { Ok(_) => {} @@ -1366,21 +1371,22 @@ impl Node { } } + // TODO: remove the files from the job folder // Remove the file inboxes - for file_inbox in file_inboxes { - match db.remove_inbox(&file_inbox) { - Ok(_) => {} - Err(err) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to remove file inbox: {}", err), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - } - } + // for file_inbox in file_inboxes { + // match db.remove_inbox(&file_inbox) { + // Ok(_) => {} + // Err(err) => { + // let api_error = APIError { + // code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + // error: "Internal Server Error".to_string(), + // message: format!("Failed to remove file inbox: {}", err), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // } + // } let _ = res .send(Ok(SendResponseBody { @@ -1432,30 +1438,14 @@ impl Node { } }; + // TODO: Review and fix this + // Retrieve the filenames in the inboxes let file_inboxes = v2_chat_messages .iter() .flatten() - .map(|message| message.job_message.files_inbox.clone()) + .map(|message| message.job_message.fs_files_paths.clone()) .collect::>(); - let mut inbox_filenames = HashMap::new(); - - for inbox in file_inboxes { - let files = match db.get_all_filenames_from_inbox(inbox.clone()) { - Ok(files) => files, - Err(err) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to get files from inbox: {}", err), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - inbox_filenames.insert(inbox, files); - } // Export the messages in the requested format match format { @@ -1481,9 +1471,12 @@ impl Node { let sender = message.sender_subidentity; let receiver = message.receiver_subidentity; let content = message.job_message.content; - let files = inbox_filenames - .get(&message.job_message.files_inbox) - .unwrap_or(&vec![]) + let files = message + .job_message + .fs_files_paths + .iter() + .map(|path| path.relative_path()) + .collect::>() .join(", "); let row = vec![timestamp, sender, receiver, content, files]; @@ -1534,9 +1527,17 @@ impl Node { messages .into_iter() .map(|message| { + let files: Vec = message + .clone() + .job_message + .fs_files_paths + .into_iter() + .map(|file| file.relative_path().to_string()) + .collect(); + json!({ "message": message, - "files": inbox_filenames.get(&message.job_message.files_inbox).unwrap_or(&vec![]), + "files": files, }) }) .collect::>() @@ -1564,8 +1565,8 @@ impl Node { for message in messages { result_messages.push_str(&format!("{}\n\n", message.job_message.content)); - if let Some(files) = inbox_filenames.get(&message.job_message.files_inbox) { - result_messages.push_str(&format!("Attached files: [{}]\n\n", files.join(", "))); + for file in &message.job_message.fs_files_paths { + result_messages.push_str(&format!("Attached file: {}\n\n", file)); } } } @@ -1612,7 +1613,7 @@ impl Node { }; // Retrieve the job to get the llm_provider - let llm_provider = match db.get_job_with_options(&job_id, false, false) { + let llm_provider = match db.get_job_with_options(&job_id, false) { Ok(job) => job.parent_agent_or_llm_provider_id.clone(), Err(err) => { let api_error = APIError { @@ -1698,7 +1699,7 @@ impl Node { let ai_shinkai_message = ShinkaiMessageBuilder::job_message_from_llm_provider( job_id.to_string(), message.content, - message.files_inbox, + message.fs_files_paths, None, identity_secret_key_clone, node_name.node_name.clone(), @@ -1728,3 +1729,4 @@ impl Node { Ok(()) } } + diff --git a/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_sheets.rs b/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_sheets.rs index 8544ded70..0a16738b4 100644 --- a/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_sheets.rs +++ b/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_sheets.rs @@ -9,14 +9,11 @@ use crate::{ use async_channel::Sender; use reqwest::StatusCode; use serde_json::{json, Value as JsonValue}; -use shinkai_message_primitives::schemas::identity::Identity; use shinkai_sqlite::SqliteManager; -use shinkai_vector_fs::vector_fs::vector_fs::VectorFS; -use shinkai_vector_resources::vector_resource::VRPath; use std::any::Any; use std::collections::HashMap; use std::sync::Arc; -use tokio::sync::{Mutex, RwLock}; +use tokio::sync::Mutex; use shinkai_http_api::node_api_router::APIError; use shinkai_message_primitives::shinkai_message::shinkai_message_schemas::{ @@ -159,7 +156,6 @@ impl Node { pub async fn v2_set_sheet_uploaded_files( db: Arc, - vector_fs: Arc, identity_manager: Arc>, sheet_manager: Arc>, input_payload: APISetSheetUploadedFilesPayload, @@ -171,48 +167,50 @@ impl Node { return Ok(()); } - let requester_name = match identity_manager.lock().await.get_main_identity() { - Some(Identity::Standard(std_identity)) => std_identity.clone().full_identity_name, - _ => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Wrong identity type. Expected Standard identity.".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + // TODO: remove this + // let requester_name = match identity_manager.lock().await.get_main_identity() { + // Some(Identity::Standard(std_identity)) => std_identity.clone().full_identity_name, + // _ => { + // let api_error = APIError { + // code: StatusCode::BAD_REQUEST.as_u16(), + // error: "Bad Request".to_string(), + // message: "Wrong identity type. Expected Standard identity.".to_string(), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; for ((row, col), files) in input_payload.files.into_iter() { - // Validate file paths - for file in files.iter() { - let vr_path = match VRPath::from_string(file) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - match vector_fs.validate_path_points_to_entry(vr_path, &requester_name).await { - Ok(_) => {} - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to validate path points to entry: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - } + // TODO: remove this + // // Validate file paths + // for file in files.iter() { + // let vr_path = match ShinkaiPath::from_string(file) { + // Ok(path) => path, + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::BAD_REQUEST.as_u16(), + // error: "Bad Request".to_string(), + // message: format!("Failed to convert path to VRPath: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + + // match vector_fs.validate_path_points_to_entry(vr_path, &requester_name).await { + // Ok(_) => {} + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::BAD_REQUEST.as_u16(), + // error: "Bad Request".to_string(), + // message: format!("Failed to validate path points to entry: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + // } // Add uploaded files to the sheet let mut sheet_manager_guard = sheet_manager.lock().await; diff --git a/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_subscriptions.rs b/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_subscriptions.rs deleted file mode 100644 index 7ebdace4a..000000000 --- a/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_subscriptions.rs +++ /dev/null @@ -1,805 +0,0 @@ -use std::{collections::HashMap, sync::Arc}; - -use async_channel::Sender; -use reqwest::StatusCode; -use serde_json::Value; - -use shinkai_http_api::node_api_router::APIError; -use shinkai_message_primitives::{ - schemas::{ - file_links::FolderSubscriptionWithPath, identity::Identity, shinkai_name::ShinkaiName, - shinkai_subscription::ShinkaiSubscription, - }, - shinkai_message::shinkai_message_schemas::{ - APIAvailableSharedItems, APICreateShareableFolder, APIGetLastNotifications, APIGetMySubscribers, - APIGetNotificationsBeforeTimestamp, APISubscribeToSharedFolder, APIUnshareFolder, APIUnsubscribeToSharedFolder, - APIUpdateShareableFolder, - }, -}; - -use shinkai_sqlite::SqliteManager; -use tokio::sync::{Mutex, RwLock}; - -use crate::{ - managers::IdentityManager, - network::{ - network_manager::{ - external_subscriber_manager::ExternalSubscriberManager, my_subscription_manager::MySubscriptionsManager, - }, - node_error::NodeError, - Node, - }, -}; - -impl Node { - pub async fn v2_api_available_shared_items( - db: Arc, - node_name: ShinkaiName, - identity_manager: Arc>, - ext_subscription_manager: Arc>, - my_subscription_manager: Arc>, - bearer: String, - payload: APIAvailableSharedItems, - res: Sender>, - ) -> Result<(), NodeError> { - // Validate the bearer token - if Self::validate_bearer_token(&bearer, db.clone(), &res).await.is_err() { - return Ok(()); - } - - let requester_name = match identity_manager.lock().await.get_main_identity() { - Some(Identity::Standard(std_identity)) => std_identity.clone().full_identity_name, - _ => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Wrong identity type. Expected Standard identity.".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - if payload.streamer_node_name == node_name.clone().get_node_name_string() { - let streamer_full_name = ShinkaiName::from_node_and_profile_names( - payload.streamer_node_name.clone(), - payload.streamer_profile_name.clone(), - ); - if streamer_full_name.is_err() { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Invalid origin node name or profile name provided".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - - let requester_profile = requester_name.get_profile_name_string().unwrap(); - - let mut subscription_manager = ext_subscription_manager.lock().await; - let result = subscription_manager - .available_shared_folders( - streamer_full_name.unwrap().extract_node(), - payload.streamer_profile_name.clone(), - requester_name.extract_node(), - requester_profile.clone(), - payload.path, - ) - .await; - - match result { - Ok(result) => match serde_json::to_value(&result) { - Ok(json_value) => { - let _ = res.send(Ok(json_value)).await.map_err(|_| ()); - } - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to serialize response: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - }, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - } else { - let mut my_subscription_manager = my_subscription_manager.lock().await; - - match ShinkaiName::from_node_and_profile_names( - payload.streamer_node_name.clone(), - payload.streamer_profile_name.clone(), - ) { - Ok(ext_node_name) => { - let result = my_subscription_manager.get_shared_folder(&ext_node_name).await; - match result { - Ok(result) => match serde_json::to_value(&result) { - Ok(json_value) => { - let _ = res.send(Ok(json_value)).await.map_err(|_| ()); - } - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to serialize response: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - }, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - } - Err(_) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Invalid node name provided".to_string(), - }; - let _ = res.send(Err(api_error)).await; - } - } - } - - Ok(()) - } - - pub async fn v2_api_available_shared_items_open( - db: Arc, - node_name: ShinkaiName, - ext_subscription_manager: Arc>, - bearer: String, - input_payload: APIAvailableSharedItems, - res: Sender>, - ) -> Result<(), NodeError> { - // Validate the bearer token - if Self::validate_bearer_token(&bearer, db.clone(), &res).await.is_err() { - return Ok(()); - } - - if input_payload.streamer_node_name == node_name.clone().get_node_name_string() { - let mut subscription_manager = ext_subscription_manager.lock().await; - // TODO: update. only feasible for root for now. - let path = "/"; - let shared_folder_infos = subscription_manager.get_cached_shared_folder_tree(path).await; - - match serde_json::to_value(&shared_folder_infos) { - Ok(json_value) => { - let _ = res.send(Ok(json_value)).await.map_err(|_| ()); - } - Err(e) => { - // Handle serialization error - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to serialize response: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - } else { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Streamer name doesn't match".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - - Ok(()) - } - - pub async fn v2_api_create_shareable_folder( - db: Arc, - identity_manager: Arc>, - ext_subscription_manager: Arc>, - bearer: String, - payload: APICreateShareableFolder, - res: Sender>, - ) -> Result<(), NodeError> { - // Validate the bearer token - if Self::validate_bearer_token(&bearer, db.clone(), &res).await.is_err() { - return Ok(()); - } - - let requester_name = match identity_manager.lock().await.get_main_identity() { - Some(Identity::Standard(std_identity)) => std_identity.clone().full_identity_name, - _ => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Wrong identity type. Expected Standard identity.".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - if !requester_name.has_profile() { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Requester name does not have a profile".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - - let mut subscription_manager = ext_subscription_manager.lock().await; - let result = subscription_manager - .create_shareable_folder( - payload.path, - requester_name, - payload.subscription_req, - payload.credentials, - ) - .await; - - match result { - Ok(_) => { - let _ = res - .send(Ok("Folder successfully made shareable".to_string())) - .await - .map_err(|_| ()); - } - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to create shareable folder: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - Ok(()) - } - - pub async fn v2_api_update_shareable_folder( - db: Arc, - identity_manager: Arc>, - ext_subscription_manager: Arc>, - bearer: String, - payload: APIUpdateShareableFolder, - res: Sender>, - ) -> Result<(), NodeError> { - // Validate the bearer token - if Self::validate_bearer_token(&bearer, db.clone(), &res).await.is_err() { - return Ok(()); - } - - let requester_name = match identity_manager.lock().await.get_main_identity() { - Some(Identity::Standard(std_identity)) => std_identity.clone().full_identity_name, - _ => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Wrong identity type. Expected Standard identity.".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let subscription_manager = ext_subscription_manager.lock().await; - let result = subscription_manager - .update_shareable_folder_requirements(payload.path, requester_name, payload.subscription) - .await; - - match result { - Ok(_) => { - let _ = res - .send(Ok("Shareable folder requirements updated successfully".to_string())) - .await - .map_err(|_| ()); - } - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to update shareable folder requirements: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - - Ok(()) - } - - pub async fn v2_api_unshare_folder( - db: Arc, - identity_manager: Arc>, - ext_subscription_manager: Arc>, - bearer: String, - payload: APIUnshareFolder, - res: Sender>, - ) -> Result<(), NodeError> { - // Validate the bearer token - if Self::validate_bearer_token(&bearer, db.clone(), &res).await.is_err() { - return Ok(()); - } - - let requester_name = match identity_manager.lock().await.get_main_identity() { - Some(Identity::Standard(std_identity)) => std_identity.clone().full_identity_name, - _ => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Wrong identity type. Expected Standard identity.".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let mut subscription_manager = ext_subscription_manager.lock().await; - let result = subscription_manager.unshare_folder(payload.path, requester_name).await; - - match result { - Ok(_) => { - let _ = res - .send(Ok("Folder successfully unshared".to_string())) - .await - .map_err(|_| ()); - } - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to unshare folder: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - Ok(()) - } - - pub async fn v2_api_subscribe_to_shared_folder( - db: Arc, - identity_manager: Arc>, - my_subscription_manager: Arc>, - bearer: String, - payload: APISubscribeToSharedFolder, - res: Sender>, - ) -> Result<(), NodeError> { - // Validate the bearer token - if Self::validate_bearer_token(&bearer, db.clone(), &res).await.is_err() { - return Ok(()); - } - - let requester_name = match identity_manager.lock().await.get_main_identity() { - Some(Identity::Standard(std_identity)) => std_identity.clone().full_identity_name, - _ => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Wrong identity type. Expected Standard identity.".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let requester_profile = requester_name.get_profile_name_string().unwrap_or("".to_string()); - - let streamer_full_name = match ShinkaiName::from_node_and_profile_names( - payload.streamer_node_name.clone(), - payload.streamer_profile_name.clone(), - ) { - Ok(shinkai_name) => shinkai_name, - Err(_) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Invalid node name provided".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let mut subscription_manager = my_subscription_manager.lock().await; - let result = subscription_manager - .subscribe_to_shared_folder( - streamer_full_name.extract_node(), - payload.streamer_profile_name.clone(), - requester_profile, - payload.path, - payload.payment, - payload.base_folder, - payload.http_preferred, - ) - .await; - - match result { - Ok(_) => { - let _ = res.send(Ok("Subscription Requested".to_string())).await.map_err(|_| ()); - } - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to subscribe to shared folder: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - Ok(()) - } - - pub async fn v2_api_unsubscribe( - db: Arc, - node_name: ShinkaiName, - identity_manager: Arc>, - my_subscription_manager: Arc>, - bearer: String, - payload: APIUnsubscribeToSharedFolder, - res: Sender>, - ) -> Result<(), NodeError> { - // Validate the bearer token - if Self::validate_bearer_token(&bearer, db.clone(), &res).await.is_err() { - return Ok(()); - } - - let requester_name = match identity_manager.lock().await.get_main_identity() { - Some(Identity::Standard(std_identity)) => std_identity.clone().full_identity_name, - _ => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Wrong identity type. Expected Standard identity.".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - // Validation: requester_name node should be me - if requester_name.get_node_name_string() != node_name.clone().get_node_name_string() { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Invalid node name provided".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - - let my_subscription_manager = my_subscription_manager.lock().await; - let sender_profile = requester_name.get_profile_name_string().unwrap_or("".to_string()); - - match ShinkaiName::from_node_and_profile_names( - payload.streamer_node_name.clone(), - payload.streamer_profile_name.clone(), - ) { - Ok(ext_node_name) => { - let result = my_subscription_manager - .unsubscribe_to_shared_folder( - ext_node_name, - payload.streamer_profile_name.clone(), - sender_profile, - payload.path, - ) - .await; - match result { - Ok(_) => { - let _ = res.send(Ok("Unsubscribed".to_string())).await.map_err(|_| ()); - } - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - } - Err(_) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Invalid node name provided".to_string(), - }; - let _ = res.send(Err(api_error)).await; - } - } - - Ok(()) - } - - pub async fn v2_api_my_subscriptions( - db: Arc, - node_name: ShinkaiName, - identity_manager: Arc>, - bearer: String, - res: Sender>, - ) -> Result<(), NodeError> { - // Validate the bearer token - if Self::validate_bearer_token(&bearer, db.clone(), &res).await.is_err() { - return Ok(()); - } - - let requester_name = match identity_manager.lock().await.get_main_identity() { - Some(Identity::Standard(std_identity)) => std_identity.clone().full_identity_name, - _ => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Wrong identity type. Expected Standard identity.".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - // Validation: requester_name node should be me - if requester_name.get_node_name_string() != node_name.clone().get_node_name_string() { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Invalid node name provided".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - - let db_result = db.list_all_my_subscriptions(); - - match db_result { - Ok(subscriptions) => { - match serde_json::to_value(&subscriptions) { - Ok(json_value) => { - let _ = res.send(Ok(json_value)).await.map_err(|_| ()); - } - Err(e) => { - // Handle serialization error - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to serialize response: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - } - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to retrieve subscriptions: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - - Ok(()) - } - - pub async fn v2_api_get_my_subscribers( - db: Arc, - ext_subscription_manager: Arc>, - bearer: String, - payload: APIGetMySubscribers, - res: Sender>, APIError>>, - ) -> Result<(), NodeError> { - // Validate the bearer token - if Self::validate_bearer_token(&bearer, db.clone(), &res).await.is_err() { - return Ok(()); - } - - let subscription_manager = ext_subscription_manager.lock().await; - let subscribers_result = subscription_manager.get_node_subscribers(Some(payload.path)).await; - - match subscribers_result { - Ok(subscribers) => { - let _ = res.send(Ok(subscribers)).await.map_err(|_| ()); - } - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to retrieve subscribers: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - - Ok(()) - } - - pub async fn v2_api_get_http_free_subscription_links( - db: Arc, - ext_subscription_manager: Arc>, - bearer: String, - subscription_profile_path: String, - res: Sender>, - ) -> Result<(), NodeError> { - // Validate the bearer token - if Self::validate_bearer_token(&bearer, db.clone(), &res).await.is_err() { - return Ok(()); - } - - // Validate the format of subscription_profile_path to be "PROFILE:::PATH" - let parts: Vec<&str> = subscription_profile_path.split(":::").collect(); - if parts.len() != 2 { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Invalid subscription_profile_path format. Expected format 'PROFILE:::PATH'.".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - - let _profile = parts[0].to_string(); - let path = parts[1].to_string(); - - let folder_subscription = match db.get_folder_requirements(&path) { - Ok(result) => result, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to retrieve folder requirements: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let folder_subs_with_path = FolderSubscriptionWithPath { - path: path.clone(), - folder_subscription, - }; - - let subscription_manager = ext_subscription_manager.lock().await; - let file_links = subscription_manager - .http_subscription_upload_manager - .get_cached_subscription_files_links(&folder_subs_with_path); - - match serde_json::to_value(&file_links) { - Ok(json_value) => { - let _ = res.send(Ok(json_value)).await.map_err(|_| ()); - } - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to serialize response: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - - Ok(()) - } - - pub async fn v2_api_get_last_notifications( - db: Arc, - node_name: ShinkaiName, - identity_manager: Arc>, - bearer: String, - payload: APIGetLastNotifications, - res: Sender>, - ) -> Result<(), NodeError> { - // Validate the bearer token - if Self::validate_bearer_token(&bearer, db.clone(), &res).await.is_err() { - return Ok(()); - } - - let requester_name = match identity_manager.lock().await.get_main_identity() { - Some(Identity::Standard(std_identity)) => std_identity.clone().full_identity_name, - _ => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Wrong identity type. Expected Standard identity.".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - if requester_name.get_node_name_string() != node_name.clone().get_node_name_string() { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Invalid node name provided".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - - match db - .read() - .await - .get_last_notifications(requester_name.clone(), payload.count, payload.timestamp) - { - Ok(notifications) => { - let _ = res.send(Ok(serde_json::to_value(notifications).unwrap())).await; - } - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to get last notifications: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - - Ok(()) - } - - pub async fn v2_api_get_notifications_before_timestamp( - db: Arc, - node_name: ShinkaiName, - identity_manager: Arc>, - bearer: String, - payload: APIGetNotificationsBeforeTimestamp, - res: Sender>, - ) -> Result<(), NodeError> { - // Validate the bearer token - if Self::validate_bearer_token(&bearer, db.clone(), &res).await.is_err() { - return Ok(()); - } - - let requester_name = match identity_manager.lock().await.get_main_identity() { - Some(Identity::Standard(std_identity)) => std_identity.clone().full_identity_name, - _ => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Wrong identity type. Expected Standard identity.".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - if requester_name.get_node_name_string() != node_name.clone().get_node_name_string() { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Invalid node name provided".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - - match db.get_notifications_before_timestamp( - requester_name.clone(), - payload.timestamp, - payload.count, - ) { - Ok(notifications) => { - let _ = res.send(Ok(serde_json::to_value(notifications).unwrap())).await; - } - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to get notifications before timestamp: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - - Ok(()) - } -} diff --git a/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_tools.rs b/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_tools.rs index df08c580f..63dffba0d 100644 --- a/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_tools.rs +++ b/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_tools.rs @@ -24,7 +24,7 @@ use shinkai_message_primitives::{ }, shinkai_message::shinkai_message_schemas::{CallbackAction, JobCreationInfo, MessageSchemaType}, shinkai_utils::{ - job_scope::JobScope, shinkai_message_builder::ShinkaiMessageBuilder, signatures::clone_signature_secret_key, + job_scope::MinimalJobScope, shinkai_message_builder::ShinkaiMessageBuilder, signatures::clone_signature_secret_key, }, }; use shinkai_message_primitives::{ @@ -44,8 +44,8 @@ use shinkai_tools_primitives::tools::{ tool_output_arg::ToolOutputArg, tool_playground::ToolPlayground, }; -use shinkai_vector_fs::vector_fs::vector_fs::VectorFS; -use std::{fs::File, io::Read, io::Write, path::Path, sync::Arc, time::Instant}; + +use std::{fs::File, io::Write, io::Read, path::Path, sync::Arc, time::Instant}; use tokio::sync::Mutex; use zip::{write::FileOptions, ZipWriter}; @@ -604,8 +604,18 @@ impl Node { } // Create a longer-lived binding for the db clone - - match db.tool_exists(&shinkai_tool.tool_router_key().to_string_without_version()) { + let version = shinkai_tool.version_indexable(); + if version.is_err() { + let api_error = APIError { + code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + error: "Internal Server Error".to_string(), + message: format!("Failed to get version: {}", version.err().unwrap()), + }; + let _ = res.send(Err(api_error)).await; + return Ok(()); + } + let version = Some(version.unwrap()); + match db.tool_exists(&shinkai_tool.tool_router_key().to_string_without_version(), version) { Ok(true) => { // Tool already exists, update it match db.update_tool(shinkai_tool).await { @@ -798,7 +808,6 @@ impl Node { bearer: String, node_name: ShinkaiName, db: Arc, - vector_fs: Arc, tool_router_key: String, parameters: Map, tool_id: String, @@ -825,7 +834,7 @@ impl Node { bearer, node_name, db, - vector_fs, + // vector_fs, tool_router_key.clone(), parameters, tool_id, @@ -1133,7 +1142,7 @@ impl Node { } // We can automatically extract the code (last message from the AI in the job inbox) using the job_id - let job = match db.get_job_with_options(&job_id, true, true) { + let job = match db.get_job_with_options(&job_id, true) { Ok(job) => job, Err(err) => { let api_error = APIError { @@ -1220,7 +1229,7 @@ impl Node { // We auto create a new job with the same configuration as the one from job_id let job_creation_info = JobCreationInfo { - scope: job.scope_with_files().cloned().unwrap_or(JobScope::new_default()), + scope: job.scope().clone(), is_hidden: Some(job.is_hidden()), associated_ui: None, }; @@ -1400,7 +1409,7 @@ impl Node { }; // Retrieve the job to get the llm_provider - let llm_provider = match db.get_job_with_options(&job_id, false, false) { + let llm_provider = match db.get_job_with_options(&job_id, false) { Ok(job) => job.parent_agent_or_llm_provider_id.clone(), Err(err) => { let api_error = APIError { @@ -1448,12 +1457,13 @@ impl Node { let job_message = JobMessage { job_id: job_id.clone(), content: format!("Update the code to: {}", code), - files_inbox: "".to_string(), parent: None, sheet_job_data: None, callback: None, metadata: None, tool_key: None, + fs_files_paths: vec![], + job_filenames: vec![], }; let shinkai_message = match Self::api_v2_create_shinkai_message( @@ -1499,7 +1509,7 @@ impl Node { let ai_shinkai_message = ShinkaiMessageBuilder::job_message_from_llm_provider( job_id.to_string(), ai_message_content, - "".to_string(), + vec![], None, identity_secret_key_clone, node_name.node_name.clone(), @@ -1544,6 +1554,9 @@ impl Node { let sqlite_manager_read = db; match sqlite_manager_read.get_tool_by_key(&tool_key_path.clone()) { Ok(tool) => { + let mut tool = tool.clone(); + tool.sanitize_config(); + let tool_bytes = serde_json::to_vec(&tool).unwrap(); let name = format!( @@ -1648,8 +1661,7 @@ impl Node { }; // Save the tool to the database - let db_write = db; - match db_write.add_tool(tool).await { + match db.add_tool(tool).await { Ok(tool) => { let archive_clone = zip_contents.archive.clone(); let files = archive_clone.file_names(); diff --git a/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_vecfs.rs b/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_vecfs.rs index 3206eb74d..c8f193302 100644 --- a/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_vecfs.rs +++ b/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_vecfs.rs @@ -1,4 +1,4 @@ -use std::sync::Arc; +use std::{collections::HashMap, sync::Arc}; use async_channel::Sender; use base64::Engine; @@ -6,19 +6,20 @@ use chrono::{DateTime, Utc}; use reqwest::StatusCode; use serde_json::Value; +use shinkai_embedding::embedding_generator::EmbeddingGenerator; +use shinkai_fs::shinkai_file_manager::{FileProcessingMode, ShinkaiFileManager}; use shinkai_http_api::node_api_router::APIError; use shinkai_message_primitives::{ - schemas::identity::Identity, + schemas::shinkai_fs::ShinkaiFileChunkCollection, shinkai_message::shinkai_message_schemas::{ - APIConvertFilesAndSaveToFolder, APIVecFsCopyFolder, APIVecFsCopyItem, APIVecFsCreateFolder, - APIVecFsDeleteFolder, APIVecFsDeleteItem, APIVecFsMoveFolder, APIVecFsMoveItem, - APIVecFsRetrievePathSimplifiedJson, APIVecFsRetrieveSourceFile, APIVecFsSearchItems, + APIVecFsCopyFolder, APIVecFsCopyItem, APIVecFsCreateFolder, APIVecFsDeleteFolder, APIVecFsDeleteItem, + APIVecFsMoveFolder, APIVecFsMoveItem, APIVecFsRetrievePathSimplifiedJson, APIVecFsRetrieveSourceFile, + APIVecFsSearchItems, }, + shinkai_utils::shinkai_path::ShinkaiPath, }; use shinkai_sqlite::SqliteManager; -use shinkai_vector_fs::vector_fs::vector_fs::VectorFS; -use shinkai_vector_resources::{embedding_generator::EmbeddingGenerator, source::SourceFile, vector_resource::VRPath}; -use tokio::sync::{Mutex, RwLock}; +use tokio::sync::Mutex; use crate::{ managers::IdentityManager, @@ -28,8 +29,7 @@ use crate::{ impl Node { pub async fn v2_api_vec_fs_retrieve_path_simplified_json( db: Arc, - vector_fs: Arc, - identity_manager: Arc>, + _identity_manager: Arc>, input_payload: APIVecFsRetrievePathSimplifiedJson, bearer: String, res: Sender>, @@ -39,100 +39,32 @@ impl Node { return Ok(()); } - let requester_name = match identity_manager.lock().await.get_main_identity() { - Some(Identity::Standard(std_identity)) => std_identity.clone().full_identity_name, - _ => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Wrong identity type. Expected Standard identity.".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + let vr_path = ShinkaiPath::from_string(input_payload.path); - let vr_path = match VRPath::from_string(&input_payload.path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + // Use list_directory_contents_with_depth to get directory contents with depth 1 + let directory_contents = ShinkaiFileManager::list_directory_contents_with_depth(vr_path, &db, 1); - let reader = match vector_fs - .new_reader(requester_name.clone(), vr_path, requester_name.clone()) - .await - { - Ok(reader) => reader, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to create reader: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let result = vector_fs.retrieve_fs_path_simplified_json_value(&reader).await; - - match result { - Ok(result) => { - let _ = res.send(Ok(result)).await.map_err(|_| ()); - } - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to retrieve fs path json: {}", e), - }; - let _ = res.send(Err(api_error)).await; - } - } - Ok(()) - } - - pub async fn v2_convert_files_and_save_to_folder( - db: Arc, - vector_fs: Arc, - identity_manager: Arc>, - input_payload: APIConvertFilesAndSaveToFolder, - embedding_generator: Arc, - bearer: String, - res: Sender, APIError>>, - ) -> Result<(), NodeError> { - // Validate the bearer token - if Self::validate_bearer_token(&bearer, db.clone(), &res).await.is_err() { + if let Err(e) = directory_contents { + let api_error = APIError { + code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + error: "Internal Server Error".to_string(), + message: format!("Failed to retrieve directory contents: {}", e), + }; + let _ = res.send(Err(api_error)).await; return Ok(()); } - let requester_name = match identity_manager.lock().await.get_main_identity() { - Some(Identity::Standard(std_identity)) => std_identity.clone().full_identity_name, - _ => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Wrong identity type. Expected Standard identity.".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + // Convert directory contents to JSON + let json_contents = serde_json::to_value(directory_contents.unwrap()).map_err(|e| NodeError::from(e))?; - Self::process_and_save_files(db, vector_fs, input_payload, requester_name, embedding_generator, res).await + // Send the directory contents as a response + let _ = res.send(Ok(json_contents)).await.map_err(|_| ()); + Ok(()) } pub async fn v2_create_folder( db: Arc, - vector_fs: Arc, - identity_manager: Arc>, + _identity_manager: Arc>, input_payload: APIVecFsCreateFolder, bearer: String, res: Sender>, @@ -142,240 +74,160 @@ impl Node { return Ok(()); } - let requester_name = match identity_manager.lock().await.get_main_identity() { - Some(Identity::Standard(std_identity)) => std_identity.clone().full_identity_name, - _ => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Wrong identity type. Expected Standard identity.".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let vr_path = match VRPath::from_string(&input_payload.path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + // Check if the base path exists + let base_path = ShinkaiPath::from_string(input_payload.path.clone()); + if !base_path.exists() { + let api_error = APIError { + code: StatusCode::BAD_REQUEST.as_u16(), + error: "Bad Request".to_string(), + message: format!("Base path does not exist: {}", input_payload.path), + }; + let _ = res.send(Err(api_error)).await; + return Ok(()); + } - let writer = match vector_fs - .new_writer(requester_name.clone(), vr_path, requester_name.clone()) - .await - { - Ok(writer) => writer, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to create writer: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + // Create the full path by appending folder_name to the path + let full_path_str = if input_payload.path == "/" { + format!("/{}", input_payload.folder_name) + } else { + format!("{}/{}", input_payload.path, input_payload.folder_name) + }; + let full_path = ShinkaiPath::from_string(full_path_str); + + // Check if the full path already exists + if full_path.exists() { + let api_error = APIError { + code: StatusCode::BAD_REQUEST.as_u16(), + error: "Bad Request".to_string(), + message: format!( + "Path already exists: {}/{}", + input_payload.path, input_payload.folder_name + ), + }; + let _ = res.send(Err(api_error)).await; + return Ok(()); + } - match vector_fs.create_new_folder(&writer, &input_payload.folder_name).await { + // Create the folder using ShinkaiFileManager + match ShinkaiFileManager::create_folder(full_path) { Ok(_) => { - let success_message = format!("Folder '{}' created successfully.", input_payload.folder_name); - let _ = res.send(Ok(success_message)).await.map_err(|_| ()); - Ok(()) + let _ = res.send(Ok("Folder created successfully".to_string())).await; } Err(e) => { let api_error = APIError { code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), error: "Internal Server Error".to_string(), - message: format!("Failed to create new folder: {}", e), + message: format!("Failed to create folder: {:?}", e), }; let _ = res.send(Err(api_error)).await; - Ok(()) } } + + Ok(()) } pub async fn v2_move_item( db: Arc, - vector_fs: Arc, - identity_manager: Arc>, + _identity_manager: Arc>, input_payload: APIVecFsMoveItem, bearer: String, res: Sender>, ) -> Result<(), NodeError> { + // Validate the bearer token if Self::validate_bearer_token(&bearer, db.clone(), &res).await.is_err() { return Ok(()); } - let requester_name = match identity_manager.lock().await.get_main_identity() { - Some(Identity::Standard(std_identity)) => std_identity.clone().full_identity_name, - _ => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Wrong identity type. Expected Standard identity.".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let origin_path = match VRPath::from_string(&input_payload.origin_path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert origin path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let destination_path = match VRPath::from_string(&input_payload.destination_path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert destination path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + // Convert origin and destination paths + let origin_path = ShinkaiPath::from_string(input_payload.origin_path.clone()); + if !origin_path.exists() { + let api_error = APIError { + code: StatusCode::BAD_REQUEST.as_u16(), + error: "Bad Request".to_string(), + message: format!("Origin path does not exist: {}", input_payload.origin_path), + }; + let _ = res.send(Err(api_error)).await; + return Ok(()); + } - let writer = match vector_fs - .new_writer(requester_name.clone(), origin_path, requester_name.clone()) - .await - { - Ok(writer) => writer, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to create writer: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + let destination_path = ShinkaiPath::from_string(input_payload.destination_path.clone()); + if destination_path.exists() { + let api_error = APIError { + code: StatusCode::BAD_REQUEST.as_u16(), + error: "Bad Request".to_string(), + message: format!("Destination path already exists: {}", input_payload.destination_path), + }; + let _ = res.send(Err(api_error)).await; + return Ok(()); + } - match vector_fs.move_item(&writer, destination_path).await { + // Move the file using ShinkaiFileManager + match ShinkaiFileManager::move_file(origin_path, destination_path, &db) { Ok(_) => { let success_message = format!("Item moved successfully to {}", input_payload.destination_path); - let _ = res.send(Ok(success_message)).await.map_err(|_| ()); - Ok(()) + let _ = res.send(Ok(success_message)).await; } Err(e) => { let api_error = APIError { code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), error: "Internal Server Error".to_string(), - message: format!("Failed to move item: {}", e), + message: format!("Failed to move item: {:?}", e), }; let _ = res.send(Err(api_error)).await; - Ok(()) } } + + Ok(()) } pub async fn v2_copy_item( db: Arc, - vector_fs: Arc, - identity_manager: Arc>, + _identity_manager: Arc>, input_payload: APIVecFsCopyItem, bearer: String, res: Sender>, ) -> Result<(), NodeError> { + // Validate the bearer token if Self::validate_bearer_token(&bearer, db.clone(), &res).await.is_err() { return Ok(()); } - let requester_name = match identity_manager.lock().await.get_main_identity() { - Some(Identity::Standard(std_identity)) => std_identity.clone().full_identity_name, - _ => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Wrong identity type. Expected Standard identity.".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let origin_path = match VRPath::from_string(&input_payload.origin_path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert origin path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let destination_path = match VRPath::from_string(&input_payload.destination_path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert destination path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + // Convert origin and destination paths + let origin_path = ShinkaiPath::from_string(input_payload.origin_path.clone()); + if !origin_path.exists() { + let api_error = APIError { + code: StatusCode::BAD_REQUEST.as_u16(), + error: "Bad Request".to_string(), + message: format!("Origin path does not exist: {}", input_payload.origin_path), + }; + let _ = res.send(Err(api_error)).await; + return Ok(()); + } - let writer = match vector_fs - .new_writer(requester_name.clone(), origin_path, requester_name.clone()) - .await - { - Ok(writer) => writer, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to create writer: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + let destination_path = ShinkaiPath::from_string(input_payload.destination_path.clone()); - match vector_fs.copy_item(&writer, destination_path).await { + // Copy the file using ShinkaiFileManager + match ShinkaiFileManager::copy_file(origin_path, destination_path) { Ok(_) => { let success_message = format!("Item copied successfully to {}", input_payload.destination_path); - let _ = res.send(Ok(success_message)).await.map_err(|_| ()); - Ok(()) + let _ = res.send(Ok(success_message)).await; } Err(e) => { let api_error = APIError { code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), error: "Internal Server Error".to_string(), - message: format!("Failed to copy item: {}", e), + message: format!("Failed to copy item: {:?}", e), }; let _ = res.send(Err(api_error)).await; - Ok(()) } } + + Ok(()) } pub async fn v2_move_folder( db: Arc, - vector_fs: Arc, - identity_manager: Arc>, + _identity_manager: Arc>, input_payload: APIVecFsMoveFolder, bearer: String, res: Sender>, @@ -384,82 +236,50 @@ impl Node { return Ok(()); } - let requester_name = match identity_manager.lock().await.get_main_identity() { - Some(Identity::Standard(std_identity)) => std_identity.clone().full_identity_name, - _ => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Wrong identity type. Expected Standard identity.".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let origin_path = match VRPath::from_string(&input_payload.origin_path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert origin path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let destination_path = match VRPath::from_string(&input_payload.destination_path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert destination path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + // Convert origin and destination paths + let origin_path = ShinkaiPath::from_string(input_payload.origin_path.clone()); + if !origin_path.exists() { + let api_error = APIError { + code: StatusCode::BAD_REQUEST.as_u16(), + error: "Bad Request".to_string(), + message: format!("Origin path does not exist: {}", input_payload.origin_path), + }; + let _ = res.send(Err(api_error)).await; + return Ok(()); + } - let writer = match vector_fs - .new_writer(requester_name.clone(), origin_path, requester_name.clone()) - .await - { - Ok(writer) => writer, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to create writer: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + let destination_path = ShinkaiPath::from_string(input_payload.destination_path.clone()); + if destination_path.exists() { + let api_error = APIError { + code: StatusCode::BAD_REQUEST.as_u16(), + error: "Bad Request".to_string(), + message: format!("Destination path already exists: {}", input_payload.destination_path), + }; + let _ = res.send(Err(api_error)).await; + return Ok(()); + } - match vector_fs.move_folder(&writer, destination_path).await { + // Move the folder using ShinkaiFileManager + match ShinkaiFileManager::move_folder(origin_path, destination_path, &db) { Ok(_) => { let success_message = format!("Folder moved successfully to {}", input_payload.destination_path); - let _ = res.send(Ok(success_message)).await.map_err(|_| ()); - Ok(()) + let _ = res.send(Ok(success_message)).await; } Err(e) => { let api_error = APIError { code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), error: "Internal Server Error".to_string(), - message: format!("Failed to move folder: {}", e), + message: format!("Failed to move folder: {:?}", e), }; let _ = res.send(Err(api_error)).await; - Ok(()) } } + + Ok(()) } pub async fn v2_copy_folder( db: Arc, - vector_fs: Arc, identity_manager: Arc>, input_payload: APIVecFsCopyFolder, bearer: String, @@ -469,84 +289,127 @@ impl Node { return Ok(()); } - let requester_name = match identity_manager.lock().await.get_main_identity() { - Some(Identity::Standard(std_identity)) => std_identity.clone().full_identity_name, - _ => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Wrong identity type. Expected Standard identity.".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let origin_path = match VRPath::from_string(&input_payload.origin_path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert origin path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + unimplemented!(); + + // let requester_name = match identity_manager.lock().await.get_main_identity() { + // Some(Identity::Standard(std_identity)) => std_identity.clone().full_identity_name, + // _ => { + // let api_error = APIError { + // code: StatusCode::BAD_REQUEST.as_u16(), + // error: "Bad Request".to_string(), + // message: "Wrong identity type. Expected Standard identity.".to_string(), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + + // let origin_path = match ShinkaiPath::from_string(&input_payload.origin_path) { + // Ok(path) => path, + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::BAD_REQUEST.as_u16(), + // error: "Bad Request".to_string(), + // message: format!("Failed to convert origin path to VRPath: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + + // let destination_path = match ShinkaiPath::from_string(&input_payload.destination_path) { + // Ok(path) => path, + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::BAD_REQUEST.as_u16(), + // error: "Bad Request".to_string(), + // message: format!("Failed to convert destination path to VRPath: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + + // let writer = match vector_fs + // .new_writer(requester_name.clone(), origin_path, requester_name.clone()) + // .await + // { + // Ok(writer) => writer, + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + // error: "Internal Server Error".to_string(), + // message: format!("Failed to create writer: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + + // match vector_fs.copy_folder(&writer, destination_path).await { + // Ok(_) => { + // let success_message = format!("Folder copied successfully to {}", input_payload.destination_path); + // let _ = res.send(Ok(success_message)).await.map_err(|_| ()); + // Ok(()) + // } + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + // error: "Internal Server Error".to_string(), + // message: format!("Failed to copy folder: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // Ok(()) + // } + // } + } - let destination_path = match VRPath::from_string(&input_payload.destination_path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert destination path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + pub async fn v2_delete_folder( + db: Arc, + _identity_manager: Arc>, + input_payload: APIVecFsDeleteFolder, + bearer: String, + res: Sender>, + ) -> Result<(), NodeError> { + if Self::validate_bearer_token(&bearer, db.clone(), &res).await.is_err() { + return Ok(()); + } - let writer = match vector_fs - .new_writer(requester_name.clone(), origin_path, requester_name.clone()) - .await - { - Ok(writer) => writer, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to create writer: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + // Convert the path to ShinkaiPath + let folder_path = ShinkaiPath::from_string(input_payload.path.clone()); + if !folder_path.exists() { + let api_error = APIError { + code: StatusCode::BAD_REQUEST.as_u16(), + error: "Bad Request".to_string(), + message: format!("Folder path does not exist: {}", input_payload.path), + }; + let _ = res.send(Err(api_error)).await; + return Ok(()); + } - match vector_fs.copy_folder(&writer, destination_path).await { + // Delete the folder using ShinkaiFileManager + match ShinkaiFileManager::remove_folder(folder_path, &db) { Ok(_) => { - let success_message = format!("Folder copied successfully to {}", input_payload.destination_path); - let _ = res.send(Ok(success_message)).await.map_err(|_| ()); - Ok(()) + let success_message = format!("Folder successfully deleted: {}", input_payload.path); + let _ = res.send(Ok(success_message)).await; } Err(e) => { let api_error = APIError { code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), error: "Internal Server Error".to_string(), - message: format!("Failed to copy folder: {}", e), + message: format!("Failed to delete folder: {:?}", e), }; let _ = res.send(Err(api_error)).await; - Ok(()) } } + + Ok(()) } - pub async fn v2_delete_folder( + pub async fn v2_delete_item( db: Arc, - vector_fs: Arc, - identity_manager: Arc>, - input_payload: APIVecFsDeleteFolder, + _identity_manager: Arc>, + input_payload: APIVecFsDeleteItem, bearer: String, res: Sender>, ) -> Result<(), NodeError> { @@ -554,218 +417,163 @@ impl Node { return Ok(()); } - let requester_name = match identity_manager.lock().await.get_main_identity() { - Some(Identity::Standard(std_identity)) => std_identity.clone().full_identity_name, - _ => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Wrong identity type. Expected Standard identity.".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let item_path = match VRPath::from_string(&input_payload.path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert folder path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + // Convert the path to ShinkaiPath + let item_path = ShinkaiPath::from_string(input_payload.path.clone()); + if !item_path.exists() { + let api_error = APIError { + code: StatusCode::BAD_REQUEST.as_u16(), + error: "Bad Request".to_string(), + message: format!("File path does not exist: {}", input_payload.path), + }; + let _ = res.send(Err(api_error)).await; + return Ok(()); + } - let writer = match vector_fs - .new_writer(requester_name.clone(), item_path, requester_name.clone()) - .await - { - Ok(writer) => writer, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to create writer: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + // Ensure the path is a file + if !item_path.is_file() { + let api_error = APIError { + code: StatusCode::BAD_REQUEST.as_u16(), + error: "Bad Request".to_string(), + message: format!("Path is not a file: {}", input_payload.path), + }; + let _ = res.send(Err(api_error)).await; + return Ok(()); + } - match vector_fs.delete_folder(&writer).await { + // Delete the file using ShinkaiFileManager + match ShinkaiFileManager::remove_file(item_path, &db) { Ok(_) => { - let success_message = format!("Folder successfully deleted: {}", input_payload.path); - let _ = res.send(Ok(success_message)).await.map_err(|_| ()); - Ok(()) + let success_message = format!("File successfully deleted: {}", input_payload.path); + let _ = res.send(Ok(success_message)).await; } Err(e) => { let api_error = APIError { code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), error: "Internal Server Error".to_string(), - message: format!("Failed to delete folder: {}", e), + message: format!("Failed to delete file: {:?}", e), }; let _ = res.send(Err(api_error)).await; - Ok(()) } } + + Ok(()) } - pub async fn v2_delete_item( + pub async fn v2_search_items( db: Arc, - vector_fs: Arc, - identity_manager: Arc>, - input_payload: APIVecFsDeleteItem, + _identity_manager: Arc>, + input_payload: APIVecFsSearchItems, + embedding_generator: Arc, bearer: String, - res: Sender>, + res: Sender>, ) -> Result<(), NodeError> { + // Validate the bearer token if Self::validate_bearer_token(&bearer, db.clone(), &res).await.is_err() { return Ok(()); } - let requester_name = match identity_manager.lock().await.get_main_identity() { - Some(Identity::Standard(std_identity)) => std_identity.clone().full_identity_name, - _ => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Wrong identity type. Expected Standard identity.".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + // Determine the search path + let search_path_str = input_payload.path.as_deref().unwrap_or("/").to_string(); + let search_path = ShinkaiPath::from_string(search_path_str.clone()); + + // Check if the search path exists + if !search_path.exists() { + let api_error = APIError { + code: StatusCode::BAD_REQUEST.as_u16(), + error: "Bad Request".to_string(), + message: format!("Search path does not exist: {}", search_path_str), + }; + let _ = res.send(Err(api_error)).await; + return Ok(()); + } - let item_path = match VRPath::from_string(&input_payload.path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert item path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + let mut parsed_file_ids = Vec::new(); + let mut paths_map = HashMap::new(); - let writer = match vector_fs - .new_writer(requester_name.clone(), item_path, requester_name.clone()) + let query_embedding = match embedding_generator + .generate_embedding_default(&input_payload.search) .await { - Ok(writer) => writer, + Ok(embedding) => embedding, Err(e) => { let api_error = APIError { code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), error: "Internal Server Error".to_string(), - message: format!("Failed to create writer: {}", e), + message: format!("Failed to generate query embedding: {:?}", e), }; let _ = res.send(Err(api_error)).await; return Ok(()); } }; - match vector_fs.delete_item(&writer).await { - Ok(_) => { - let success_message = format!("Item successfully deleted: {}", input_payload.path); - let _ = res.send(Ok(success_message)).await.map_err(|_| ()); - Ok(()) + // Retrieve files in the specified path + let search_prefix = search_path.relative_path(); + match db.get_parsed_files_by_prefix(&search_prefix) { + Ok(parsed_files) => { + for parsed_file in parsed_files { + parsed_file_ids.push(parsed_file.id.unwrap()); + paths_map.insert( + parsed_file.id.unwrap(), + ShinkaiPath::from_string(parsed_file.relative_path.clone()), + ); + } } Err(e) => { + // Handle the error, e.g., log it or send an error response let api_error = APIError { code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), error: "Internal Server Error".to_string(), - message: format!("Failed to delete item: {}", e), + message: format!("Failed to get parsed files: {:?}", e), }; let _ = res.send(Err(api_error)).await; - Ok(()) + return Ok(()); } } - } - - pub async fn v2_search_items( - db: Arc, - vector_fs: Arc, - identity_manager: Arc>, - input_payload: APIVecFsSearchItems, - bearer: String, - res: Sender, APIError>>, - ) -> Result<(), NodeError> { - if Self::validate_bearer_token(&bearer, db.clone(), &res).await.is_err() { - return Ok(()); - } - let requester_name = match identity_manager.lock().await.get_main_identity() { - Some(Identity::Standard(std_identity)) => std_identity.clone().full_identity_name, - _ => { + // Perform a vector search on all parsed files + let search_results = match db.search_chunks( + &parsed_file_ids, + query_embedding, + input_payload.max_results.unwrap_or(100) as usize, + ) { + Ok(results) => results, + Err(e) => { let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Wrong identity type. Expected Standard identity.".to_string(), + code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + error: "Internal Server Error".to_string(), + message: format!("Failed to search chunks: {:?}", e), }; let _ = res.send(Err(api_error)).await; return Ok(()); } }; - let search_path_str = input_payload.path.as_deref().unwrap_or("/"); - let search_path = match VRPath::from_string(search_path_str) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert search path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } + let results = ShinkaiFileChunkCollection { + chunks: search_results.into_iter().map(|(chunk, _)| chunk).collect(), + paths: Some(paths_map), }; - let reader = match vector_fs - .new_reader(requester_name.clone(), search_path, requester_name.clone()) - .await - { - Ok(reader) => reader, + // Convert results to JSON + let json_results = match serde_json::to_value(results) { + Ok(json_results) => json_results, Err(e) => { let api_error = APIError { code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), error: "Internal Server Error".to_string(), - message: format!("Failed to create reader: {}", e), + message: format!("Failed to convert results to JSON: {:?}", e), }; let _ = res.send(Err(api_error)).await; return Ok(()); } }; - let max_resources_to_search = input_payload.max_files_to_scan.unwrap_or(100) as u64; - let max_results = input_payload.max_results.unwrap_or(100) as u64; - - let query_embedding = vector_fs - .generate_query_embedding_using_reader(input_payload.search, &reader) - .await - .unwrap(); - let search_results = vector_fs - .vector_search_fs_item(&reader, query_embedding, max_resources_to_search) - .await - .unwrap(); - - let results: Vec = search_results - .into_iter() - .map(|res| res.path.to_string()) - .take(max_results as usize) - .collect(); - - let _ = res.send(Ok(results)).await.map_err(|_| ()); + // Send the search results as a response + let _ = res.send(Ok(json_results)).await.map_err(|_| ()); Ok(()) } pub async fn v2_retrieve_vector_resource( db: Arc, - vector_fs: Arc, identity_manager: Arc>, path: String, bearer: String, @@ -776,88 +584,177 @@ impl Node { return Ok(()); } - let requester_name = match identity_manager.lock().await.get_main_identity() { - Some(Identity::Standard(std_identity)) => std_identity.clone().full_identity_name, - _ => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Wrong identity type. Expected Standard identity.".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + unimplemented!(); + + // let requester_name = match identity_manager.lock().await.get_main_identity() { + // Some(Identity::Standard(std_identity)) => std_identity.clone().full_identity_name, + // _ => { + // let api_error = APIError { + // code: StatusCode::BAD_REQUEST.as_u16(), + // error: "Bad Request".to_string(), + // message: "Wrong identity type. Expected Standard identity.".to_string(), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + + // let vr_path = match ShinkaiPath::from_string(&path) { + // Ok(path) => path, + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::BAD_REQUEST.as_u16(), + // error: "Bad Request".to_string(), + // message: format!("Failed to convert path to VRPath: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + + // let reader = match vector_fs + // .new_reader(requester_name.clone(), vr_path, requester_name.clone()) + // .await + // { + // Ok(reader) => reader, + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + // error: "Internal Server Error".to_string(), + // message: format!("Failed to create reader: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // return Ok(()); + // } + // }; + + // let result = vector_fs.retrieve_vector_resource(&reader).await; + + // match result { + // Ok(result_value) => match result_value.to_json_value() { + // Ok(json_value) => { + // let _ = res.send(Ok(json_value)).await.map_err(|_| ()); + // Ok(()) + // } + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + // error: "Internal Server Error".to_string(), + // message: format!("Failed to convert result to JSON: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // Ok(()) + // } + // }, + // Err(e) => { + // let api_error = APIError { + // code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + // error: "Internal Server Error".to_string(), + // message: format!("Failed to retrieve vector resource: {}", e), + // }; + // let _ = res.send(Err(api_error)).await; + // Ok(()) + // } + // } + } - let vr_path = match VRPath::from_string(&path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + pub async fn v2_upload_file_to_folder( + db: Arc, + _identity_manager: Arc>, + embedding_generator: Arc, + bearer: String, + filename: String, + file: Vec, + path: String, + _file_datetime: Option>, + res: Sender>, + ) -> Result<(), NodeError> { + // Validate the bearer token + if Self::validate_bearer_token(&bearer, db.clone(), &res).await.is_err() { + return Ok(()); + } - let reader = match vector_fs - .new_reader(requester_name.clone(), vr_path, requester_name.clone()) - .await + // Construct the full path for the file + let full_path_str = if path == "/" { + format!("/{}", filename) + } else { + format!("{}/{}", path, filename) + }; + let full_path = ShinkaiPath::from_string(full_path_str.clone()); + + // Save and process the file + match ShinkaiFileManager::save_and_process_file( + full_path.clone(), + file, + &db, + FileProcessingMode::Auto, + &*embedding_generator, + ) + .await { - Ok(reader) => reader, + Ok(_) => { + let success_message = format!("File uploaded and processed successfully: {}", full_path_str); + let _ = res.send(Ok(serde_json::json!({ "message": success_message }))).await; + } Err(e) => { let api_error = APIError { code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), error: "Internal Server Error".to_string(), - message: format!("Failed to create reader: {}", e), + message: format!("Failed to upload and process file: {:?}", e), }; let _ = res.send(Err(api_error)).await; - return Ok(()); } - }; + } - let result = vector_fs.retrieve_vector_resource(&reader).await; + Ok(()) + } - match result { - Ok(result_value) => match result_value.to_json_value() { - Ok(json_value) => { - let _ = res.send(Ok(json_value)).await.map_err(|_| ()); - Ok(()) - } - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to convert result to JSON: {}", e), - }; - let _ = res.send(Err(api_error)).await; - Ok(()) - } - }, + pub async fn v2_retrieve_file( + db: Arc, + _identity_manager: Arc>, + input_payload: APIVecFsRetrieveSourceFile, + bearer: String, + res: Sender>, + ) -> Result<(), NodeError> { + // Validate the bearer token + if Self::validate_bearer_token(&bearer, db.clone(), &res).await.is_err() { + return Ok(()); + } + + // Convert the input path to a ShinkaiPath + let vr_path = ShinkaiPath::from_string(input_payload.path.clone()); + + // Read the file content + let file_content = match std::fs::read(vr_path.as_path()) { + Ok(content) => content, Err(e) => { let api_error = APIError { code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), error: "Internal Server Error".to_string(), - message: format!("Failed to retrieve vector resource: {}", e), + message: format!("Failed to read file content: {:?}", e), }; let _ = res.send(Err(api_error)).await; - Ok(()) + return Ok(()); } - } + }; + + // Encode the file content in base64 + let encoded_file_content = base64::engine::general_purpose::STANDARD.encode(&file_content); + + // Send the encoded file content as a response + let _ = res.send(Ok(encoded_file_content)).await.map_err(|_| ()); + Ok(()) } - pub async fn v2_upload_file_to_folder( + pub async fn v2_upload_file_to_job( db: Arc, - vector_fs: Arc, - identity_manager: Arc>, + _identity_manager: Arc>, embedding_generator: Arc, bearer: String, + job_id: String, filename: String, file: Vec, - path: String, - file_datetime: Option>, + _file_datetime: Option>, res: Sender>, ) -> Result<(), NodeError> { // Validate the bearer token @@ -865,100 +762,33 @@ impl Node { return Ok(()); } - // Step 1: Create a file inbox - let hash_hex = uuid::Uuid::new_v4().to_string(); - let file_inbox_name = hash_hex; - - // Step 2: Add the file to the inbox - let (add_file_res_sender, add_file_res_receiver) = async_channel::bounded(1); - - match Self::v2_add_file_to_inbox( - db.clone(), - file_inbox_name.clone(), + // Save and process the file with the job ID + match ShinkaiFileManager::save_and_process_file_with_jobid( + &job_id, filename.clone(), - file.clone(), - bearer.clone(), - add_file_res_sender, + file, + &db, + FileProcessingMode::Auto, + &*embedding_generator, ) .await { - Ok(_) => match add_file_res_receiver.recv().await { - Ok(Ok(_)) => {} - Ok(Err(api_error)) => { - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - Err(_) => { - let _ = res - .send(Err(APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: "Failed to receive add file result".to_string(), - })) - .await; - return Ok(()); - } - }, - Err(api_error) => { - let _ = res.send(Err(api_error)).await; - return Ok(()); + Ok(response) => { + let success_message = format!( + "File uploaded and processed successfully for job {}: {}", + job_id, filename + ); + let _ = res + .send(Ok( + serde_json::json!({ "message": success_message, "filename": response.filename() }), + )) + .await; } - }; - - // Step 3: Convert the file and save it to the folder - let input_payload = APIConvertFilesAndSaveToFolder { - path, - file_inbox: file_inbox_name, - file_datetime, - }; - - let (convert_res_sender, convert_res_receiver) = async_channel::bounded(1); - - match Self::v2_convert_files_and_save_to_folder( - db, - vector_fs, - identity_manager, - input_payload, - embedding_generator, - bearer, - convert_res_sender, - ) - .await - { - Ok(_) => match convert_res_receiver.recv().await { - Ok(Ok(result)) => { - let first_element = match result.into_iter().next() { - Some(element) => element, - None => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: "Result array is empty".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - let _ = res.send(Ok(first_element)).await; - } - Ok(Err(api_error)) => { - let _ = res.send(Err(api_error)).await; - } - Err(_) => { - let _ = res - .send(Err(APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: "Failed to receive conversion result".to_string(), - })) - .await; - } - }, - Err(node_error) => { + Err(e) => { let api_error = APIError { code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), error: "Internal Server Error".to_string(), - message: format!("Failed to convert files and save to folder: {}", node_error), + message: format!("Failed to upload and process file for job {}: {:?}", job_id, e), }; let _ = res.send(Err(api_error)).await; } @@ -967,94 +797,71 @@ impl Node { Ok(()) } - pub async fn v2_retrieve_source_file( + pub async fn v2_api_vec_fs_retrieve_files_for_job( db: Arc, - vector_fs: Arc, - identity_manager: Arc>, - input_payload: APIVecFsRetrieveSourceFile, + _identity_manager: Arc>, + job_id: String, bearer: String, - res: Sender>, + res: Sender>, ) -> Result<(), NodeError> { + // Validate the bearer token if Self::validate_bearer_token(&bearer, db.clone(), &res).await.is_err() { return Ok(()); } - let requester_name = match identity_manager.lock().await.get_main_identity() { - Some(Identity::Standard(std_identity)) => std_identity.clone().full_identity_name, - _ => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: "Wrong identity type. Expected Standard identity.".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + // Retrieve files for the given job_id using ShinkaiFileManager + let files_result = ShinkaiFileManager::get_all_files_and_folders_for_job(&job_id, &db); - let vr_path = match VRPath::from_string(&input_payload.path) { - Ok(path) => path, - Err(e) => { - let api_error = APIError { - code: StatusCode::BAD_REQUEST.as_u16(), - error: "Bad Request".to_string(), - message: format!("Failed to convert path to VRPath: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + if let Err(e) = files_result { + let api_error = APIError { + code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), + error: "Internal Server Error".to_string(), + message: format!("Failed to retrieve files for job_id {}: {}", job_id, e), + }; + let _ = res.send(Err(api_error)).await; + return Ok(()); + } - let reader = match vector_fs - .new_reader(requester_name.clone(), vr_path, requester_name.clone()) - .await - { - Ok(reader) => reader, - Err(e) => { - let api_error = APIError { - code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), - error: "Internal Server Error".to_string(), - message: format!("Failed to create reader: {}", e), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; + // Convert the files information to JSON + let json_files = serde_json::to_value(files_result.unwrap()).map_err(|e| NodeError::from(e))?; + + // Send the files information as a response + let _ = res.send(Ok(json_files)).await.map_err(|_| ()); + Ok(()) + } - let source_file_map = match vector_fs.retrieve_source_file_map(&reader).await { - Ok(source_file_map) => source_file_map, + pub async fn v2_api_vec_fs_get_folder_name_for_job( + db: Arc, + _identity_manager: Arc>, + job_id: String, + bearer: String, + res: Sender>, + ) -> Result<(), NodeError> { + // Validate the bearer token + if Self::validate_bearer_token(&bearer, db.clone(), &res).await.is_err() { + return Ok(()); + } + + // Retrieve the folder name for the given job_id + let folder_name_result = db.get_job_folder_name(&job_id); + + match folder_name_result { + Ok(folder_name) => { + let folder_name_json = serde_json::json!({ + "folder_name": folder_name.relative_path().to_string() + }); + let _ = res.send(Ok(folder_name_json)).await; + } Err(e) => { let api_error = APIError { code: StatusCode::INTERNAL_SERVER_ERROR.as_u16(), error: "Internal Server Error".to_string(), - message: format!("Failed to retrieve source file map: {}", e), + message: format!("Failed to retrieve folder name for job_id {}: {}", job_id, e), }; let _ = res.send(Err(api_error)).await; - return Ok(()); - } - }; - - let source_file = match source_file_map.get_source_file(VRPath::root()) { - Some(source_file) => source_file, - None => { - let api_error = APIError { - code: StatusCode::NOT_FOUND.as_u16(), - error: "Not Found".to_string(), - message: "Source file not found in the source file map".to_string(), - }; - let _ = res.send(Err(api_error)).await; - return Ok(()); } - }; - - let file_content = match source_file { - SourceFile::Standard(file) => &file.file_content, - SourceFile::TLSNotarized(file) => &file.file_content, - }; - - let encoded_file_content = base64::engine::general_purpose::STANDARD.encode(&file_content); + } - let _ = res.send(Ok(encoded_file_content)).await.map_err(|_| ()); Ok(()) } } diff --git a/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_wallets.rs b/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_wallets.rs index be99d1fe1..0e66183f0 100644 --- a/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_wallets.rs +++ b/shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_wallets.rs @@ -12,7 +12,7 @@ use shinkai_message_primitives::schemas::{ wallet_mixed::{Network, NetworkIdentifier}, }; use shinkai_sqlite::SqliteManager; -use tokio::sync::{Mutex, RwLock}; +use tokio::sync::Mutex; use crate::{ network::{node_error::NodeError, Node}, diff --git a/shinkai-bin/shinkai-node/src/runner.rs b/shinkai-bin/shinkai-node/src/runner.rs index cac191d4a..8b0e1dcea 100644 --- a/shinkai-bin/shinkai-node/src/runner.rs +++ b/shinkai-bin/shinkai-node/src/runner.rs @@ -7,6 +7,8 @@ use crate::utils::keys::generate_or_load_keys; use crate::utils::qr_code_setup::generate_qr_codes; use async_channel::{bounded, Receiver, Sender}; use ed25519_dalek::VerifyingKey; +use shinkai_embedding::embedding_generator::RemoteEmbeddingGenerator; +use shinkai_fs::simple_parser::file_parser_helper::ShinkaiFileParser; use shinkai_http_api::node_api_router; use shinkai_http_api::node_commands::NodeCommand; use shinkai_message_primitives::shinkai_utils::encryption::{ @@ -17,7 +19,6 @@ use shinkai_message_primitives::shinkai_utils::signatures::{ clone_signature_secret_key, hash_signature_public_key, signature_public_key_to_string, signature_secret_key_to_string, }; -use shinkai_vector_resources::embedding_generator::RemoteEmbeddingGenerator; use std::collections::HashMap; use std::error::Error as StdError; use std::fmt; @@ -75,7 +76,6 @@ pub async fn initialize_node() -> Result< // Storage db filesystem let main_db_path = get_main_db_path(main_db, &node_keys.identity_public_key, node_storage_path.clone()); - let vector_fs_db_path = get_vector_fs_db_path(vector_fs_db, &node_keys.identity_public_key, node_storage_path); // Acquire the Node's keys. // TODO: Should check with on and then it's with onchain data for matching with the keys provided @@ -107,8 +107,8 @@ pub async fn initialize_node() -> Result< ShinkaiLogOption::Node, ShinkaiLogLevel::Info, format!( - "Starting node with address: {}, main db path: {}, vector fs db path: {}", - node_env.api_listen_address, main_db_path, vector_fs_db_path + "Starting node with address: {}, main db path: {}", + node_env.api_listen_address, main_db_path ) .as_str(), ); @@ -188,7 +188,6 @@ pub async fn initialize_node() -> Result< node_env.proxy_identity.clone(), node_env.first_device_needs_registration_code, initial_llm_providers, - vector_fs_db_path.clone(), Some(embedding_generator), node_env.ws_address, node_env.default_embedding_model.clone(), @@ -224,7 +223,6 @@ pub async fn initialize_node() -> Result< &encryption_public_key_string, &identity_public_key_string, &main_db_path, - &vector_fs_db_path, ); } @@ -252,8 +250,6 @@ pub async fn initialize_node() -> Result< }); tokio::spawn(async { - use shinkai_vector_resources::file_parser::file_parser::ShinkaiFileParser; - match ShinkaiFileParser::initialize_local_file_parser().await { Ok(_) => {} Err(e) => shinkai_log( @@ -308,28 +304,6 @@ fn get_main_db_path(main_db: &str, identity_public_key: &VerifyingKey, node_stor } } -/// Machine filesystem path to the main VectorFS database, pub key based. -fn get_vector_fs_db_path( - vector_fs_db: &str, - identity_public_key: &VerifyingKey, - node_storage_path: Option, -) -> String { - if let Some(path) = node_storage_path { - Path::new(&path) - .join(vector_fs_db) - .join(hash_signature_public_key(identity_public_key)) - .to_str() - .expect("Invalid NODE_STORAGE_PATH") - .to_string() - } else { - Path::new(vector_fs_db) - .join(hash_signature_public_key(identity_public_key)) - .into_os_string() - .into_string() - .unwrap() - } -} - /// Machine filesystem path for .secret. fn get_secrets_file_path(secrets_file: &str, node_storage_path: Option) -> String { if let Some(path) = node_storage_path { @@ -370,13 +344,7 @@ fn init_embedding_generator(node_env: &NodeEnvironment) -> RemoteEmbeddingGenera } /// Prints Useful Node information at startup -pub fn print_node_info( - node_env: &NodeEnvironment, - encryption_pk: &str, - signature_pk: &str, - main_db_path: &str, - vector_fs_db_path: &str, -) { +pub fn print_node_info(node_env: &NodeEnvironment, encryption_pk: &str, signature_pk: &str, main_db_path: &str) { println!("---------------------------------------------------------------"); println!("Node API address: {}", node_env.api_listen_address); println!("Node API HTTPS address: {}", node_env.api_https_listen_address); @@ -387,6 +355,5 @@ pub fn print_node_info( println!("Node encryption pk: {}", encryption_pk); println!("Node signature pk: {}", signature_pk); println!("Main DB path: {}", main_db_path); - println!("Vector FS DB path: {}", vector_fs_db_path); println!("---------------------------------------------------------------"); } diff --git a/shinkai-bin/shinkai-node/src/tools/llm_language_support/generate_python.rs b/shinkai-bin/shinkai-node/src/tools/llm_language_support/generate_python.rs index 464f5de06..e021b6e2c 100644 --- a/shinkai-bin/shinkai-node/src/tools/llm_language_support/generate_python.rs +++ b/shinkai-bin/shinkai-node/src/tools/llm_language_support/generate_python.rs @@ -1,6 +1,9 @@ use super::language_helpers::to_snake_case; use serde_json::Value; -use shinkai_tools_primitives::tools::{shinkai_tool::ShinkaiToolHeader, tool_playground::ToolPlayground}; +use shinkai_tools_primitives::tools::{ + shinkai_tool::ShinkaiToolHeader, + tool_playground::{SqlQuery, SqlTable}, +}; // Example output: /* @@ -181,8 +184,9 @@ fn generate_docstring(tool: &ShinkaiToolHeader, indent: &str) -> String { pub fn generate_python_definition( tool: ShinkaiToolHeader, + sql_tables: Vec, + sql_queries: Vec, generate_pyi: bool, - tool_playground: Option, ) -> String { let mut python_output = String::new(); let function_name = create_function_name_set(&tool); @@ -195,48 +199,7 @@ pub fn generate_python_definition( // Add docstring to .pyi python_output.push_str(&generate_docstring(&tool, " ")); - python_output.push_str("\n ...\n"); - - // If SQL tables exist, generate query function stub with docs - if let Some(playground) = tool_playground { - if !playground.metadata.sql_tables.is_empty() { - python_output.push_str("\n\n"); - python_output.push_str(&format!( - "async def query_{}(query: str, params: Optional[List[Any]] = None) -> List[Dict[str, Any]]:\n", - function_name - )); - - // Add query function documentation - python_output.push_str(&format!( - " \"\"\"Query the SQL database for results from {}\n\n", - function_name - )); - python_output.push_str(" Available SQL Tables:\n"); - for table in &playground.metadata.sql_tables { - python_output.push_str(&format!(" {}:\n {}\n", table.name, table.definition)); - } - - if !playground.metadata.sql_queries.is_empty() { - python_output.push_str("\n Example / Reference SQL Queries:\n"); - for query in &playground.metadata.sql_queries { - python_output.push_str(&format!(" {}:\n {}\n", query.name, query.query)); - } - } - - python_output.push_str( - r#" - Args: - query (str): SQL query to execute - params (Optional[List[Any]], optional): Query parameters. Defaults to None. - - Returns: - List[Dict[str, Any]]: Query results - """ - ... -"#, - ); - } - } + python_output.push_str("\n pass\n"); return python_output; } else { @@ -297,5 +260,49 @@ pub fn generate_python_definition( ); } + // Add SQL query function if tables exist + if !sql_tables.is_empty() { + python_output.push_str("\n\n"); + python_output.push_str(&format!( + "async def query_{}(query: str, params: Optional[List[Any]] = None) -> List[Dict[str, Any]]:\n", + function_name + )); + + // Add query function documentation + python_output.push_str(&format!( + " \"\"\"Query the SQL database for results from {}\n\n", + function_name + )); + python_output.push_str(" Available SQL Tables:\n"); + for table in sql_tables { + python_output.push_str(&format!(" {}:\n {}\n", table.name, table.definition)); + } + + if !sql_queries.is_empty() { + python_output.push_str("\n Example / Reference SQL Queries:\n"); + for query in sql_queries { + python_output.push_str(&format!(" {}:\n {}\n", query.name, query.query)); + } + } + + python_output.push_str( + r#" + Args: + query (str): SQL query to execute + params (Optional[List[Any]], optional): Query parameters. Defaults to None. + + Returns: + List[Dict[str, Any]]: Query results + """ +"#, + ); + + if generate_pyi { + python_output.push_str(" pass\n"); + } else { + python_output.push_str(" return shinkai_sqlite_query_executor(query, params)\n"); + } + } + python_output } diff --git a/shinkai-bin/shinkai-node/src/tools/llm_language_support/generate_typescript.rs b/shinkai-bin/shinkai-node/src/tools/llm_language_support/generate_typescript.rs index e5b419e49..15785582e 100644 --- a/shinkai-bin/shinkai-node/src/tools/llm_language_support/generate_typescript.rs +++ b/shinkai-bin/shinkai-node/src/tools/llm_language_support/generate_typescript.rs @@ -36,7 +36,10 @@ export async function shinkaiDownloadPages(input: {urls: any[]}): Promise<{ } */ use serde_json::Value; -use shinkai_tools_primitives::tools::{shinkai_tool::ShinkaiToolHeader, tool_playground::ToolPlayground}; +use shinkai_tools_primitives::tools::{ + shinkai_tool::ShinkaiToolHeader, + tool_playground::{SqlQuery, SqlTable}, +}; pub fn create_function_name_set(tool: &ShinkaiToolHeader) -> String { crate::tools::llm_language_support::language_helpers::to_camel_case(&tool.name) @@ -96,8 +99,9 @@ fn arg_type_to_typescript(arg_type: &str) -> String { pub fn generate_typescript_definition( tool: ShinkaiToolHeader, + sql_tables: Vec, + sql_queries: Vec, generate_dts: bool, - tool_playground: Option, ) -> String { let mut typescript_output = String::new(); let function_name = create_function_name_set(&tool); @@ -216,53 +220,49 @@ pub fn generate_typescript_definition( } // If SQL tables exist, generate a query function - if let Some(playground) = &tool_playground { - if !playground.metadata.sql_tables.is_empty() { - // Combine SQL documentation into a single format! macro - typescript_output.push_str(&format!( - "/** + if !sql_tables.is_empty() { + // Combine SQL documentation into a single format! macro + typescript_output.push_str(&format!( + "/** * Query the SQL database for results from {} * * Available SQL Tables: ", - function_name - )); + function_name + )); - for table in &playground.metadata.sql_tables { - typescript_output.push_str(&format!(" * {}\n * {}\n", table.name, table.definition)); - } + for table in sql_tables { + typescript_output.push_str(&format!(" * {}\n * {}\n", table.name, table.definition)); + } - if !playground.metadata.sql_queries.is_empty() { - typescript_output.push_str( - " * - * Example / Reference SQL Queries:\n", - ); - for query in &playground.metadata.sql_queries { - typescript_output.push_str(&format!(" * {}\n * {}\n", query.name, query.query)); - } + if !sql_queries.is_empty() { + typescript_output.push_str(" *\n * Example / Reference SQL Queries:\n"); + for query in sql_queries { + typescript_output.push_str(&format!(" * {}\n * {}\n\n", query.name, query.query)); } + } - // Combine parameter documentation - typescript_output.push_str( - " * + // Combine parameter documentation + typescript_output.push_str( + " * * @param query - SQL query to execute * @param params - Optional array of parameters for the query * @returns Query results */ ", - ); + ); - // Combine function definition and implementation - typescript_output.push_str(&format!( - " -async function query_{}(query: string, params?: any[]) {{ - return shinkaiSqliteQueryExecutor('{}', query, params); -}} -", - function_name, - "default" // TODO: make this dynamic - )); - } + // Combine function definition and implementation + typescript_output.push_str(&format!( + " +async function query_{}(query: string, params?: any[]){}", + function_name, + if generate_dts { + ";" + } else { + " {\n return shinkaiSqliteQueryExecutor(query, params)\n}" + } + )); } typescript_output.push_str("\n"); diff --git a/shinkai-bin/shinkai-node/src/tools/tool_definitions/definition_generation.rs b/shinkai-bin/shinkai-node/src/tools/tool_definitions/definition_generation.rs index 3df0406b7..f598d70f1 100644 --- a/shinkai-bin/shinkai-node/src/tools/tool_definitions/definition_generation.rs +++ b/shinkai-bin/shinkai-node/src/tools/tool_definitions/definition_generation.rs @@ -3,7 +3,7 @@ use shinkai_message_primitives::schemas::shinkai_tools::CodeLanguage; use shinkai_message_primitives::schemas::tool_router_key::ToolRouterKey; use shinkai_sqlite::errors::SqliteManagerError; use shinkai_sqlite::SqliteManager; -use shinkai_tools_primitives::tools::shinkai_tool::ShinkaiToolHeader; +use shinkai_tools_primitives::tools::shinkai_tool::{ShinkaiTool, ShinkaiToolHeader}; use shinkai_tools_primitives::tools::tool_playground::ToolPlayground; use std::collections::{HashMap, HashSet}; use std::sync::Arc; @@ -103,42 +103,50 @@ pub async fn generate_tool_definitions( }; } - for tool in all_tools { - let tool_playground: Option = - match sqlite_manager.get_tool_playground(&tool.tool_router_key) { - Ok(tool_playground) => Some(tool_playground), - Err(SqliteManagerError::ToolPlaygroundNotFound(_)) => None, - Err(e) => return Err(APIError::from(e.to_string())), - }; + for tool_header in all_tools { + let tool_data = match sqlite_manager.get_tool_by_key(&tool_header.tool_router_key) { + Ok(tool_data) => tool_data, + Err(e) => return Err(APIError::from(e.to_string())), + }; match language { CodeLanguage::Typescript => { let function_name = - crate::tools::llm_language_support::generate_typescript::create_function_name_set(&tool); + crate::tools::llm_language_support::generate_typescript::create_function_name_set(&tool_header); if generated_names.contains(&function_name) { eprintln!( "Warning: Duplicate function name '{}' found for tool '{}'. Skipping generation.", function_name, - tool.name.clone() + tool_header.name.clone() ); continue; } generated_names.insert(function_name); - output.push_str(&generate_typescript_definition(tool, only_headers, tool_playground)); + output.push_str(&generate_typescript_definition( + tool_header, + tool_data.sql_tables(), + tool_data.sql_queries(), + only_headers, + )); } CodeLanguage::Python => { let function_name = - crate::tools::llm_language_support::generate_python::create_function_name_set(&tool); + crate::tools::llm_language_support::generate_python::create_function_name_set(&tool_header); if generated_names.contains(&function_name) { eprintln!( "Warning: Duplicate function name '{}' found for tool '{}'. Skipping generation.", function_name, - tool.name.clone() + tool_header.name.clone() ); continue; } generated_names.insert(function_name); - output.push_str(&generate_python_definition(tool, only_headers, tool_playground)); + output.push_str(&generate_python_definition( + tool_header, + tool_data.sql_tables(), + tool_data.sql_queries(), + only_headers, + )); } } } diff --git a/shinkai-bin/shinkai-node/src/tools/tool_execution/execution_coordinator.rs b/shinkai-bin/shinkai-node/src/tools/tool_execution/execution_coordinator.rs index 45c7e467f..67e261e75 100644 --- a/shinkai-bin/shinkai-node/src/tools/tool_execution/execution_coordinator.rs +++ b/shinkai-bin/shinkai-node/src/tools/tool_execution/execution_coordinator.rs @@ -18,7 +18,6 @@ use shinkai_tools_primitives::tools::error::ToolError; use shinkai_tools_primitives::tools::shinkai_tool::ShinkaiTool; use shinkai_tools_primitives::tools::tool_config::{OAuth, ToolConfig}; -use shinkai_vector_fs::vector_fs::vector_fs::VectorFS; use tokio::sync::Mutex; use crate::managers::IdentityManager; @@ -117,7 +116,6 @@ pub async fn execute_tool_cmd( bearer: String, node_name: ShinkaiName, db: Arc, - vector_fs: Arc, tool_router_key: String, parameters: Map, tool_id: String, @@ -144,7 +142,7 @@ pub async fn execute_tool_cmd( extra_config, bearer, db, - vector_fs, + // vector_fs, llm_provider, node_name, identity_manager, diff --git a/shinkai-bin/shinkai-node/src/tools/tool_execution/execution_custom.rs b/shinkai-bin/shinkai-node/src/tools/tool_execution/execution_custom.rs index 041a9c96c..c5e013e1b 100644 --- a/shinkai-bin/shinkai-node/src/tools/tool_execution/execution_custom.rs +++ b/shinkai-bin/shinkai-node/src/tools/tool_execution/execution_custom.rs @@ -8,12 +8,9 @@ use ed25519_dalek::SigningKey; use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; -use shinkai_tools_primitives::tools::tool_config::OAuth; use shinkai_tools_primitives::tools::tool_config::ToolConfig; -use shinkai_vector_fs::vector_fs::vector_fs::VectorFS; use tokio::sync::Mutex; -use tokio::sync::RwLock; use x25519_dalek::PublicKey as EncryptionPublicKey; use x25519_dalek::StaticSecret as EncryptionStaticKey; @@ -30,7 +27,6 @@ pub async fn execute_custom_tool( _extra_config: Vec, bearer: String, db: Arc, - vector_fs: Arc, llm_provider: String, node_name: ShinkaiName, identity_manager: Arc>, @@ -40,7 +36,6 @@ pub async fn execute_custom_tool( signing_secret_key: SigningKey, ) -> Result { println!("[executing_rust_tool] {}", tool_router_key); - // TODO: if it is, find it and call it // Check if the tool_router_key contains "rust_toolkit" if !tool_router_key.contains("rust_toolkit") { @@ -57,7 +52,6 @@ pub async fn execute_custom_tool( tool_id, app_id, db, - vector_fs, node_name, identity_manager, job_manager, @@ -75,7 +69,6 @@ pub async fn execute_custom_tool( tool_id, app_id, db, - vector_fs, node_name, identity_manager, job_manager, @@ -93,7 +86,6 @@ pub async fn execute_custom_tool( tool_id, app_id, db, - vector_fs, node_name, identity_manager, job_manager, diff --git a/shinkai-bin/shinkai-node/src/tools/tool_generation.rs b/shinkai-bin/shinkai-node/src/tools/tool_generation.rs index ed7ac09bc..82d660031 100644 --- a/shinkai-bin/shinkai-node/src/tools/tool_generation.rs +++ b/shinkai-bin/shinkai-node/src/tools/tool_generation.rs @@ -9,7 +9,6 @@ use shinkai_message_primitives::shinkai_message::shinkai_message_schemas::JobMes use shinkai_sqlite::SqliteManager; use std::sync::Arc; use tokio::sync::Mutex; -use tokio::sync::RwLock; use x25519_dalek::PublicKey as EncryptionPublicKey; use x25519_dalek::StaticSecret as EncryptionStaticKey; @@ -125,12 +124,13 @@ pub async fn v2_send_basic_job_message_for_existing_job( let job_message = JobMessage { job_id: job_id.clone(), content, - files_inbox: "".to_string(), parent: None, sheet_job_data: None, callback: None, metadata: None, tool_key: None, + fs_files_paths: vec![], + job_filenames: vec![], }; let (res_sender, res_receiver) = async_channel::bounded(1); diff --git a/shinkai-bin/shinkai-node/src/tools/tool_implementation/native_tools/llm_prompt_processor.rs b/shinkai-bin/shinkai-node/src/tools/tool_implementation/native_tools/llm_prompt_processor.rs index 110c7eabc..c89fbdd18 100644 --- a/shinkai-bin/shinkai-node/src/tools/tool_implementation/native_tools/llm_prompt_processor.rs +++ b/shinkai-bin/shinkai-node/src/tools/tool_implementation/native_tools/llm_prompt_processor.rs @@ -1,18 +1,19 @@ use shinkai_message_primitives::schemas::inbox_name::InboxName; use shinkai_sqlite::SqliteManager; use shinkai_tools_primitives::tools::parameters::Parameters; -use shinkai_tools_primitives::tools::{tool_output_arg::ToolOutputArg, error::ToolError, shinkai_tool::ShinkaiToolHeader}; -use shinkai_vector_fs::vector_fs::vector_fs::VectorFS; +use shinkai_tools_primitives::tools::{ + error::ToolError, shinkai_tool::ShinkaiToolHeader, tool_output_arg::ToolOutputArg, +}; use std::sync::Arc; use serde_json::{json, Map, Value}; -use shinkai_message_primitives::shinkai_utils::job_scope::JobScope; +use shinkai_message_primitives::shinkai_utils::job_scope::MinimalJobScope; use ed25519_dalek::SigningKey; use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; use shinkai_message_primitives::shinkai_message::shinkai_message_schemas::JobCreationInfo; -use tokio::sync::{Mutex, RwLock}; +use tokio::sync::Mutex; use x25519_dalek::PublicKey as EncryptionPublicKey; use x25519_dalek::StaticSecret as EncryptionStaticKey; @@ -70,7 +71,6 @@ impl ToolExecutor for LmPromptProcessorTool { _tool_id: String, _app_id: String, db_clone: Arc, - _vector_fs_clone: Arc, node_name_clone: ShinkaiName, identity_manager_clone: Arc>, job_manager_clone: Arc>, @@ -89,7 +89,7 @@ impl ToolExecutor for LmPromptProcessorTool { let response = v2_create_and_send_job_message( bearer.clone(), JobCreationInfo { - scope: JobScope::new_default(), + scope: MinimalJobScope::default(), is_hidden: Some(true), associated_ui: None, }, diff --git a/shinkai-bin/shinkai-node/src/tools/tool_implementation/native_tools/sql_processor.rs b/shinkai-bin/shinkai-node/src/tools/tool_implementation/native_tools/sql_processor.rs index ce1950b69..88fda7b27 100644 --- a/shinkai-bin/shinkai-node/src/tools/tool_implementation/native_tools/sql_processor.rs +++ b/shinkai-bin/shinkai-node/src/tools/tool_implementation/native_tools/sql_processor.rs @@ -1,9 +1,7 @@ use shinkai_sqlite::SqliteManager; use shinkai_tools_primitives::tools::parameters::Parameters; use shinkai_tools_primitives::tools::{shinkai_tool::ShinkaiToolHeader, tool_output_arg::ToolOutputArg}; -use shinkai_vector_fs::vector_fs::vector_fs::VectorFS; -use shinkai_vector_resources::embeddings::Embedding; -use std::path::Path; +use std::path::{Path, PathBuf}; use std::sync::Arc; use serde_json::{json, Map, Value}; @@ -21,17 +19,17 @@ use crate::managers::IdentityManager; use crate::tools::tool_implementation::tool_traits::ToolExecutor; use crate::utils::environment::fetch_node_environment; -use tokio::sync::{Mutex, RwLock}; +use tokio::sync::Mutex; use async_trait::async_trait; use r2d2::Pool; use r2d2_sqlite::SqliteConnectionManager; -use rusqlite::params_from_iter; +use rusqlite::{params_from_iter, ToSql}; // LLM Tool pub struct SQLProcessorTool { pub tool: ShinkaiToolHeader, - pub tool_embedding: Option, + pub tool_embedding: Option>, } impl SQLProcessorTool { @@ -72,8 +70,7 @@ SELECT field_1, field_3 FROM table_name WHERE field_3 > 100 ORDER BY field_2 DES input_args: { let mut params = Parameters::new(); params.add_property("query".to_string(), "string".to_string(), "The SQL query to execute".to_string(), true); - params.add_property("query_params".to_string(), "any[]".to_string(), "The parameters to pass to the query".to_string(), false); - params.add_property("database_name".to_string(), "string".to_string(), "Use 'default' for default database".to_string(), true); + params.add_property("params".to_string(), "any[]".to_string(), "The parameters to pass to the query".to_string(), false); params }, output_arg: ToolOutputArg { @@ -88,14 +85,52 @@ SELECT field_1, field_3 FROM table_name WHERE field_3 > 100 ORDER BY field_2 DES } } +fn get_folder_path(app_id: String) -> Result { + let node_env = fetch_node_environment(); + let node_storage_path = node_env + .node_storage_path + .clone() + .ok_or_else(|| ToolError::ExecutionError("Node storage path is not set".to_string()))?; + let p = Path::new(&node_storage_path) + .join("tools_storage") + .join(app_id) + .join("home") + .join("db.sqlite"); + Ok(p) +} + +pub async fn get_current_tables(app_id: String) -> Result, ToolError> { + let full_path = get_folder_path(app_id)?; + let manager = SqliteConnectionManager::file(full_path.clone()); + let pool = Pool::new(manager) + .map_err(|e| ToolError::ExecutionError(format!("Failed to create connection pool: {}", e)))?; + + let conn = pool + .get() + .map_err(|e| ToolError::ExecutionError(format!("Failed to get connection: {}", e)))?; + + let query = "SELECT sql FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'"; + + let tables = conn + .prepare(query) + .map_err(|e| ToolError::ExecutionError(format!("Failed to prepare query: {}", e)))? + .query_map(params_from_iter(&[] as &[&dyn ToSql]), |row| { + let table_sql: String = row.get(0).unwrap_or_default(); + Ok(table_sql.replace("\n", "")) + }) + .map_err(|e| ToolError::ExecutionError(format!("Failed to execute query: {}", e)))? + .collect::, _>>() + .map_err(|e| ToolError::ExecutionError(format!("Failed to collect results: {}", e)))?; + Ok(tables) +} + #[async_trait] impl ToolExecutor for SQLProcessorTool { async fn execute( _bearer: String, - tool_id: String, + _tool_id: String, app_id: String, _db_clone: Arc, - _vector_fs_clone: Arc, _node_name_clone: ShinkaiName, _identity_manager_clone: Arc>, _job_manager_clone: Arc>, @@ -110,20 +145,8 @@ impl ToolExecutor for SQLProcessorTool { .and_then(|v| v.as_str()) .ok_or_else(|| ToolError::ExecutionError("Query parameter is required".to_string()))?; - let node_env = fetch_node_environment(); - let node_storage_path = node_env - .node_storage_path - .clone() - .ok_or_else(|| ToolError::ExecutionError("Node storage path is not set".to_string()))?; - let full_path = Path::new(&node_storage_path) - .join("tools_storage") - .join(app_id) - .join("home") - .join(tool_id) - .join("db.sqlite"); - let query_params = parameters - .get("query_params") + .get("params") .and_then(|v| v.as_array()) .map(|arr| { arr.iter() @@ -131,7 +154,7 @@ impl ToolExecutor for SQLProcessorTool { .collect::>() }) .unwrap_or(vec![]); - + let full_path = get_folder_path(app_id)?; // Ensure parent directory exists if let Some(parent) = full_path.parent() { std::fs::create_dir_all(parent) diff --git a/shinkai-bin/shinkai-node/src/tools/tool_implementation/native_tools/tool_knowledge.rs b/shinkai-bin/shinkai-node/src/tools/tool_implementation/native_tools/tool_knowledge.rs index 778d6c5cc..3b1d37718 100644 --- a/shinkai-bin/shinkai-node/src/tools/tool_implementation/native_tools/tool_knowledge.rs +++ b/shinkai-bin/shinkai-node/src/tools/tool_implementation/native_tools/tool_knowledge.rs @@ -1,11 +1,9 @@ -use futures::StreamExt; use shinkai_message_primitives::schemas::job::JobLike; use shinkai_message_primitives::schemas::subprompts::SubPrompt; -use shinkai_message_primitives::shinkai_utils::job_scope::JobScope; +use shinkai_message_primitives::shinkai_utils::job_scope::MinimalJobScope; use shinkai_sqlite::SqliteManager; use shinkai_tools_primitives::tools::parameters::Parameters; use shinkai_tools_primitives::tools::{shinkai_tool::ShinkaiToolHeader, tool_output_arg::ToolOutputArg}; -use shinkai_vector_fs::vector_fs::vector_fs::VectorFS; use std::sync::Arc; use serde_json::{json, Map, Value}; @@ -21,7 +19,7 @@ use x25519_dalek::StaticSecret as EncryptionStaticKey; use crate::llm_provider::job_manager::JobManager; use crate::managers::IdentityManager; -use tokio::sync::{Mutex, RwLock}; +use tokio::sync::Mutex; use async_trait::async_trait; @@ -76,7 +74,6 @@ impl ToolExecutor for KnowledgeTool { _tool_id: String, _app_id: String, db_clone: Arc, - vector_fs: Arc, node_name: ShinkaiName, _identity_manager_clone: Arc>, _job_manager: Arc>, @@ -90,7 +87,7 @@ impl ToolExecutor for KnowledgeTool { // TODO: how do we use app_id here? is it linked to a job somehow? // TODO: create e2e test using this fn so we can test it with some real data - let mut scope = JobScope::new_default(); + let mut scope = MinimalJobScope::default(); // Checks if job_id is provided in the parameters if let Some(job_id_value) = parameters.get("job_id") { @@ -102,69 +99,34 @@ impl ToolExecutor for KnowledgeTool { Err(e) => return Err(ToolError::ExecutionError(format!("Failed to fetch job data: {}", e))), }; - if let Some(scope_with_files) = full_job.scope_with_files().clone() { - scope = scope_with_files.clone(); - } else { - return Err(ToolError::ExecutionError( - "Failed to extract scope with files".to_string(), - )); - } + scope = full_job.scope().clone(); } } - let result = tokio::task::block_in_place(|| { - tokio::runtime::Runtime::new() - .map_err(|e| ToolError::ExecutionError(e.to_string()))? - .block_on(async { - // TODO: if scope empty then return an error? - - let resource_stream = { - // Note(Nico): in the future we will get rid of this old fashion way to do embeddings - let user_profile = - ShinkaiName::from_node_and_profile_names(node_name.node_name, "main".to_string()).unwrap(); - - JobManager::retrieve_all_resources_in_job_scope_stream(vector_fs.clone(), &scope, &user_profile) - .await - }; - - let mut chunks = resource_stream.chunks(5); - let mut processed_embeddings = Vec::new(); - - while let Some(resources) = chunks.next().await { - let futures = resources.into_iter().map(|resource| async move { - let subprompts = SubPrompt::convert_resource_into_subprompts_with_extra_info(&resource, 97); - let embedding = subprompts - .iter() - .map(|subprompt| subprompt.get_content().clone()) - .collect::>() - .join(" "); - Ok::<_, ToolError>(embedding) - }); - - let results = futures::future::join_all(futures).await; - - for result in results { - match result { - Ok(processed) => processed_embeddings.push(processed), - Err(e) => { - // Log error but continue processing - eprintln!("Error processing embedding: {}", e); - } - } - } - } - - let joined_results = processed_embeddings.join(":::"); - Ok::<_, ToolError>(json!({ - "result": joined_results, - "type": "embeddings", - "rowCount": processed_embeddings.len(), - "rowsAffected": processed_embeddings.len(), - })) - }) - })?; - - Ok(result) + // Use the new method to retrieve resources + let resource_collections = JobManager::retrieve_all_resources_in_job_scope(&scope, &db_clone) + .await + .map_err(|e| ToolError::ExecutionError(format!("Failed to retrieve resources: {:?}", e)))?; + + let mut processed_embeddings = Vec::new(); + + for collection in resource_collections { + let subprompts = SubPrompt::convert_chunks_into_subprompts_with_extra_info(&collection.chunks, 97); + let embedding = subprompts + .iter() + .map(|subprompt| subprompt.get_content().clone()) + .collect::>() + .join(" "); + processed_embeddings.push(embedding); + } + + let joined_results = processed_embeddings.join(":::"); + Ok(json!({ + "result": joined_results, + "type": "embeddings", + "rowCount": processed_embeddings.len(), + "rowsAffected": processed_embeddings.len(), + })) } } diff --git a/shinkai-bin/shinkai-node/src/tools/tool_implementation/tool_traits.rs b/shinkai-bin/shinkai-node/src/tools/tool_implementation/tool_traits.rs index d6af87a18..1f3afc793 100644 --- a/shinkai-bin/shinkai-node/src/tools/tool_implementation/tool_traits.rs +++ b/shinkai-bin/shinkai-node/src/tools/tool_implementation/tool_traits.rs @@ -4,9 +4,8 @@ use serde_json::{Map, Value}; use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; use shinkai_sqlite::SqliteManager; use shinkai_tools_primitives::tools::error::ToolError; -use shinkai_vector_fs::vector_fs::vector_fs::VectorFS; use std::sync::Arc; -use tokio::sync::{Mutex, RwLock}; +use tokio::sync::Mutex; use x25519_dalek::{PublicKey as EncryptionPublicKey, StaticSecret as EncryptionStaticKey}; use crate::{llm_provider::job_manager::JobManager, managers::IdentityManager}; @@ -18,7 +17,6 @@ pub trait ToolExecutor { tool_id: String, app_id: String, db_clone: Arc, - vector_fs_clone: Arc, node_name_clone: ShinkaiName, identity_manager_clone: Arc>, job_manager_clone: Arc>, diff --git a/shinkai-bin/shinkai-node/src/utils/environment.rs b/shinkai-bin/shinkai-node/src/utils/environment.rs index c80d2df81..dded3a1b8 100644 --- a/shinkai-bin/shinkai-node/src/utils/environment.rs +++ b/shinkai-bin/shinkai-node/src/utils/environment.rs @@ -2,11 +2,11 @@ use std::env; use std::net::{IpAddr, SocketAddr}; use std::str::FromStr; +use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use shinkai_message_primitives::schemas::llm_providers::serialized_llm_provider::{ LLMProviderInterface, SerializedLLMProvider, }; use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; -use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; #[derive(Debug, Clone)] pub struct NodeEnvironment { @@ -70,6 +70,13 @@ pub fn fetch_llm_provider_env(global_identity: String) -> Vec = LLMProviderInterface::from_str(&initial_agent_models[i]); diff --git a/shinkai-bin/shinkai-node/tests/it/a2_sheet_workflow_tests.rs b/shinkai-bin/shinkai-node/tests/it/a2_sheet_workflow_tests.rs index a21094894..cb325a975 100644 --- a/shinkai-bin/shinkai-node/tests/it/a2_sheet_workflow_tests.rs +++ b/shinkai-bin/shinkai-node/tests/it/a2_sheet_workflow_tests.rs @@ -303,25 +303,26 @@ fn import_export_sheet_tests() { { eprintln!("\n\n### Sending message (APICreateFilesInboxWithSymmetricKey) from profile subidentity to node 1\n\n"); - let message_content = aes_encryption_key_to_string(symmetrical_sk); - let msg = ShinkaiMessageBuilder::create_files_inbox_with_sym_key( - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - "job::test::false".to_string(), - message_content.clone(), - node1_profile_name.to_string(), - node1_identity_name.to_string(), - node1_identity_name.to_string(), - ) - .unwrap(); - - let (res_sender, res_receiver) = async_channel::bounded(1); - node1_commands_sender - .send(NodeCommand::APICreateFilesInboxWithSymmetricKey { msg, res: res_sender }) - .await - .unwrap(); - let _ = res_receiver.recv().await.unwrap().expect("Failed to receive messages"); + // TODO: remove this + // let message_content = aes_encryption_key_to_string(symmetrical_sk); + // let msg = ShinkaiMessageBuilder::create_files_inbox_with_sym_key( + // node1_profile_encryption_sk.clone(), + // clone_signature_secret_key(&node1_profile_identity_sk), + // node1_encryption_pk, + // "job::test::false".to_string(), + // message_content.clone(), + // node1_profile_name.to_string(), + // node1_identity_name.to_string(), + // node1_identity_name.to_string(), + // ) + // .unwrap(); + + // let (res_sender, res_receiver) = async_channel::bounded(1); + // node1_commands_sender + // .send(NodeCommand::APICreateFilesInboxWithSymmetricKey { msg, res: res_sender }) + // .await + // .unwrap(); + // let _ = res_receiver.recv().await.unwrap().expect("Failed to receive messages"); } let mut sheet_id = "".to_string(); { diff --git a/shinkai-bin/shinkai-node/tests/it/a3_micropayment_flow_tests.rs b/shinkai-bin/shinkai-node/tests/it/a3_micropayment_flow_tests.rs index 382648aaf..ecbd5eab0 100644 --- a/shinkai-bin/shinkai-node/tests/it/a3_micropayment_flow_tests.rs +++ b/shinkai-bin/shinkai-node/tests/it/a3_micropayment_flow_tests.rs @@ -14,12 +14,12 @@ use shinkai_message_primitives::shinkai_utils::signatures::{ clone_signature_secret_key, signature_public_key_to_string, signature_secret_key_to_string, unsafe_deterministic_signature_keypair, }; +use shinkai_message_primitives::shinkai_utils::utils::hash_string; use shinkai_node::network::Node; use shinkai_tools_primitives::tools::tool_output_arg::ToolOutputArg; use shinkai_tools_primitives::tools::network_tool::NetworkTool; use shinkai_tools_primitives::tools::parameters::Parameters; use shinkai_tools_primitives::tools::shinkai_tool::{ShinkaiTool, ShinkaiToolHeader}; -use shinkai_vector_resources::utils::hash_string; use std::net::{IpAddr, Ipv4Addr}; use std::sync::Arc; use std::{net::SocketAddr, time::Duration}; @@ -110,7 +110,6 @@ fn micropayment_flow_test() { None, true, vec![], - node1_fs_db_path, None, None, default_embedding_model(), @@ -134,7 +133,6 @@ fn micropayment_flow_test() { None, true, vec![], - node2_fs_db_path, None, None, default_embedding_model(), diff --git a/shinkai-bin/shinkai-node/tests/it/change_nodes_name_tests.rs b/shinkai-bin/shinkai-node/tests/it/change_nodes_name_tests.rs index 144cf5c2f..ab59bc6c4 100644 --- a/shinkai-bin/shinkai-node/tests/it/change_nodes_name_tests.rs +++ b/shinkai-bin/shinkai-node/tests/it/change_nodes_name_tests.rs @@ -64,7 +64,6 @@ fn change_nodes_name_test() { None, true, vec![], - node1_fs_db_path, None, None, default_embedding_model(), @@ -159,7 +158,7 @@ fn change_nodes_name_test() { None, true, vec![], - node1_fs_db_path, + None, None, default_embedding_model(), diff --git a/shinkai-bin/shinkai-node/tests/it/db_identity_tests.rs b/shinkai-bin/shinkai-node/tests/it/db_identity_tests.rs index 6d784be1d..c9962d0bb 100644 --- a/shinkai-bin/shinkai-node/tests/it/db_identity_tests.rs +++ b/shinkai-bin/shinkai-node/tests/it/db_identity_tests.rs @@ -1,3 +1,4 @@ +use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use shinkai_message_primitives::schemas::identity::{StandardIdentity, StandardIdentityType}; use shinkai_message_primitives::schemas::shinkai_name::{ShinkaiName, ShinkaiSubidentityType}; use shinkai_message_primitives::shinkai_message::shinkai_message_schemas::{IdentityPermissions, RegistrationCodeType}; @@ -9,11 +10,10 @@ use shinkai_message_primitives::shinkai_utils::signatures::{ }; use shinkai_sqlite::errors::SqliteManagerError; use shinkai_sqlite::SqliteManager; -use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; + use std::path::PathBuf; use std::sync::Arc; use tempfile::NamedTempFile; -use tokio::sync::RwLock; use ed25519_dalek::VerifyingKey; use x25519_dalek::PublicKey as EncryptionPublicKey; diff --git a/shinkai-bin/shinkai-node/tests/it/db_inbox_tests.rs b/shinkai-bin/shinkai-node/tests/it/db_inbox_tests.rs index b537e240c..0dd60ae92 100644 --- a/shinkai-bin/shinkai-node/tests/it/db_inbox_tests.rs +++ b/shinkai-bin/shinkai-node/tests/it/db_inbox_tests.rs @@ -1,3 +1,4 @@ +use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use shinkai_message_primitives::schemas::identity::{StandardIdentity, StandardIdentityType}; use shinkai_message_primitives::schemas::inbox_name::InboxName; use shinkai_message_primitives::schemas::inbox_permission::InboxPermission; @@ -15,7 +16,7 @@ use shinkai_message_primitives::shinkai_utils::signatures::{ }; use shinkai_sqlite::errors::SqliteManagerError; use shinkai_sqlite::SqliteManager; -use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; + use std::path::PathBuf; use std::sync::Arc; use tempfile::NamedTempFile; diff --git a/shinkai-bin/shinkai-node/tests/it/db_job_tests.rs b/shinkai-bin/shinkai-node/tests/it/db_job_tests.rs index 8475ae86b..529004a8c 100644 --- a/shinkai-bin/shinkai-node/tests/it/db_job_tests.rs +++ b/shinkai-bin/shinkai-node/tests/it/db_job_tests.rs @@ -1,12 +1,11 @@ +use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use shinkai_message_primitives::schemas::inbox_name::InboxName; -use shinkai_message_primitives::schemas::subprompts::SubPromptType::{Assistant, User}; use shinkai_message_primitives::shinkai_message::shinkai_message::ShinkaiMessage; use shinkai_message_primitives::shinkai_message::shinkai_message_schemas::MessageSchemaType; use shinkai_message_primitives::shinkai_utils::encryption::EncryptionMethod; -use shinkai_message_primitives::shinkai_utils::job_scope::JobScope; +use shinkai_message_primitives::shinkai_utils::job_scope::MinimalJobScope; use shinkai_message_primitives::shinkai_utils::shinkai_message_builder::ShinkaiMessageBuilder; use shinkai_sqlite::SqliteManager; -use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use std::path::PathBuf; use std::sync::Arc; use tempfile::NamedTempFile; @@ -15,7 +14,7 @@ use tokio::time::{sleep, Duration}; use ed25519_dalek::SigningKey; use x25519_dalek::{PublicKey as EncryptionPublicKey, StaticSecret as EncryptionStaticKey}; -async fn create_new_job(db: &Arc, job_id: String, agent_id: String, scope: JobScope) { +async fn create_new_job(db: &Arc, job_id: String, agent_id: String, scope: MinimalJobScope) { match db.create_new_job(job_id, agent_id, scope, false, None, None) { Ok(_) => (), Err(e) => panic!("Failed to create a new job: {}", e), @@ -69,7 +68,7 @@ fn generate_message_with_text( #[cfg(test)] mod tests { - use std::collections::{HashMap, HashSet}; + use std::collections::HashSet; use super::*; use shinkai_message_primitives::{ @@ -84,7 +83,7 @@ mod tests { shinkai_message::shinkai_message_schemas::{IdentityPermissions, JobMessage}, shinkai_utils::{ encryption::unsafe_deterministic_encryption_keypair, - job_scope::JobScope, + job_scope::MinimalJobScope, shinkai_message_builder::ShinkaiMessageBuilder, signatures::{clone_signature_secret_key, unsafe_deterministic_signature_keypair}, }, @@ -95,7 +94,7 @@ mod tests { async fn test_create_new_job() { let job_id = "job1".to_string(); let agent_id = "agent1".to_string(); - let scope = JobScope::new_default(); + let scope = MinimalJobScope::default(); let db = setup_test_db(); let shinkai_db = Arc::new(db); @@ -126,7 +125,7 @@ mod tests { for i in 1..=5 { let job_id = format!("job{}", i); eprintln!("job_id: {}", job_id.clone()); - let scope = JobScope::new_default(); + let scope = MinimalJobScope::default(); let _ = create_new_job(&shinkai_db, job_id, agent_id.clone(), scope).await; } @@ -149,7 +148,7 @@ mod tests { let job_id = "job_to_change_agent".to_string(); let initial_agent_id = "initial_agent".to_string(); let new_agent_id = "new_agent".to_string(); - let scope = JobScope::new_default(); + let scope = MinimalJobScope::default(); let db = setup_test_db(); let shinkai_db = Arc::new(db); @@ -181,7 +180,7 @@ mod tests { // let inbox_name = // InboxName::new("inbox::@@node1.shinkai/subidentity::@@node2.shinkai/subidentity2::true".to_string()) // .unwrap(); - let scope = JobScope::new_default(); + let scope = MinimalJobScope::default(); let db = setup_test_db(); let shinkai_db = Arc::new(db); @@ -196,67 +195,6 @@ mod tests { assert!(job.is_finished); } - #[tokio::test] - async fn test_update_step_history() { - let job_id = "test_job".to_string(); - let db = setup_test_db(); - let shinkai_db = Arc::new(db); - - let node1_identity_name = "@@node1.shinkai"; - let node1_subidentity_name = "main_profile_node1"; - let (node1_identity_sk, _) = unsafe_deterministic_signature_keypair(0); - let (node1_encryption_sk, node1_encryption_pk) = unsafe_deterministic_encryption_keypair(0); - - let agent_id = "agent_test".to_string(); - let scope = JobScope::new_default(); - - // Create a new job - let _ = create_new_job(&shinkai_db, job_id.clone(), agent_id.clone(), scope).await; - - let message = generate_message_with_text( - "Hello World".to_string(), - node1_encryption_sk.clone(), - clone_signature_secret_key(&node1_identity_sk), - node1_encryption_pk, - node1_subidentity_name.to_string(), - node1_identity_name.to_string(), - "2023-07-02T20:53:34.810Z".to_string(), - ); - - // Insert the ShinkaiMessage into the database - shinkai_db - .unsafe_insert_inbox_message(&message, None, None) - .await - .unwrap(); - - // Update step history - shinkai_db - .add_step_history( - job_id.clone(), - "What is 10 + 25".to_string(), - None, - "The answer is 35".to_string(), - None, - None, - ) - .unwrap(); - sleep(Duration::from_millis(10)).await; - shinkai_db - .add_step_history( - job_id.clone(), - "2) What is 10 + 25".to_string(), - None, - "2) The answer is 35".to_string(), - None, - None, - ) - .unwrap(); - - // Retrieve the job and check that step history is updated - let job = shinkai_db.get_job(&job_id.clone()).unwrap(); - assert_eq!(job.step_history.len(), 2); - } - #[tokio::test] async fn test_get_non_existent_job() { let job_id = "non_existent_job".to_string(); @@ -319,7 +257,7 @@ mod tests { // let inbox_names = vec![inbox_name]; // let documents = vec!["document1".to_string(), "document2".to_string()]; - let scope = JobScope::new_default(); + let scope = MinimalJobScope::default(); let _ = create_new_job(&shinkai_db, job_id, agent_id.clone(), scope).await; } @@ -338,7 +276,7 @@ mod tests { async fn test_job_inbox_empty() { let job_id = "job_test".to_string(); let agent_id = "agent_test".to_string(); - let scope = JobScope::new_default(); + let scope = MinimalJobScope::default(); let db = setup_test_db(); let shinkai_db = Arc::new(db); @@ -352,7 +290,7 @@ mod tests { let shinkai_message = ShinkaiMessageBuilder::job_message_from_llm_provider( job_id.to_string(), "something".to_string(), - "".to_string(), + vec![], None, placeholder_signature_sk, "@@node1.shinkai".to_string(), @@ -373,7 +311,7 @@ mod tests { async fn test_job_inbox_tree_structure() { let job_id = "job_test".to_string(); let agent_id = "agent_test".to_string(); - let scope = JobScope::new_default(); + let scope = MinimalJobScope::default(); let db = setup_test_db(); let shinkai_db = Arc::new(db); @@ -396,7 +334,7 @@ mod tests { let shinkai_message = ShinkaiMessageBuilder::job_message_from_llm_provider( job_id.clone(), format!("Hello World {}", i), - "".to_string(), + vec![], None, placeholder_signature_sk.clone(), "@@node1.shinkai".to_string(), @@ -465,175 +403,6 @@ mod tests { assert_eq!(job_message_4.content, "Hello World 4".to_string()); } - #[tokio::test] - async fn test_job_inbox_tree_structure_with_step_history_and_execution_context() { - let job_id = "job_test".to_string(); - let agent_id = "agent_test".to_string(); - let scope = JobScope::new_default(); - let db = setup_test_db(); - let shinkai_db = Arc::new(db); - - // Create a new job - let _ = create_new_job(&shinkai_db, job_id.clone(), agent_id.clone(), scope).await; - - let (placeholder_signature_sk, _) = unsafe_deterministic_signature_keypair(0); - - let mut parent_message_hash: Option = None; - let mut parent_message_hash_2: Option = None; - - /* - The tree that we are creating looks like: - 1 - ├── 2 - │ ├── 4 - └── 3 - */ - let mut current_level = 0; - let mut results = Vec::new(); - for i in 1..=4 { - let shinkai_message = ShinkaiMessageBuilder::job_message_from_llm_provider( - job_id.clone(), - format!("Hello World {}", i), - "".to_string(), - None, - placeholder_signature_sk.clone(), - "@@node1.shinkai".to_string(), - "@@node1.shinkai".to_string(), - ) - .unwrap(); - - let parent_hash: Option = match i { - 2 | 3 => { - current_level += 1; - parent_message_hash.clone() - } - 4 => { - results.pop(); - parent_message_hash_2.clone() - } - _ => None, - }; - - // Add a message to the job - let _ = shinkai_db - .add_message_to_job_inbox(&job_id.clone(), &shinkai_message, parent_hash.clone(), None) - .await; - - // Add a step history - let result = format!("Result {}", i); - shinkai_db - .add_step_history( - job_id.clone(), - format!("Step {} Level {}", i, current_level), - None, - result.clone(), - None, - None, - ) - .unwrap(); - - // Add the result to the results vector - results.push(result); - - // Set job execution context - let mut execution_context = HashMap::new(); - execution_context.insert("context".to_string(), results.join(", ")); - shinkai_db - .set_job_execution_context(job_id.clone(), execution_context, None) - .unwrap(); - - // Update the parent message according to the tree structure - if i == 1 { - parent_message_hash = Some(shinkai_message.calculate_message_hash_for_pagination()); - } else if i == 2 { - parent_message_hash_2 = Some(shinkai_message.calculate_message_hash_for_pagination()); - } - - tokio::time::sleep(Duration::from_millis(200)).await; - } - - // Check if the job inbox is not empty after adding a message - assert!(!shinkai_db.is_job_inbox_empty(&job_id).unwrap()); - - // Get the inbox name - let inbox_name = InboxName::get_job_inbox_name_from_params(job_id.clone()).unwrap(); - let inbox_name_value = match inbox_name { - InboxName::RegularInbox { value, .. } | InboxName::JobInbox { value, .. } => value, - }; - - // Get the messages from the job inbox - let last_messages_inbox = shinkai_db - .get_last_messages_from_inbox(inbox_name_value.clone().to_string(), 4, None) - .unwrap(); - - // Check the content of the messages - assert_eq!(last_messages_inbox.len(), 3); - - // Check the content of the first message array - assert_eq!(last_messages_inbox[0].len(), 1); - let message_content_1 = last_messages_inbox[0][0].clone().get_message_content().unwrap(); - let job_message_1: JobMessage = serde_json::from_str(&message_content_1).unwrap(); - assert_eq!(job_message_1.content, "Hello World 1".to_string()); - - // Check the content of the second message array - assert_eq!(last_messages_inbox[1].len(), 2); - let message_content_2 = last_messages_inbox[1][0].clone().get_message_content().unwrap(); - let job_message_2: JobMessage = serde_json::from_str(&message_content_2).unwrap(); - assert_eq!(job_message_2.content, "Hello World 2".to_string()); - - let message_content_3 = last_messages_inbox[1][1].clone().get_message_content().unwrap(); - let job_message_3: JobMessage = serde_json::from_str(&message_content_3).unwrap(); - assert_eq!(job_message_3.content, "Hello World 3".to_string()); - - // Check the content of the third message array - assert_eq!(last_messages_inbox[2].len(), 1); - let message_content_4 = last_messages_inbox[2][0].clone().get_message_content().unwrap(); - let job_message_4: JobMessage = serde_json::from_str(&message_content_4).unwrap(); - assert_eq!(job_message_4.content, "Hello World 4".to_string()); - - // Check the step history and execution context - let job = shinkai_db.get_job(&job_id.clone()).unwrap(); - eprintln!("job execution context: {:?}", job.execution_context); - - // Check the execution context - assert_eq!( - job.execution_context.get("context").unwrap(), - "Result 1, Result 2, Result 4" - ); - - // Check the step history - let step1 = &job.step_history[0]; - let step2 = &job.step_history[1]; - let step4 = &job.step_history[2]; - - assert_eq!( - step1.step_revisions[0].sub_prompts[0], - SubPrompt::Omni(User, "Step 1 Level 0".to_string(), vec![], 100) - ); - assert_eq!( - step1.step_revisions[0].sub_prompts[1], - SubPrompt::Omni(Assistant, "Result 1".to_string(), vec![], 100) - ); - - assert_eq!( - step2.step_revisions[0].sub_prompts[0], - SubPrompt::Omni(User, "Step 2 Level 1".to_string(), vec![], 100) - ); - assert_eq!( - step2.step_revisions[0].sub_prompts[1], - SubPrompt::Omni(Assistant, "Result 2".to_string(), vec![], 100) - ); - - assert_eq!( - step4.step_revisions[0].sub_prompts[0], - SubPrompt::Omni(User, "Step 4 Level 2".to_string(), vec![], 100) - ); - assert_eq!( - step4.step_revisions[0].sub_prompts[1], - SubPrompt::Omni(Assistant, "Result 4".to_string(), vec![], 100) - ); - } - #[tokio::test] async fn test_insert_steps_with_simple_tree_structure() { let node1_identity_name = "@@node1.shinkai"; @@ -643,7 +412,7 @@ mod tests { let job_id = "test_job"; let agent_id = "agent_test".to_string(); - let scope = JobScope::new_default(); + let scope = MinimalJobScope::default(); let db = setup_test_db(); let shinkai_db = Arc::new(db); @@ -662,12 +431,11 @@ mod tests { └── 3 */ for i in 1..=4 { - let user_message = format!("User message {}", i); - let agent_response = format!("Agent response {}", i); + let message_content = format!("Message {}", i); // Generate the ShinkaiMessage let message = generate_message_with_text( - format!("Hello World {}", i), + message_content.clone(), node1_encryption_sk.clone(), clone_signature_secret_key(&node1_identity_sk), node1_encryption_pk, @@ -676,8 +444,6 @@ mod tests { format!("2023-07-02T20:53:34.81{}Z", i), ); - eprintln!("Message: {:?}", message); - let parent_hash: Option = match i { 2 | 3 => parent_message_hash.clone(), 4 => parent_message_hash_2.clone(), @@ -690,10 +456,6 @@ mod tests { .await .unwrap(); - shinkai_db - .add_step_history(job_id.to_string(), user_message, None, agent_response, None, None) - .unwrap(); - // Update the parent message hash according to the tree structure if i == 1 { parent_message_hash = Some(message.calculate_message_hash_for_pagination()); @@ -704,7 +466,6 @@ mod tests { tokio::time::sleep(Duration::from_millis(200)).await; } - eprintln!("\n\n Getting messages..."); let inbox_name = InboxName::get_job_inbox_name_from_params(job_id.to_string()).unwrap(); let last_messages_inbox = shinkai_db .get_last_messages_from_inbox(inbox_name.to_string(), 3, None) @@ -728,16 +489,16 @@ mod tests { let step_history_content: Vec = step_history .iter() - .map(|step| { - let user_message = match &step.step_revisions[0].sub_prompts[0] { - SubPrompt::Omni(_, text, _, _) => text, - _ => panic!("Unexpected SubPrompt variant"), - }; - let agent_response = match &step.step_revisions[0].sub_prompts[1] { + .map(|shinkai_message| { + eprintln!("Shinkai message: {:?}", shinkai_message); + let prompt = shinkai_message.to_prompt(); + eprintln!("Prompt: {:?}", prompt); + + let message_content = match &prompt.sub_prompts[0] { SubPrompt::Omni(_, text, _, _) => text, _ => panic!("Unexpected SubPrompt variant"), }; - format!("{} {}", user_message, agent_response) + message_content.clone() }) .collect(); @@ -746,55 +507,16 @@ mod tests { assert_eq!(step_history.len(), 3); // Check the content of the steps - assert_eq!( - format!( - "{} {}", - match &step_history[0].step_revisions[0].sub_prompts[0] { - SubPrompt::Omni(_, text, _, _) => text, - _ => panic!("Unexpected SubPrompt variant"), - }, - match &step_history[0].step_revisions[0].sub_prompts[1] { - SubPrompt::Omni(_, text, _, _) => text, - _ => panic!("Unexpected SubPrompt variant"), - } - ), - "User message 1 Agent response 1".to_string() - ); - assert_eq!( - format!( - "{} {}", - match &step_history[1].step_revisions[0].sub_prompts[0] { - SubPrompt::Omni(_, text, _, _) => text, - _ => panic!("Unexpected SubPrompt variant"), - }, - match &step_history[1].step_revisions[0].sub_prompts[1] { - SubPrompt::Omni(_, text, _, _) => text, - _ => panic!("Unexpected SubPrompt variant"), - } - ), - "User message 2 Agent response 2".to_string() - ); - assert_eq!( - format!( - "{} {}", - match &step_history[2].step_revisions[0].sub_prompts[0] { - SubPrompt::Omni(_, text, _, _) => text, - _ => panic!("Unexpected SubPrompt variant"), - }, - match &step_history[2].step_revisions[0].sub_prompts[1] { - SubPrompt::Omni(_, text, _, _) => text, - _ => panic!("Unexpected SubPrompt variant"), - } - ), - "User message 4 Agent response 4".to_string() - ); + assert_eq!(step_history_content[0], "Message 1".to_string()); + assert_eq!(step_history_content[1], "Message 2".to_string()); + assert_eq!(step_history_content[2], "Message 4".to_string()); } #[tokio::test] async fn test_job_inbox_tree_structure_with_invalid_date() { let job_id = "job_test".to_string(); let agent_id = "agent_test".to_string(); - let scope = JobScope::new_default(); + let scope = MinimalJobScope::default(); let db = setup_test_db(); let shinkai_db = Arc::new(db); @@ -809,7 +531,7 @@ mod tests { let shinkai_message = ShinkaiMessageBuilder::job_message_from_llm_provider( job_id.clone(), format!("Hello World {}", i), - "".to_string(), + vec![], None, placeholder_signature_sk.clone(), "@@node1.shinkai".to_string(), @@ -877,7 +599,7 @@ mod tests { async fn test_add_forked_job() { let job_id = "job1".to_string(); let agent_id = "agent1".to_string(); - let scope = JobScope::new_default(); + let scope = MinimalJobScope::default(); let db = setup_test_db(); let shinkai_db = Arc::new(db); @@ -900,7 +622,7 @@ mod tests { let shinkai_message = ShinkaiMessageBuilder::job_message_from_llm_provider( job_id.clone(), format!("Hello World {}", i), - "".to_string(), + vec![], None, placeholder_signature_sk.clone(), "@@node1.shinkai".to_string(), @@ -987,7 +709,7 @@ mod tests { let job1_id = "job1".to_string(); let job2_id = "job2".to_string(); let agent_id = "agent1".to_string(); - let scope = JobScope::new_default(); + let scope = MinimalJobScope::default(); let db = setup_test_db(); let shinkai_db = Arc::new(db); diff --git a/shinkai-bin/shinkai-node/tests/it/db_llm_providers_tests.rs b/shinkai-bin/shinkai-node/tests/it/db_llm_providers_tests.rs index 931d13120..05f5c27ca 100644 --- a/shinkai-bin/shinkai-node/tests/it/db_llm_providers_tests.rs +++ b/shinkai-bin/shinkai-node/tests/it/db_llm_providers_tests.rs @@ -1,9 +1,8 @@ +use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use shinkai_sqlite::SqliteManager; -use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use std::path::PathBuf; use std::sync::Arc; use tempfile::NamedTempFile; -use tokio::sync::RwLock; fn setup_test_db() -> SqliteManager { let temp_file = NamedTempFile::new().unwrap(); diff --git a/shinkai-bin/shinkai-node/tests/it/db_restore_tests.rs b/shinkai-bin/shinkai-node/tests/it/db_restore_tests.rs index 8113a4603..f5c6bde5b 100644 --- a/shinkai-bin/shinkai-node/tests/it/db_restore_tests.rs +++ b/shinkai-bin/shinkai-node/tests/it/db_restore_tests.rs @@ -57,7 +57,6 @@ mod tests { None, true, vec![], - node1_vector_fs_path, None, None, default_embedding_model(), diff --git a/shinkai-bin/shinkai-node/tests/it/encrypted_files_tests.rs b/shinkai-bin/shinkai-node/tests/it/encrypted_files_tests.rs deleted file mode 100644 index bf435866d..000000000 --- a/shinkai-bin/shinkai-node/tests/it/encrypted_files_tests.rs +++ /dev/null @@ -1,436 +0,0 @@ -use super::utils::db_handlers::setup_node_storage_path; -use super::utils::test_boilerplate::run_test_one_node_network; -use aes_gcm::aead::{generic_array::GenericArray, Aead}; -use aes_gcm::Aes256Gcm; -use aes_gcm::KeyInit; -use shinkai_http_api::node_commands::NodeCommand; -use shinkai_message_primitives::schemas::llm_providers::serialized_llm_provider::{ - LLMProviderInterface, OpenAI, SerializedLLMProvider, -}; -use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; -use shinkai_message_primitives::shinkai_message::shinkai_message_schemas::{JobMessage, MessageSchemaType}; -use shinkai_message_primitives::shinkai_utils::encryption::{clone_static_secret_key, EncryptionMethod}; -use shinkai_message_primitives::shinkai_utils::file_encryption::{ - aes_encryption_key_to_string, aes_nonce_to_hex_string, hash_of_aes_encryption_key_hex, - unsafe_deterministic_aes_encryption_key, -}; -use shinkai_message_primitives::shinkai_utils::shinkai_message_builder::ShinkaiMessageBuilder; -use shinkai_message_primitives::shinkai_utils::signatures::clone_signature_secret_key; -use shinkai_vector_resources::resource_errors::VRError; -use std::path::Path; -use std::time::Duration; -use std::time::Instant; - -use super::utils::node_test_api::{ - api_create_job, api_get_all_inboxes_from_profile, api_get_all_smart_inboxes_from_profile, - api_initial_registration_with_no_code_for_device, api_llm_provider_registration, api_message_job, -}; -use mockito::Server; - -#[test] -fn sandwich_messages_with_files_test() { - setup_node_storage_path(); - unsafe { std::env::set_var("WELCOME_MESSAGE", "false") }; - unsafe { std::env::set_var("ONLY_TESTING_JS_TOOLS", "true") }; - - let mut server = Server::new(); - - run_test_one_node_network(|env| { - Box::pin(async move { - let node1_commands_sender = env.node1_commands_sender.clone(); - let node1_identity_name = env.node1_identity_name.clone(); - let node1_profile_name = env.node1_profile_name.clone(); - let node1_device_name = env.node1_device_name.clone(); - let node1_agent = env.node1_llm_provider.clone(); - let node1_encryption_pk = env.node1_encryption_pk; - let node1_device_encryption_sk = env.node1_device_encryption_sk.clone(); - let node1_profile_encryption_sk = env.node1_profile_encryption_sk.clone(); - let node1_device_identity_sk = clone_signature_secret_key(&env.node1_device_identity_sk); - let node1_profile_identity_sk = clone_signature_secret_key(&env.node1_profile_identity_sk); - let node1_abort_handler = env.node1_abort_handler; - - // For this test - let symmetrical_sk = unsafe_deterministic_aes_encryption_key(0); - - { - // Register a Profile in Node1 and verifies it - eprintln!("\n\nRegister a Device with main Profile in Node1 and verify it"); - api_initial_registration_with_no_code_for_device( - node1_commands_sender.clone(), - env.node1_profile_name.as_str(), - env.node1_identity_name.as_str(), - node1_encryption_pk, - node1_device_encryption_sk.clone(), - clone_signature_secret_key(&node1_device_identity_sk), - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_device_name.as_str(), - ) - .await; - } - - { - // Register an Agent - eprintln!("\n\nRegister an Agent in Node1 and verify it"); - let agent_name = ShinkaiName::new( - format!( - "{}/{}/agent/{}", - node1_identity_name.clone(), - node1_profile_name.clone(), - node1_agent.clone() - ) - .to_string(), - ) - .unwrap(); - - let _m = server - .mock("POST", "/v1/chat/completions") - .match_header("authorization", "Bearer mockapikey") - .with_status(200) - .with_header("content-type", "application/json") - .with_body( - r#"{ - "id": "chatcmpl-123", - "object": "chat.completion", - "created": 1677652288, - "choices": [{ - "index": 0, - "message": { - "role": "assistant", - "content": "Hello there, how may I assist you today?" - }, - "finish_reason": "stop" - }], - "usage": { - "prompt_tokens": 9, - "completion_tokens": 12, - "total_tokens": 21 - } - }"#, - ) - .create(); - - let open_ai = OpenAI { - model_type: "gpt-4-1106-preview".to_string(), - }; - - // let generic_api = GenericAPI { - // model_type: "togethercomputer/llama-2-70b-chat".to_string(), - // }; - - let agent = SerializedLLMProvider { - id: node1_agent.clone().to_string(), - full_identity_name: agent_name, - // external_url: Some("https://api.openai.com".to_string()), - // api_key: env::var("INITIAL_AGENT_API_KEY").ok(), - external_url: Some(server.url()), - api_key: Some("mockapikey".to_string()), - // external_url: Some("https://api.together.xyz".to_string()), - model: LLMProviderInterface::OpenAI(open_ai), - // model: LLMProviderInterface::GenericAPI(generic_api), - }; - api_llm_provider_registration( - node1_commands_sender.clone(), - clone_static_secret_key(&node1_profile_encryption_sk), - node1_encryption_pk, - clone_signature_secret_key(&node1_profile_identity_sk), - node1_identity_name.clone().as_str(), - node1_profile_name.clone().as_str(), - agent, - ) - .await; - } - - let mut job_id = "".to_string(); - let agent_subidentity = format!("{}/agent/{}", node1_profile_name.clone(), node1_agent.clone()).to_string(); - { - // Create a Job - eprintln!("\n\nCreate a Job for the previous Agent in Node1 and verify it"); - job_id = api_create_job( - node1_commands_sender.clone(), - clone_static_secret_key(&node1_profile_encryption_sk), - node1_encryption_pk, - clone_signature_secret_key(&node1_profile_identity_sk), - node1_identity_name.clone().as_str(), - node1_profile_name.clone().as_str(), - &agent_subidentity.clone(), - ) - .await; - } - { - // api_get_all_inboxes_from_profile - eprintln!("\n\nGet All Profiles"); - let inboxes = api_get_all_inboxes_from_profile( - node1_commands_sender.clone(), - clone_static_secret_key(&node1_profile_encryption_sk), - node1_encryption_pk, - clone_signature_secret_key(&node1_profile_identity_sk), - node1_identity_name.clone().as_str(), - node1_profile_name.clone().as_str(), - node1_identity_name.clone().as_str(), - ) - .await; - assert_eq!(inboxes.len(), 1); - } - // Send message (APICreateFilesInboxWithSymmetricKey) from Device subidentity to Node 1 - { - eprintln!("\n\n### Sending message (APICreateFilesInboxWithSymmetricKey) from profile subidentity to node 1\n\n"); - - let message_content = aes_encryption_key_to_string(symmetrical_sk); - let msg = ShinkaiMessageBuilder::create_files_inbox_with_sym_key( - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - "job::test::false".to_string(), - message_content.clone(), - node1_profile_name.to_string(), - node1_identity_name.to_string(), - node1_identity_name.to_string(), - ) - .unwrap(); - - let (res_sender, res_receiver) = async_channel::bounded(1); - node1_commands_sender - .send(NodeCommand::APICreateFilesInboxWithSymmetricKey { msg, res: res_sender }) - .await - .unwrap(); - let _response = res_receiver.recv().await.unwrap().expect("Failed to receive messages"); - } - { - eprintln!("\n\n### Sending Second message (APIAddFileToInboxWithSymmetricKey) from profile subidentity to node 1\n\n"); - - // Prepare the file to be read - let filename = "../../files/zeko_mini.vrkai"; - let file_path = Path::new(filename); - - // Read the file into a buffer - let file_data = std::fs::read(file_path).map_err(|_| VRError::FailedPDFParsing).unwrap(); - - // Encrypt the file using Aes256Gcm - let cipher = Aes256Gcm::new(GenericArray::from_slice(&symmetrical_sk)); - let nonce = GenericArray::from_slice(&[0u8; 12]); - let nonce_slice = nonce.as_slice(); - let nonce_str = aes_nonce_to_hex_string(nonce_slice); - let ciphertext = cipher.encrypt(nonce, file_data.as_ref()).expect("encryption failure!"); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIAddFileToInboxWithSymmetricKey { - filename: filename.to_string(), - file: ciphertext, - public_key: hash_of_aes_encryption_key_hex(symmetrical_sk), - encrypted_nonce: nonce_str, - res: res_sender, - }) - .await - .unwrap(); - - // Receive the response - let response = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - eprintln!("response: {}", response); - } - { - // Get filenames in inbox - let message_content = hash_of_aes_encryption_key_hex(symmetrical_sk); - let msg = ShinkaiMessageBuilder::new( - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - ) - .message_raw_content(message_content.clone()) - .body_encryption(EncryptionMethod::DiffieHellmanChaChaPoly1305) - .message_schema_type(MessageSchemaType::TextContent) - .internal_metadata( - node1_profile_name.to_string().clone(), - "".to_string(), - EncryptionMethod::None, - None, - ) - .external_metadata_with_intra_sender( - node1_identity_name.to_string(), - node1_identity_name.to_string().clone(), - node1_profile_name.to_string().clone(), - ) - .build() - .unwrap(); - - let (res_sender, res_receiver) = async_channel::bounded(1); - // Send the command - node1_commands_sender - .send(NodeCommand::APIGetFilenamesInInbox { msg, res: res_sender }) - .await - .unwrap(); - - // Receive the response - let response = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - assert_eq!(response, vec!["../../files/zeko_mini.vrkai"]); - } - // { - // let _m = server - // .mock("POST", "/v1/chat/completions") - // .match_header("authorization", "Bearer mockapikey") - // .with_status(200) - // .with_header("content-type", "application/json") - // .with_body( - // r#"{ - // "id": "chatcmpl-123", - // "object": "chat.completion", - // "created": 1677652288, - // "choices": [{ - // "index": 0, - // "message": { - // "role": "assistant", - // "content": "\n\n{\"answer\": \"Hello there, how may I assist you today?\"}" - // }, - // "finish_reason": "stop" - // }], - // "usage": { - // "prompt_tokens": 9, - // "completion_tokens": 12, - // "total_tokens": 21 - // } - // }"#, - // ) - // .create(); - // } - - let job_message_content = "What's Zeko?".to_string(); - { - // Send a Message to the Job for processing - eprintln!("\n\nSend a message for the Job"); - let start = Instant::now(); - api_message_job( - node1_commands_sender.clone(), - clone_static_secret_key(&node1_profile_encryption_sk), - node1_encryption_pk, - clone_signature_secret_key(&node1_profile_identity_sk), - node1_identity_name.clone().as_str(), - node1_profile_name.clone().as_str(), - &agent_subidentity.clone(), - &job_id.clone().to_string(), - &job_message_content, - &hash_of_aes_encryption_key_hex(symmetrical_sk), - "", - ) - .await; - - let duration = start.elapsed(); // Get the time elapsed since the start of the timer - eprintln!("Time elapsed in api_message_job is: {:?}", duration); - } - { - // api_get_all_smart_inboxes_from_profile - eprintln!("\n\n Get All Smart Inboxes"); - let inboxes = api_get_all_smart_inboxes_from_profile( - node1_commands_sender.clone(), - clone_static_secret_key(&node1_profile_encryption_sk), - node1_encryption_pk, - clone_signature_secret_key(&node1_profile_identity_sk), - node1_identity_name.clone().as_str(), - node1_profile_name.clone().as_str(), - node1_identity_name.clone().as_str(), - ) - .await; - assert_eq!(inboxes.len(), 1); - assert_eq!(inboxes[0].custom_name, "What's Zeko?"); - } - - { - eprintln!("Waiting for the Job to finish"); - for _ in 0..50 { - let (res1_sender, res1_receiver) = async_channel::bounded(1); - node1_commands_sender - .send(NodeCommand::FetchLastMessages { - limit: 2, - res: res1_sender, - }) - .await - .unwrap(); - let node1_last_messages = res1_receiver.recv().await.unwrap(); - eprintln!("node1_last_messages: {:?}", node1_last_messages); - - match node1_last_messages[0].get_message_content() { - Ok(message_content) => match serde_json::from_str::(&message_content) { - Ok(job_message) => { - eprintln!("message_content: {}", message_content); - if job_message.content != job_message_content { - assert!(true); - break; - } - } - Err(_) => { - eprintln!("error: message_content: {}", message_content); - } - }, - Err(_) => { - // nothing - } - } - tokio::time::sleep(Duration::from_secs(10)).await; - } - } - - let new_job_message_content = "Can you output markdown for an FAQ where my previous question is the heading and your response is the text underneath?".to_string(); - { - // Send a Message to the Job for processing - eprintln!("\n\nSend a message for the Job"); - let start = Instant::now(); - api_message_job( - node1_commands_sender.clone(), - clone_static_secret_key(&node1_profile_encryption_sk), - node1_encryption_pk, - clone_signature_secret_key(&node1_profile_identity_sk), - node1_identity_name.clone().as_str(), - node1_profile_name.clone().as_str(), - &agent_subidentity.clone(), - &job_id.clone().to_string(), - &new_job_message_content, - "", - "", - ) - .await; - - let duration = start.elapsed(); // Get the time elapsed since the start of the timer - eprintln!("Time elapsed in api_message_job is: {:?}", duration); - } - - { - eprintln!("Waiting for the Job to finish"); - for _ in 0..50 { - let (res1_sender, res1_receiver) = async_channel::bounded(1); - node1_commands_sender - .send(NodeCommand::FetchLastMessages { - limit: 2, - res: res1_sender, - }) - .await - .unwrap(); - let node1_last_messages = res1_receiver.recv().await.unwrap(); - eprintln!("node1_last_messages: {:?}", node1_last_messages); - - match node1_last_messages[0].get_message_content() { - Ok(message_content) => match serde_json::from_str::(&message_content) { - Ok(job_message) => { - eprintln!("message_content: {}", message_content); - if job_message.content != new_job_message_content { - assert!(true); - node1_abort_handler.abort(); - return; - } - } - Err(_) => { - eprintln!("error: message_content: {}", message_content); - } - }, - Err(_) => { - // nothing - } - } - tokio::time::sleep(Duration::from_secs(10)).await; - } - } - }) - }); -} diff --git a/shinkai-bin/shinkai-node/tests/it/job_branchs_retries_tests.rs b/shinkai-bin/shinkai-node/tests/it/job_branchs_retries_tests.rs index 2a56f9f67..8fa532946 100644 --- a/shinkai-bin/shinkai-node/tests/it/job_branchs_retries_tests.rs +++ b/shinkai-bin/shinkai-node/tests/it/job_branchs_retries_tests.rs @@ -195,7 +195,7 @@ fn job_branchs_retries_tests() { &agent_subidentity.clone(), &job_id.clone().to_string(), "hello are u there? (1)", - "", + &[], "", ) .await; @@ -224,7 +224,7 @@ fn job_branchs_retries_tests() { &agent_subidentity.clone(), &job_id.clone().to_string(), "hello are u there? (3)", - "", + &[], "", ) .await; @@ -287,7 +287,7 @@ fn job_branchs_retries_tests() { &agent_subidentity.clone(), &job_id.clone().to_string(), "hello are u there? (5)", - "", + &[], message2_hash.unwrap().as_str(), ) .await; diff --git a/shinkai-bin/shinkai-node/tests/it/job_image_analysis_tests.rs b/shinkai-bin/shinkai-node/tests/it/job_image_analysis_tests.rs index 4fe860ca8..c35e431b5 100644 --- a/shinkai-bin/shinkai-node/tests/it/job_image_analysis_tests.rs +++ b/shinkai-bin/shinkai-node/tests/it/job_image_analysis_tests.rs @@ -1,7 +1,6 @@ +use crate::it::utils::vecfs_test_utils::{get_files_for_job, get_folder_name_for_job, upload_file_to_job}; + use super::utils::test_boilerplate::run_test_one_node_network; -use aes_gcm::aead::{generic_array::GenericArray, Aead}; -use aes_gcm::Aes256Gcm; -use aes_gcm::KeyInit; use shinkai_http_api::node_commands::NodeCommand; use shinkai_message_primitives::schemas::llm_providers::serialized_llm_provider::{ LLMProviderInterface, Ollama, SerializedLLMProvider, @@ -9,12 +8,9 @@ use shinkai_message_primitives::schemas::llm_providers::serialized_llm_provider: use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; use shinkai_message_primitives::shinkai_message::shinkai_message_schemas::JobMessage; use shinkai_message_primitives::shinkai_utils::encryption::clone_static_secret_key; -use shinkai_message_primitives::shinkai_utils::file_encryption::{ - aes_encryption_key_to_string, aes_nonce_to_hex_string, hash_of_aes_encryption_key_hex, - unsafe_deterministic_aes_encryption_key, -}; -use shinkai_message_primitives::shinkai_utils::shinkai_message_builder::ShinkaiMessageBuilder; +use shinkai_message_primitives::shinkai_utils::shinkai_path::ShinkaiPath; use shinkai_message_primitives::shinkai_utils::signatures::clone_signature_secret_key; +use std::path::Path; use std::time::Duration; use std::time::Instant; @@ -31,6 +27,7 @@ fn job_image_analysis() { run_test_one_node_network(|env| { Box::pin(async move { let node1_commands_sender = env.node1_commands_sender.clone(); + let node1_api_key_bearer = env.node1_api_key; let node1_identity_name = env.node1_identity_name.clone(); let node1_profile_name = env.node1_profile_name.clone(); let node1_device_name = env.node1_device_name.clone(); @@ -41,9 +38,6 @@ fn job_image_analysis() { let node1_device_identity_sk = clone_signature_secret_key(&env.node1_device_identity_sk); let node1_profile_identity_sk = clone_signature_secret_key(&env.node1_profile_identity_sk); - // For this test - let symmetrical_sk = unsafe_deterministic_aes_encryption_key(0); - { // Register a Profile in Node1 and verifies it eprintln!("\n\nRegister a Device with main Profile in Node1 and verify it"); @@ -103,15 +97,8 @@ fn job_image_analysis() { let agent = SerializedLLMProvider { id: node1_agent.clone().to_string(), full_identity_name: agent_name, - // external_url: Some("http://localhost:11435".to_string()), - // external_url: Some("https://api.openai.com".to_string()), - // api_key: Some("".to_string()), - // api_key: Some(api_key), external_url: Some(server.url()), api_key: Some("mockapikey".to_string()), - // external_url: Some("https://api.together.xyz".to_string()), - // model: LLMProviderInterface::OpenAI(open_ai), - // model: LLMProviderInterface::GenericAPI(generic_api), model: LLMProviderInterface::Ollama(ollama), }; api_llm_provider_registration( @@ -142,62 +129,48 @@ fn job_image_analysis() { ) .await; } + let job_message_content = "describe the image".to_string(); { - eprintln!("\n\n### Sending message (APICreateFilesInboxWithSymmetricKey) from profile subidentity to node 1\n\n"); + eprintln!("\n\n### Sending message (APIAddFileToInboxWithSymmetricKey) from profile subidentity to node 1\n\n"); + let file_path = Path::new("../../files/blue_64x64.png"); + upload_file_to_job(&node1_commands_sender, &job_id, file_path, &node1_api_key_bearer).await; - let message_content = aes_encryption_key_to_string(symmetrical_sk.clone()); - let msg = ShinkaiMessageBuilder::create_files_inbox_with_sym_key( - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - "job::test::false".to_string(), - message_content.clone(), - node1_profile_name.to_string(), - node1_identity_name.to_string(), - node1_identity_name.to_string(), - ) - .unwrap(); + // Retrieve the folder name for the job + let folder_name = get_folder_name_for_job(&node1_commands_sender, &job_id, &node1_api_key_bearer) + .await + .unwrap(); + eprintln!("Folder name for job: {}", folder_name); - let (res_sender, res_receiver) = async_channel::bounded(1); - node1_commands_sender - .send(NodeCommand::APICreateFilesInboxWithSymmetricKey { msg, res: res_sender }) + // Retrieve the files for the job + let files = get_files_for_job(&node1_commands_sender, &job_id, &node1_api_key_bearer) .await .unwrap(); - let _response = res_receiver.recv().await.unwrap().expect("Failed to receive messages"); - } - { - eprintln!("\n\n### Sending message (APIAddFileToInboxWithSymmetricKey) from profile subidentity to node 1\n\n"); - let file_path = "../../files/blue_64x64.png"; - let file_data = std::fs::read(file_path).expect("Failed to read file"); + eprintln!("Files for job: {:?}", files); + + // Extract the path from the files + let file_paths: Vec = if let Some(files_array) = files.as_array() { + files_array + .iter() + .filter_map(|file| file.get("path").and_then(|name| name.as_str()).map(|s| s.to_string())) + .collect() + } else { + panic!("Files is not an array"); + }; - // Encrypt the file using Aes256Gcm - let cipher = Aes256Gcm::new(GenericArray::from_slice(&symmetrical_sk)); - let nonce = GenericArray::from_slice(&[0u8; 12]); - let nonce_slice = nonce.as_slice(); - let nonce_str = aes_nonce_to_hex_string(nonce_slice); - let ciphertext = cipher.encrypt(nonce, file_data.as_ref()).expect("encryption failure!"); + // Convert Vec to Vec<&str> + let file_paths_str: Vec<&str> = file_paths.iter().map(|s| s.as_str()).collect(); - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); + // Check that the files contain the expected file + let expected_file_name = "blue_64x64.png"; + eprintln!("file_paths: {:?}", file_paths); + assert!( + file_paths.iter().any(|file_name| file_name.ends_with(expected_file_name)), + "Expected file not found in job files" + ); - // Send the command - node1_commands_sender - .send(NodeCommand::APIAddFileToInboxWithSymmetricKey { - filename: "samurai_underwater.png".to_string(), - file: ciphertext, - public_key: hash_of_aes_encryption_key_hex(symmetrical_sk), - encrypted_nonce: nonce_str, - res: res_sender, - }) - .await - .unwrap(); + let shinkai_path = ShinkaiPath::base_path(); + eprintln!("Shinkai Path: {}", shinkai_path.to_string_lossy()); - // Receive the response - let response = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - eprintln!("response: {:?}", response); - } - let job_message_content = "describe the image".to_string(); - { // Send a Message to the Job for processing eprintln!("\n\nSend a message for the Job"); let start = Instant::now(); @@ -211,7 +184,7 @@ fn job_image_analysis() { &agent_subidentity.clone(), &job_id.clone().to_string(), &job_message_content, - &hash_of_aes_encryption_key_hex(symmetrical_sk), + &file_paths_str, "", ) .await; @@ -236,7 +209,7 @@ fn job_image_analysis() { match node1_last_messages[0].get_message_content() { Ok(message_content) => match serde_json::from_str::(&message_content) { Ok(job_message) => { - // eprintln!("message_content: {}", message_content); + eprintln!("message_content: {}", message_content); if job_message.content != job_message_content { assert!(true); break; diff --git a/shinkai-bin/shinkai-node/tests/it/job_manager_concurrency_tests.rs b/shinkai-bin/shinkai-node/tests/it/job_manager_concurrency_tests.rs index a2f1bbe9b..a2485205b 100644 --- a/shinkai-bin/shinkai-node/tests/it/job_manager_concurrency_tests.rs +++ b/shinkai-bin/shinkai-node/tests/it/job_manager_concurrency_tests.rs @@ -1,4 +1,5 @@ use ed25519_dalek::SigningKey; +use shinkai_embedding::embedding_generator::RemoteEmbeddingGenerator; use shinkai_job_queue_manager::job_queue_manager::{JobForProcessing, JobQueueManager}; use shinkai_message_primitives::schemas::inbox_name::InboxName; use shinkai_message_primitives::shinkai_utils::encryption::{ @@ -19,14 +20,12 @@ use shinkai_node::llm_provider::job_manager::JobManager; use shinkai_node::llm_provider::llm_stopper::LLMStopper; use shinkai_node::managers::sheet_manager::SheetManager; use shinkai_sqlite::SqliteManager; -use shinkai_vector_fs::vector_fs::vector_fs::VectorFS; -use shinkai_vector_resources::embedding_generator::RemoteEmbeddingGenerator; -use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; + use std::result::Result::Ok; use std::sync::Arc; use std::sync::Weak; use std::time::Duration; -use tokio::sync::{Mutex, RwLock}; +use tokio::sync::Mutex; use x25519_dalek::{PublicKey as EncryptionPublicKey, StaticSecret as EncryptionStaticKey}; use super::utils; @@ -81,31 +80,17 @@ fn node_name() -> ShinkaiName { ShinkaiName::new("@@localhost.shinkai".to_string()).unwrap() } -async fn setup_default_vector_fs(db: Arc) -> VectorFS { - let generator = RemoteEmbeddingGenerator::new_default(); - let profile_list = vec![default_test_profile()]; - let supported_embedding_models = vec![EmbeddingModelType::OllamaTextEmbeddingsInference( - OllamaTextEmbeddingsInference::SnowflakeArcticEmbed_M, - )]; - - VectorFS::new(generator, supported_embedding_models, profile_list, db, node_name()) - .await - .unwrap() -} - #[tokio::test] async fn test_process_job_queue_concurrency() { let num_threads = 8; let db = utils::db_handlers::setup_test_db(); let db = Arc::new(db); - let vector_fs = Arc::new(setup_default_vector_fs(db.clone()).await); let (node_identity_sk, _) = unsafe_deterministic_signature_keypair(0); let node_name = ShinkaiName::new("@@node1.shinkai".to_string()).unwrap(); // Mock job processing function let mock_processing_fn = |job: JobForProcessing, db: Weak, - _vector_fs: Weak, _node_name: ShinkaiName, _: SigningKey, _: RemoteEmbeddingGenerator, @@ -143,7 +128,6 @@ async fn test_process_job_queue_concurrency() { }; let db_weak = Arc::downgrade(&db); - let vector_fs_weak = Arc::downgrade(&vector_fs); let mut job_queue = JobQueueManager::::new(db_weak.clone(), None) .await .unwrap(); @@ -158,7 +142,6 @@ async fn test_process_job_queue_concurrency() { let job_queue_handler = JobManager::process_job_queue( job_queue_manager.clone(), db_weak.clone(), - vector_fs_weak.clone(), node_name.clone(), num_threads, clone_signature_secret_key(&node_identity_sk), @@ -173,7 +156,6 @@ async fn test_process_job_queue_concurrency() { llm_stopper.clone(), move |job, _db, - _vector_fs, node_name, identity_sk, generator, @@ -189,7 +171,6 @@ async fn test_process_job_queue_concurrency() { mock_processing_fn( job, db_weak.clone(), - vector_fs_weak.clone(), node_name.clone(), identity_sk, generator, @@ -207,12 +188,13 @@ async fn test_process_job_queue_concurrency() { JobMessage { job_id: format!("job_id::{}::false", i).to_string(), content: format!("my content {}", i).to_string(), - files_inbox: "".to_string(), parent: None, sheet_job_data: None, callback: None, metadata: None, tool_key: None, + fs_files_paths: vec![], + job_filenames: vec![], }, ShinkaiName::new("@@node1.shinkai/main".to_string()).unwrap(), None, @@ -251,14 +233,12 @@ async fn test_sequential_process_for_same_job_id() { let num_threads = 8; let db = utils::db_handlers::setup_test_db(); let db = Arc::new(db); - let vector_fs = Arc::new(setup_default_vector_fs(db.clone()).await); let (node_identity_sk, _) = unsafe_deterministic_signature_keypair(0); let node_name = ShinkaiName::new("@@node1.shinkai".to_string()).unwrap(); // Mock job processing function let mock_processing_fn = |job: JobForProcessing, db: Weak, - _vector_fs: Weak, _node_name: ShinkaiName, _: SigningKey, _: RemoteEmbeddingGenerator, @@ -296,7 +276,6 @@ async fn test_sequential_process_for_same_job_id() { }; let db_weak = Arc::downgrade(&db); - let vector_fs_weak = Arc::downgrade(&vector_fs); let mut job_queue = JobQueueManager::::new(db_weak.clone(), None) .await .unwrap(); @@ -311,7 +290,6 @@ async fn test_sequential_process_for_same_job_id() { let job_queue_handler = JobManager::process_job_queue( job_queue_manager.clone(), db_weak.clone(), - vector_fs_weak.clone(), node_name.clone(), num_threads, clone_signature_secret_key(&node_identity_sk), @@ -325,7 +303,6 @@ async fn test_sequential_process_for_same_job_id() { llm_stopper.clone(), move |job, _db, - _vector_fs, node_name, identity_sk, generator, @@ -340,7 +317,6 @@ async fn test_sequential_process_for_same_job_id() { mock_processing_fn( job, db_weak.clone(), - vector_fs_weak.clone(), node_name.clone(), identity_sk, generator, @@ -357,12 +333,13 @@ async fn test_sequential_process_for_same_job_id() { JobMessage { job_id: "job_id::123::false".to_string(), content: format!("my content {}", i).to_string(), - files_inbox: "".to_string(), parent: None, sheet_job_data: None, callback: None, metadata: None, tool_key: None, + fs_files_paths: vec![], + job_filenames: vec![], }, ShinkaiName::new("@@node1.shinkai/main".to_string()).unwrap(), None, diff --git a/shinkai-bin/shinkai-node/tests/it/model_capabilities_manager_tests.rs b/shinkai-bin/shinkai-node/tests/it/model_capabilities_manager_tests.rs index 00c90915f..99f7935a9 100644 --- a/shinkai-bin/shinkai-node/tests/it/model_capabilities_manager_tests.rs +++ b/shinkai-bin/shinkai-node/tests/it/model_capabilities_manager_tests.rs @@ -14,7 +14,7 @@ mod tests { use tokio::sync::RwLock; use shinkai_sqlite::SqliteManager; - use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; + use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use tempfile::NamedTempFile; fn setup_test_db() -> SqliteManager { diff --git a/shinkai-bin/shinkai-node/tests/it/native_tool_tests.rs b/shinkai-bin/shinkai-node/tests/it/native_tool_tests.rs index 5009f04c6..938462fdc 100644 --- a/shinkai-bin/shinkai-node/tests/it/native_tool_tests.rs +++ b/shinkai-bin/shinkai-node/tests/it/native_tool_tests.rs @@ -1,35 +1,33 @@ use async_channel::{bounded, Receiver, Sender}; -use serde_json::{json, Map, Value}; +use serde_json::{json, Map}; use shinkai_http_api::node_commands::NodeCommand; -use shinkai_message_primitives::schemas::inbox_name::InboxName; use shinkai_message_primitives::schemas::llm_providers::serialized_llm_provider::{ LLMProviderInterface, OpenAI, SerializedLLMProvider, }; use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; -use shinkai_message_primitives::shinkai_message::shinkai_message_schemas::JobMessage; use shinkai_message_primitives::shinkai_utils::encryption::{ clone_static_secret_key, unsafe_deterministic_encryption_keypair, }; -use shinkai_message_primitives::shinkai_utils::job_scope::{JobScope, VectorFSFolderScopeEntry}; +use shinkai_message_primitives::shinkai_utils::job_scope::MinimalJobScope; +use shinkai_message_primitives::shinkai_utils::search_mode::VectorSearchMode; use shinkai_message_primitives::shinkai_utils::shinkai_logging::{shinkai_log, ShinkaiLogLevel, ShinkaiLogOption}; -use shinkai_message_primitives::shinkai_utils::shinkai_message_builder::ShinkaiMessageBuilder; +use shinkai_message_primitives::shinkai_utils::shinkai_path::ShinkaiPath; use shinkai_message_primitives::shinkai_utils::signatures::{ clone_signature_secret_key, unsafe_deterministic_signature_keypair, }; +use shinkai_message_primitives::shinkai_utils::utils::hash_string; use shinkai_node::network::Node; -use shinkai_vector_resources::utils::hash_string; -use shinkai_vector_resources::vector_resource::{VRPath, VectorSearchMode}; use std::fs; +use std::net::SocketAddr; use std::net::{IpAddr, Ipv4Addr}; use std::path::Path; -use std::{net::SocketAddr, time::Duration}; use tokio::runtime::Runtime; use crate::it::utils::node_test_api::{api_create_job_with_scope, api_execute_tool}; use crate::it::utils::vecfs_test_utils::{create_folder, upload_file}; use super::utils::db_handlers::setup_node_storage_path; -use super::utils::node_test_api::{api_message_job, api_registration_device_node_profile_main}; +use super::utils::node_test_api::api_registration_device_node_profile_main; use super::utils::test_boilerplate::{default_embedding_model, supported_embedding_models}; use mockito::Server; @@ -70,7 +68,6 @@ fn native_tool_test_knowledge() { let (node1_device_encryption_sk, _node1_device_encryption_pk) = unsafe_deterministic_encryption_keypair(200); let node1_db_path = format!("db_tests/{}", hash_string(node1_identity_name)); - let node1_fs_db_path = format!("db_tests/vector_fs{}", hash_string(node1_identity_name)); let node1_profile_name = "main"; let api_key_bearer = "my_api_key".to_string(); @@ -140,7 +137,6 @@ fn native_tool_test_knowledge() { None, true, vec![agent], - node1_fs_db_path, None, None, default_embedding_model(), @@ -202,14 +198,9 @@ fn native_tool_test_knowledge() { let file_path = Path::new("../../files/shinkai_intro.vrkai"); upload_file( &node1_commands_sender, - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - node1_identity_name, - node1_profile_name, "/test_folder", file_path, - 0, + &api_key_bearer.clone(), ) .await; } @@ -224,18 +215,12 @@ fn native_tool_test_knowledge() { ShinkaiLogLevel::Debug, &format!("Creating a Job for Agent {}", agent_subidentity.clone()), ); - let vr_path = VRPath::root(); - let vector_fs_folder = VectorFSFolderScopeEntry { - name: "test_folder".to_string(), - path: vr_path, - }; + let vector_fs_folder = ShinkaiPath::from_string("test_folder".to_string()); - let job_scope = JobScope { - local_vrkai: vec![], - local_vrpack: vec![], + let job_scope = MinimalJobScope { vector_fs_items: vec![], vector_fs_folders: vec![vector_fs_folder], - vector_search_mode: vec![VectorSearchMode::FillUpTo25k], + vector_search_mode: VectorSearchMode::FillUpTo25k, }; job_id = api_create_job_with_scope( diff --git a/shinkai-bin/shinkai-node/tests/it/node_integration_tests.rs b/shinkai-bin/shinkai-node/tests/it/node_integration_tests.rs index 655b70068..e4fe36ea3 100644 --- a/shinkai-bin/shinkai-node/tests/it/node_integration_tests.rs +++ b/shinkai-bin/shinkai-node/tests/it/node_integration_tests.rs @@ -1,4 +1,5 @@ use async_channel::{bounded, Receiver, Sender}; +use shinkai_message_primitives::shinkai_utils::utils::hash_string; use core::panic; use shinkai_http_api::node_api_router::{APIError, SendResponseBodyData}; use shinkai_http_api::node_commands::NodeCommand; @@ -14,7 +15,6 @@ use shinkai_message_primitives::shinkai_utils::signatures::{ unsafe_deterministic_signature_keypair, }; use shinkai_node::network::Node; -use shinkai_vector_resources::utils::hash_string; use std::fs; use std::net::{IpAddr, Ipv4Addr}; use std::path::Path; @@ -80,9 +80,7 @@ fn subidentity_registration() { bounded(100); let node1_db_path = format!("db_tests/{}", hash_string(node1_identity_name)); - let node1_fs_db_path = format!("db_tests/vector_fs{}", hash_string(node1_identity_name)); let node2_db_path = format!("db_tests/{}", hash_string(node2_identity_name)); - let node2_fs_db_path = format!("db_tests/vector_fs{}", hash_string(node2_identity_name)); // Create node1 and node2 let addr1 = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080); @@ -100,7 +98,7 @@ fn subidentity_registration() { None, true, vec![], - node1_fs_db_path, + None, None, default_embedding_model(), @@ -124,7 +122,7 @@ fn subidentity_registration() { None, true, vec![], - node2_fs_db_path, + None, None, default_embedding_model(), diff --git a/shinkai-bin/shinkai-node/tests/it/node_retrying_tests.rs b/shinkai-bin/shinkai-node/tests/it/node_retrying_tests.rs index 51bfe1847..7b1a139eb 100644 --- a/shinkai-bin/shinkai-node/tests/it/node_retrying_tests.rs +++ b/shinkai-bin/shinkai-node/tests/it/node_retrying_tests.rs @@ -9,8 +9,8 @@ use shinkai_message_primitives::shinkai_utils::shinkai_message_builder::ShinkaiM use shinkai_message_primitives::shinkai_utils::signatures::{ clone_signature_secret_key, unsafe_deterministic_signature_keypair, }; +use shinkai_message_primitives::shinkai_utils::utils::hash_string; use shinkai_node::network::Node; -use shinkai_vector_resources::utils::hash_string; use std::net::{IpAddr, Ipv4Addr}; use std::sync::Arc; use std::{net::SocketAddr, time::Duration}; @@ -77,9 +77,7 @@ fn node_retrying_test() { bounded(100); let node1_db_path = format!("db_tests/{}", hash_string(node1_identity_name)); - let node1_fs_db_path = format!("db_tests/vector_fs{}", hash_string(node1_identity_name)); let node2_db_path = format!("db_tests/{}", hash_string(node2_identity_name)); - let node2_fs_db_path = format!("db_tests/vector_fs{}", hash_string(node2_identity_name)); // Create node1 and node2 let addr1 = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080); @@ -97,7 +95,7 @@ fn node_retrying_test() { None, true, vec![], - node1_fs_db_path, + None, None, default_embedding_model(), @@ -121,7 +119,7 @@ fn node_retrying_test() { None, true, vec![], - node2_fs_db_path, + None, None, default_embedding_model(), diff --git a/shinkai-bin/shinkai-node/tests/it/subscription_http_upload_tests.rs b/shinkai-bin/shinkai-node/tests/it/subscription_http_upload_tests.rs deleted file mode 100644 index 890d438fe..000000000 --- a/shinkai-bin/shinkai-node/tests/it/subscription_http_upload_tests.rs +++ /dev/null @@ -1,415 +0,0 @@ -use async_channel::{bounded, Receiver, Sender}; -use shinkai_http_api::node_api_router::APIError; -use shinkai_message_primitives::schemas::file_links::{FileLink, FileStatus}; -use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; -use shinkai_message_primitives::schemas::shinkai_subscription::{ - ShinkaiSubscription, ShinkaiSubscriptionStatus, SubscriptionId, -}; -use shinkai_message_primitives::shinkai_message::shinkai_message_schemas::{ - FileDestinationCredentials, FileDestinationSourceType, -}; -use shinkai_message_primitives::shinkai_utils::signatures::clone_signature_secret_key; -use shinkai_node::network::Node; -use shinkai_subscription_manager::subscription_manager::http_manager::http_download_manager::{ - HttpDownloadJob, HttpDownloadManager, -}; -use shinkai_subscription_manager::subscription_manager::http_manager::http_upload_manager::HttpSubscriptionUploadManager; -use shinkai_subscription_manager::subscription_manager::http_manager::subscription_file_uploader::{ - delete_all_in_folder, FileDestination, -}; -use std::collections::HashMap; -use std::sync::Arc; -use tokio::sync::{RwLock, Semaphore}; -use utils::test_boilerplate::run_test_one_node_network; - -use super::utils; -use super::utils::node_test_api::api_initial_registration_with_no_code_for_device; -use super::utils::shinkai_testing_framework::ShinkaiTestingFramework; - -#[test] -fn subscription_http_upload() { - std::env::set_var("SUBSCRIPTION_HTTP_UPLOAD_INTERVAL_MINUTES", "1000"); - - run_test_one_node_network(|env| { - Box::pin(async move { - let node1_commands_sender = env.node1_commands_sender.clone(); - let node1_device_name = env.node1_device_name.clone(); - let node1_encryption_pk = env.node1_encryption_pk; - let node1_device_encryption_sk = env.node1_device_encryption_sk.clone(); - let node1_profile_encryption_sk = env.node1_profile_encryption_sk.clone(); - let node1_device_identity_sk = clone_signature_secret_key(&env.node1_device_identity_sk); - let node1_profile_identity_sk = clone_signature_secret_key(&env.node1_profile_identity_sk); - // let node1_db = env.node1_db.clone(); - // let node1_vecfs = env.node1_vecfs.clone(); - let node1_ext_subscription_manager = env.node1_ext_subscription_manager.clone(); - // let node1_my_subscription_manager = env.node1_my_subscriptions_manager.clone(); - let node1_name = env.node1_identity_name.clone(); - let node1_abort_handler = env.node1_abort_handler; - - // Downgrade node1_db and node1_vecfs from Arc to Weak - let node1_db_weak = Arc::downgrade(&env.node1_db); - let node1_vecfs_weak = Arc::downgrade(&env.node1_vecfs); - - // Read AWS credentials from environment variables - let access_key_id = std::env::var("AWS_ACCESS_KEY_ID").expect("AWS_ACCESS_KEY_ID not set"); - let secret_access_key = std::env::var("AWS_SECRET_ACCESS_KEY").expect("AWS_SECRET_ACCESS_KEY not set"); - let aws_url = std::env::var("AWS_URL").expect("AWS_URL not set"); - - // file_dest_credentials - let file_dest_credentials = FileDestinationCredentials { - source: FileDestinationSourceType::R2, - access_key_id, - secret_access_key, - endpoint_uri: aws_url, - bucket: "shinkai-streamer".to_string(), - }; - - // Shinkai Testing Framework - let testing_framework = ShinkaiTestingFramework::new( - node1_commands_sender.clone(), - env.node1_profile_identity_sk.clone(), - env.node1_profile_encryption_sk.clone(), - env.node1_encryption_pk, - env.node1_identity_name.clone(), - env.node1_profile_name.clone(), - ); - - { - // Register a Profile in Node1 and verifies it - eprintln!("\n\nRegister a Device with main Profile in Node1 and verify it"); - api_initial_registration_with_no_code_for_device( - node1_commands_sender.clone(), - env.node1_profile_name.as_str(), - env.node1_identity_name.as_str(), - node1_encryption_pk, - node1_device_encryption_sk.clone(), - clone_signature_secret_key(&node1_device_identity_sk), - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_device_name.as_str(), - ) - .await; - } - { - // Initialize local PDF parser - ShinkaiTestingFramework::initialize_pdfium().await; - - // Create folder /shared_test_folder - testing_framework.create_folder("/", "shinkai_sharing").await; - testing_framework - .upload_file("/shinkai_sharing", "../../files/shinkai_intro.pdf") - .await; - testing_framework - .upload_file("/shinkai_sharing", "../../files/zeko_mini.pdf") - .await; - - testing_framework - .make_folder_shareable_free_whttp("/shinkai_sharing", file_dest_credentials) - .await; - testing_framework.show_available_shared_items().await; - } - { - let external_subscriber_manager = node1_ext_subscription_manager.lock().await; - let subscription_uploader = &external_subscriber_manager.http_subscription_upload_manager.clone(); - let shared_folders_trees_ref = &external_subscriber_manager.shared_folders_trees.clone(); - drop(external_subscriber_manager); - - { - // Setting up initial conditions - // Retrieve upload credentials from the database - let db_strong = node1_db_weak.upgrade().unwrap(); - let path = "/shinkai_sharing"; - let profile = "main"; - let credentials = db_strong.read().await.get_upload_credentials(path, profile).unwrap(); - - let destination = FileDestination::from_credentials(credentials).await.unwrap(); - - // clean up the testing folder - let _ = delete_all_in_folder(&destination.clone(), "/shinkai_sharing").await; - - // Adds: - // two random files (should get deleted) - // a file that has the wrong hash (it should be re-uploaded) - let dummy_data1 = vec![1, 2, 3, 4, 5]; - let dummy_data2 = vec![6, 7, 8, 9, 10]; - let dummy_file_name1 = "dummy_file1"; - let dummy_file_name2 = "dummy_file2"; - let outdated_shinkai_file = "shinkai_intro"; - - // Upload dummy files to the folder /shinkai_sharing - testing_framework - .update_file_to_http( - destination.clone(), - dummy_data1.clone(), - "/shinkai_sharing", - dummy_file_name1, - ) - .await; - testing_framework - .update_file_to_http( - destination.clone(), - dummy_data2.clone(), - "/shinkai_sharing", - dummy_file_name2, - ) - .await; - testing_framework - .update_file_to_http( - destination.clone(), - dummy_data2.clone(), - "/shinkai_sharing", - outdated_shinkai_file, - ) - .await; - - let checksum_file_name1 = "dummy_file1.4aaabb39.checksum"; - let checksum_file_name2 = "dummy_file2.2bbbbb39.checksum"; - let checksum_outdated_shinkai = "shinkai_intro.aaaaaaaa.checksum"; - - testing_framework - .update_file_to_http( - destination.clone(), - dummy_data1.clone(), - "/shinkai_sharing", - checksum_file_name1, - ) - .await; - testing_framework - .update_file_to_http( - destination.clone(), - dummy_data1, - "/shinkai_sharing", - checksum_outdated_shinkai, - ) - .await; - testing_framework - .update_file_to_http(destination, dummy_data2, "/shinkai_sharing", checksum_file_name2) - .await; - } - - let subscriptions_whttp_support = - HttpSubscriptionUploadManager::fetch_subscriptions_with_http_support(&node1_db_weak.clone()).await; - - assert_eq!( - subscriptions_whttp_support.len(), - 1, - "Expected one subscription with HTTP support" - ); - let subscription = &subscriptions_whttp_support[0]; - assert_eq!(subscription.path, "/shinkai_sharing", "Path does not match"); - assert!(subscription.folder_subscription.is_free, "Subscription should be free"); - assert_eq!( - subscription.folder_subscription.has_web_alternative, - Some(true), - "Should have a web alternative" - ); - - let _ = HttpSubscriptionUploadManager::subscription_http_check_loop( - node1_db_weak.clone(), - node1_vecfs_weak.clone(), - ShinkaiName::new(node1_name.clone()).unwrap(), - subscription_uploader.subscription_file_map.clone(), - subscription_uploader.subscription_status.clone(), - shared_folders_trees_ref.clone(), - subscription_uploader.file_links.clone(), - 1, - ) - .await; - - // Check that subscription_file_map (cache) was updated correctly - let expected_files = [ - ( - "/shinkai_sharing/shinkai_intro", - "61a64137b4bb0ee5224a5507274ecf6dc87433e4e619001672d8890110dd7720", - ), - ( - "/shinkai_sharing/zeko_mini.0c1fe48b.checksum", - "54dbc143e2b41854522f0a71a8502e452351ee312dda36802a093f610c1fe48b", - ), - ( - "/shinkai_sharing/shinkai_intro.10dd7720.checksum", - "61a64137b4bb0ee5224a5507274ecf6dc87433e4e619001672d8890110dd7720", - ), - ( - "/shinkai_sharing/zeko_mini", - "54dbc143e2b41854522f0a71a8502e452351ee312dda36802a093f610c1fe48b", - ), - ]; - - // Print out the content of subscription_file_map and assert the values - { - for entry in subscription_uploader.subscription_file_map.iter() { - let _key = entry.key(); - let value = entry.value(); - // println!("\n\n(In Test) After everything - Folder Subscription: {:?}", key); - for (file_path, status) in value.iter() { - // println!(" {} - {:?}", file_path, status); - // Find the expected hash for the current file path - if let Some((_, expected_hash)) = expected_files.iter().find(|(path, _)| path == file_path) - { - match status { - FileStatus::Sync(actual_hash) => { - assert_eq!(actual_hash, expected_hash, "Hash mismatch for file: {}", file_path); - } - _ => panic!("Expected Sync status for file: {}", file_path), - } - } else { - panic!("File path {} not found in expected files", file_path); - } - } - } - } - // // Print out the content of file_links - // { - // let file_links = subscription_uploader.file_links; - // eprintln!("file_links address: {:p}", &file_links); - // println!("\n\n File Links Debug:"); - // for entry in file_links.iter() { - // let folder_subscription = entry.key(); - // eprintln!("Folder Subscription: {:?}", folder_subscription); - // let links_map = entry.value(); - // println!("links map: {:?}", folder_subscription); - // for (file_path, link) in links_map.iter() { - // println!(" {} - {} - {}", file_path, link.last_8_hash, link.link); - // } - // } - // } - - { - // Add the subscription to my_subscriptions - let new_subscription = SubscriptionId { - unique_id: "@@node1_test.arb-sep-shinkai:::main:::shinkai_sharing:::@@node1_test.arb-sep-shinkai:::main" - .to_string(), - include_folders: None, - exclude_folders: None, - }; - - let subscription = ShinkaiSubscription { - subscription_id: new_subscription, - shared_folder: "/shinkai_sharing".to_string(), - streaming_node: ShinkaiName::new("@@node1_test.arb-sep-shinkai".to_string()).unwrap(), - streaming_profile: "main".to_string(), - subscription_description: None, - subscriber_destination_path: None, - subscriber_node: ShinkaiName::new("@@node1_test.arb-sep-shinkai".to_string()).unwrap(), - subscriber_profile: "main".to_string(), - payment: None, - state: ShinkaiSubscriptionStatus::UnsubscribeConfirmed, - date_created: chrono::Utc::now(), - last_modified: chrono::Utc::now(), - last_sync: None, - http_preferred: None, - }; - { - let db_strong = node1_db_weak.upgrade().unwrap(); - let _ = db_strong.write().await.add_my_subscription(subscription.clone()); - } - // Instantiate HttpDownloadManager and call process_job_queue - let http_download_manager = HttpDownloadManager::new( - node1_db_weak.clone(), - node1_vecfs_weak.clone(), - ShinkaiName::new(node1_name.clone()).unwrap(), - ) - .await; - - { - // let's call the api to download the files - // Call the API to download the files and then add them to the job queue manager - let db_clone = node1_db_weak.upgrade().unwrap(); - let node_name_clone = ShinkaiName::new(node1_name.clone()).unwrap(); - let ext_subscription_manager_clone = node1_ext_subscription_manager.clone(); - let subscription_profile_path = "main:::/shinkai_sharing".to_string(); - - // Create a channel for sending results - #[allow(clippy::complexity)] - let (sender, receiver): ( - Sender>, - Receiver>, - ) = bounded(1); - - let _ = Node::api_get_http_free_subscription_links( - db_clone, - node_name_clone, - ext_subscription_manager_clone, - subscription_profile_path, - sender, - ) - .await; - - match receiver.recv().await { - Ok(result) => match result { - Ok(value) => { - eprintln!("Received response: {:?}", value); - // Deserialize JSON value to Vec - let file_links: Vec = - serde_json::from_value(value).unwrap_or_else(|_| vec![]); - for file_link in file_links { - let job = HttpDownloadJob { - subscription_id: subscription.subscription_id.clone(), // Assuming FileLink has a field subscription_id - info: file_link.clone(), - url: file_link.link.clone(), - date_created: chrono::Utc::now().to_string(), - }; - // Add job to the download queue - http_download_manager.add_job_to_download_queue(job).await.unwrap(); - } - } - Err(e) => eprintln!("Error processing request: {:?}", e), - }, - Err(e) => eprintln!("Failed to receive response: {:?}", e), - } - } - eprintln!("\n\nProcessing download queue"); - let semaphore = Arc::new(Semaphore::new(1)); - let mut continue_processing = false; - let mut handles = Vec::new(); - let active_jobs = Arc::new(RwLock::new(HashMap::new())); - - loop { - // Process the job queue using the associated function syntax - let new_handles = HttpDownloadManager::process_job_queue( - http_download_manager.job_queue_manager.clone(), - node1_vecfs_weak.clone(), - node1_db_weak.clone(), - 1, - semaphore.clone(), - active_jobs.clone(), - &mut continue_processing, - ) - .await; - - // If new_handles is empty, break the loop - if new_handles.is_empty() { - break; - } - - handles.extend(new_handles); - - // Wait for all current jobs to complete - let handles_to_join = std::mem::take(&mut handles); - futures::future::join_all(handles_to_join).await; - handles.clear(); - eprintln!("Download queue processed. New Loop"); - } - eprintln!("Download queue processed"); - let _res = testing_framework.retrieve_and_print_path_simplified("/", true).await; - - // After processing the download queue, retrieve file information for specific files - let file_info_shinkai_intro = testing_framework - .retrieve_file_info("/My Subscriptions/shinkai_sharing/shinkai_intro", true) - .await; - eprintln!( - "File info for /shinkai_sharing/shinkai_intro: {:?}", - file_info_shinkai_intro - ); - - let file_info_zeko_mini = testing_framework - .retrieve_file_info("/My Subscriptions/shinkai_sharing/zeko_mini", true) - .await; - eprintln!("File info for /shinkai_sharing/zeko_mini: {:?}", file_info_zeko_mini); - } - } - node1_abort_handler.abort(); - }) - }); -} diff --git a/shinkai-bin/shinkai-node/tests/it/utils/db_handlers.rs b/shinkai-bin/shinkai-node/tests/it/utils/db_handlers.rs index 7811808c2..30e831dfa 100644 --- a/shinkai-bin/shinkai-node/tests/it/utils/db_handlers.rs +++ b/shinkai-bin/shinkai-node/tests/it/utils/db_handlers.rs @@ -1,8 +1,9 @@ use std::fs; use std::path::{Path, PathBuf}; +use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; +use shinkai_message_primitives::shinkai_utils::shinkai_path::ShinkaiPath; use shinkai_sqlite::SqliteManager; -use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use tempfile::NamedTempFile; pub fn setup() { @@ -28,6 +29,17 @@ pub fn setup_test_db() -> SqliteManager { pub fn setup_node_storage_path() { let temp_file = NamedTempFile::new().unwrap(); + eprintln!("Temp file path: {:?}", temp_file.path()); + let path = PathBuf::from(temp_file.path()); - std::env::set_var("NODE_STORAGE_PATH", path.parent().unwrap()); + let parent_path = path.parent().unwrap(); + + std::env::set_var("NODE_STORAGE_PATH", parent_path); + + let base_path = ShinkaiPath::base_path(); + + eprintln!("Base path: {:?}", base_path.as_path()); + + // Ensure the directory is empty + let _ = fs::remove_dir_all(base_path.as_path()); } diff --git a/shinkai-bin/shinkai-node/tests/it/utils/node_test_api.rs b/shinkai-bin/shinkai-node/tests/it/utils/node_test_api.rs index 0e30b0091..eb653d188 100644 --- a/shinkai-bin/shinkai-node/tests/it/utils/node_test_api.rs +++ b/shinkai-bin/shinkai-node/tests/it/utils/node_test_api.rs @@ -1,4 +1,6 @@ use async_channel::Sender; +use shinkai_message_primitives::shinkai_utils::job_scope::MinimalJobScope; +use shinkai_message_primitives::shinkai_utils::shinkai_path::ShinkaiPath; use core::panic; use ed25519_dalek::SigningKey; use serde_json::{Map, Value}; @@ -12,7 +14,6 @@ use shinkai_message_primitives::shinkai_message::shinkai_message_schemas::{ IdentityPermissions, MessageSchemaType, RegistrationCodeType, }; use shinkai_message_primitives::shinkai_utils::encryption::{encryption_public_key_to_string, EncryptionMethod}; -use shinkai_message_primitives::shinkai_utils::job_scope::JobScope; use shinkai_message_primitives::shinkai_utils::shinkai_logging::{shinkai_log, ShinkaiLogLevel, ShinkaiLogOption}; use shinkai_message_primitives::shinkai_utils::shinkai_message_builder::ShinkaiMessageBuilder; use shinkai_message_primitives::shinkai_utils::signatures::clone_signature_secret_key; @@ -411,14 +412,15 @@ pub async fn api_message_job( recipient_subidentity: &str, job_id: &str, content: &str, - files_inbox: &str, + files: &[&str], parent: &str, ) { { + let files_vec = files.iter().map(|f| ShinkaiPath::new(f)).collect::>(); let job_message = ShinkaiMessageBuilder::job_message( job_id.to_string(), content.to_string(), - files_inbox.to_string(), + files_vec, parent.to_string(), subidentity_encryption_sk.clone(), clone_signature_secret_key(&subidentity_signature_sk), @@ -454,7 +456,7 @@ pub async fn api_create_job( sender_subidentity: &str, recipient_subidentity: &str, ) -> String { - let job_scope = JobScope::new_default(); + let job_scope = MinimalJobScope::default(); api_create_job_with_scope( node_commands_sender, subidentity_encryption_sk, @@ -476,7 +478,7 @@ pub async fn api_create_job_with_scope( sender: &str, sender_subidentity: &str, recipient_subidentity: &str, - job_scope: JobScope, + job_scope: MinimalJobScope, ) -> String { { let full_sender = format!("{}/{}", sender, sender_subidentity); diff --git a/shinkai-bin/shinkai-node/tests/it/utils/shinkai_testing_framework.rs b/shinkai-bin/shinkai-node/tests/it/utils/shinkai_testing_framework.rs index 3259709a1..4a1c8eda4 100644 --- a/shinkai-bin/shinkai-node/tests/it/utils/shinkai_testing_framework.rs +++ b/shinkai-bin/shinkai-node/tests/it/utils/shinkai_testing_framework.rs @@ -7,6 +7,7 @@ use super::vecfs_test_utils::{ use async_channel::Sender; use ed25519_dalek::SigningKey; use serde_json::Value; +use shinkai_fs::simple_parser::file_parser_helper::ShinkaiFileParser; use shinkai_http_api::{node_api_router::APIError, node_commands::NodeCommand}; use shinkai_message_primitives::{ shinkai_message::shinkai_message_schemas::{ @@ -14,7 +15,6 @@ use shinkai_message_primitives::{ }, shinkai_utils::{shinkai_message_builder::ShinkaiMessageBuilder, signatures::clone_signature_secret_key}, }; -use shinkai_vector_resources::file_parser::file_parser::ShinkaiFileParser; use x25519_dalek::{PublicKey as EncryptionPublicKey, StaticSecret as EncryptionStaticKey}; /// Struct to simplify testing by encapsulating common test components. @@ -25,6 +25,7 @@ pub struct ShinkaiTestingFramework { pub node_encryption_pk: EncryptionPublicKey, pub node_identity_name: String, pub node_profile_name: String, + pub bearer_token: String, } impl ShinkaiTestingFramework { @@ -36,6 +37,7 @@ impl ShinkaiTestingFramework { node_encryption_pk: EncryptionPublicKey, node_identity_name: String, node_profile_name: String, + bearer_token: String, ) -> Self { ShinkaiTestingFramework { node_commands_sender, @@ -44,6 +46,7 @@ impl ShinkaiTestingFramework { node_encryption_pk, node_identity_name, node_profile_name, + bearer_token, } } @@ -128,14 +131,9 @@ impl ShinkaiTestingFramework { let file_path = Path::new(file_path); upload_file( &self.node_commands_sender, - self.profile_encryption_sk.clone(), - clone_signature_secret_key(&self.profile_identity_sk), - self.node_encryption_pk, - &self.node_identity_name, - &self.node_profile_name, folder_name, file_path, - 0, // Example symmetric key index, adjust as needed + &self.bearer_token, ) .await; } diff --git a/shinkai-bin/shinkai-node/tests/it/utils/test_boilerplate.rs b/shinkai-bin/shinkai-node/tests/it/utils/test_boilerplate.rs index bfa9b9a40..8877f8b61 100644 --- a/shinkai-bin/shinkai-node/tests/it/utils/test_boilerplate.rs +++ b/shinkai-bin/shinkai-node/tests/it/utils/test_boilerplate.rs @@ -1,14 +1,14 @@ -use super::db_handlers::setup; +use super::db_handlers::{setup, setup_node_storage_path}; use async_channel::{bounded, Receiver, Sender}; +use shinkai_embedding::embedding_generator::RemoteEmbeddingGenerator; +use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use shinkai_node::llm_provider::job_callback_manager::JobCallbackManager; use shinkai_node::managers::sheet_manager::SheetManager; use shinkai_node::managers::tool_router::ToolRouter; use shinkai_sqlite::SqliteManager; -use shinkai_vector_fs::vector_fs::vector_fs::VectorFS; -use shinkai_vector_resources::embedding_generator::RemoteEmbeddingGenerator; -use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; -use tokio::sync::{Mutex, RwLock}; + +use tokio::sync::Mutex; use core::panic; use ed25519_dalek::{SigningKey, VerifyingKey}; @@ -48,11 +48,11 @@ pub struct TestEnvironment { pub node1_device_identity_pk: VerifyingKey, pub node1_device_encryption_sk: EncryptionStaticKey, pub node1_device_encryption_pk: EncryptionPublicKey, - pub node1_vecfs: Arc, pub node1_db: Arc, pub node1_sheet_manager: Arc>, pub node1_callback_manager: Arc>, pub node1_tool_router: Option>, + pub node1_api_key: String, pub node1_abort_handler: AbortHandle, } @@ -83,6 +83,7 @@ where F: FnOnce(TestEnvironment) -> Pin + Send>> + Send + 'static, { setup(); + setup_node_storage_path(); let rt = Runtime::new().unwrap(); rt.block_on(async { @@ -104,12 +105,11 @@ where let (node1_device_encryption_sk, node1_device_encryption_pk) = unsafe_deterministic_encryption_keypair(200); let node1_db_path = format!("db_tests/{}", hash_signature_public_key(&node1_identity_pk)); - let node1_fs_db_path = format!("db_tests/vector_fs{}", hash_signature_public_key(&node1_identity_pk)); // Fetch the PROXY_ADDRESS environment variable let proxy_identity: Option = env::var("PROXY_IDENTITY").ok().and_then(|addr| addr.parse().ok()); - let api_v2_key = env::var("API_V2_KEY").unwrap_or_else(|_| "SUPER_SECRET".to_string()); + let node1_api_key = env::var("API_V2_KEY").unwrap_or_else(|_| "SUPER_SECRET".to_string()); // Create node1 and node2 let addr1 = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080); @@ -127,17 +127,15 @@ where proxy_identity, false, vec![], - node1_fs_db_path, Some(RemoteEmbeddingGenerator::new_default()), None, default_embedding_model(), supported_embedding_models(), - Some(api_v2_key), + Some(node1_api_key.clone()), ) .await; let node1_locked = node1.lock().await; - let node1_vecfs = node1_locked.vector_fs.clone(); let node1_db = node1_locked.db.clone(); let node1_sheet_manager = node1_locked.sheet_manager.clone(); let node1_callback_manager = node1_locked.callback_manager.clone(); @@ -172,12 +170,12 @@ where node1_device_identity_pk, node1_device_encryption_sk, node1_device_encryption_pk, - node1_vecfs, node1_db, node1_sheet_manager, node1_callback_manager, node1_tool_router, node1_abort_handler, + node1_api_key, }; let interactions_handler = tokio::spawn(interactions_handler_logic(env)); diff --git a/shinkai-bin/shinkai-node/tests/it/utils/vecfs_test_utils.rs b/shinkai-bin/shinkai-node/tests/it/utils/vecfs_test_utils.rs index 42c19c638..e6a388663 100644 --- a/shinkai-bin/shinkai-node/tests/it/utils/vecfs_test_utils.rs +++ b/shinkai-bin/shinkai-node/tests/it/utils/vecfs_test_utils.rs @@ -1,29 +1,22 @@ -use aes_gcm::aead::{generic_array::GenericArray, Aead}; -use aes_gcm::Aes256Gcm; -use aes_gcm::KeyInit; use async_channel::Sender; use chrono::{TimeZone, Utc}; use ed25519_dalek::SigningKey; use rust_decimal::Decimal; use serde_json::Value; +use shinkai_fs::shinkai_fs_error::ShinkaiFsError; +use shinkai_http_api::node_api_router::APIError; +use shinkai_http_api::node_commands::NodeCommand; use shinkai_message_primitives::schemas::shinkai_subscription_req::FolderSubscription; use shinkai_message_primitives::schemas::shinkai_subscription_req::PaymentOption; use shinkai_message_primitives::shinkai_message::shinkai_message::ShinkaiMessage; use shinkai_message_primitives::shinkai_message::shinkai_message_schemas::{ - APIAvailableSharedItems, APIConvertFilesAndSaveToFolder, APICreateShareableFolder, APIVecFsCreateFolder, - APIVecFsDeleteFolder, APIVecFsDeleteItem, APIVecFsRetrievePathSimplifiedJson, FileDestinationCredentials, - MessageSchemaType, + APIAvailableSharedItems, APICreateShareableFolder, APIVecFsCreateFolder, APIVecFsDeleteFolder, APIVecFsDeleteItem, + APIVecFsRetrievePathSimplifiedJson, FileDestinationCredentials, MessageSchemaType, }; use shinkai_message_primitives::shinkai_utils::encryption::EncryptionMethod; -use shinkai_message_primitives::shinkai_utils::file_encryption::{ - aes_encryption_key_to_string, aes_nonce_to_hex_string, hash_of_aes_encryption_key_hex, - unsafe_deterministic_aes_encryption_key, -}; use shinkai_message_primitives::shinkai_utils::shinkai_message_builder::ShinkaiMessageBuilder; -use shinkai_http_api::node_commands::NodeCommand; -use shinkai_http_api::node_api_router::APIError; -use shinkai_vector_resources::resource_errors::VRError; + use std::path::Path; use std::time::Duration; use x25519_dalek::{PublicKey as EncryptionPublicKey, StaticSecret as EncryptionStaticKey}; @@ -203,102 +196,6 @@ pub fn generate_message_with_payload( .unwrap() } -// Function to recursively check if the actual response contains the expected structure -pub fn check_structure(actual: &Value, expected: &Value) -> bool { - if let (Some(mut actual_folders), Some(mut expected_folders)) = ( - actual["child_folders"].as_array().cloned(), - expected["child_folders"].as_array().cloned(), - ) { - if actual_folders.len() != expected_folders.len() { - eprintln!("Folder count mismatch: expected {}, found {}", expected_folders.len(), actual_folders.len()); - return false; - } - sort_folders(&mut actual_folders); - sort_folders(&mut expected_folders); - for (actual_folder, expected_folder) in actual_folders.iter().zip(expected_folders.iter()) { - if !check_folder(actual_folder, expected_folder) { - return false; - } - } - } else { - eprintln!("Expected and actual folders structure mismatch"); - return false; - } - true -} - -pub fn sort_folders(folders: &mut [Value]) { - folders.sort_by(|a, b| a["name"].as_str().cmp(&b["name"].as_str())); -} - -pub fn sort_items(items: &mut [Value]) { - items.sort_by(|a, b| a["name"].as_str().cmp(&b["name"].as_str())); -} - -pub fn check_folder(actual_folder: &Value, expected_folder: &Value) -> bool { - let actual_name = actual_folder["name"].as_str().unwrap_or("Unknown Folder"); - let expected_name = expected_folder["name"].as_str().unwrap_or("Unknown Folder"); - if actual_name != expected_name { - eprintln!("Folder name mismatch: expected '{}', found '{}'", expected_name, actual_name); - return false; - } - - let actual_path = actual_folder["path"].as_str().unwrap_or("Unknown Path"); - let expected_path = expected_folder["path"].as_str().unwrap_or("Unknown Path"); - if actual_path != expected_path { - eprintln!("Folder path mismatch: expected '{}', found '{}'", expected_path, actual_path); - return false; - } - - let mut actual_subfolders = actual_folder["child_folders"].as_array().unwrap_or(&vec![]).to_vec(); - let mut expected_subfolders = expected_folder["child_folders"].as_array().unwrap_or(&vec![]).to_vec(); - if actual_subfolders.len() != expected_subfolders.len() { - eprintln!("Subfolder count mismatch in '{}': expected {}, found {}", actual_name, expected_subfolders.len(), actual_subfolders.len()); - return false; - } - sort_folders(&mut actual_subfolders); - sort_folders(&mut expected_subfolders); - for (actual_subfolder, expected_subfolder) in actual_subfolders.iter().zip(expected_subfolders.iter()) { - if !check_folder(actual_subfolder, expected_subfolder) { - return false; - } - } - - let mut actual_items = actual_folder["child_items"].as_array().unwrap_or(&vec![]).to_vec(); - let mut expected_items = expected_folder["child_items"].as_array().unwrap_or(&vec![]).to_vec(); - if actual_items.len() != expected_items.len() { - eprintln!("Item count mismatch in '{}': expected {}, found {}", actual_name, expected_items.len(), actual_items.len()); - return false; - } - sort_items(&mut actual_items); - sort_items(&mut expected_items); - for (actual_item, expected_item) in actual_items.iter().zip(expected_items.iter()) { - if !check_item(actual_item, expected_item) { - return false; - } - } - - true -} - -pub fn check_item(actual_item: &Value, expected_item: &Value) -> bool { - let actual_name = actual_item["name"].as_str().unwrap_or("Unknown Item"); - let expected_name = expected_item["name"].as_str().unwrap_or("Unknown Item"); - if actual_name != expected_name { - eprintln!("Item name mismatch: expected '{}', found '{}'", expected_name, actual_name); - return false; - } - - let actual_path = actual_item["path"].as_str().unwrap_or("Unknown Path"); - let expected_path = expected_item["path"].as_str().unwrap_or("Unknown Path"); - if actual_path != expected_path { - eprintln!("Item path mismatch: expected '{}', found '{}'", expected_path, actual_path); - return false; - } - - true -} - pub async fn fetch_last_messages( commands_sender: &Sender, limit: usize, @@ -582,14 +479,9 @@ pub fn print_subtree(folder: &serde_json::Value, indent: &str, is_last: bool) { #[allow(clippy::too_many_arguments)] pub async fn upload_file( commands_sender: &Sender, - encryption_sk: EncryptionStaticKey, - signature_sk: SigningKey, - encryption_pk: EncryptionPublicKey, - identity_name: &str, - profile_name: &str, folder_name: &str, file_path: &Path, - symmetric_key_index: u32, + bearer_token: &str, ) { eprintln!("file_path: {:?}", file_path); @@ -597,79 +489,119 @@ pub async fn upload_file( let current_dir = std::env::current_dir().unwrap(); println!("Current directory: {:?}", current_dir); + // Read file data + let file_data = std::fs::read(file_path) + .map_err(|_| ShinkaiFsError::FailedPDFParsing) + .unwrap(); - let symmetrical_sk = unsafe_deterministic_aes_encryption_key(symmetric_key_index); - eprintln!("\n\n### Sending message (APICreateFilesInboxWithSymmetricKey) from profile subidentity to node 1\n\n"); - - let message_content = aes_encryption_key_to_string(symmetrical_sk); - let msg = ShinkaiMessageBuilder::create_files_inbox_with_sym_key( - encryption_sk.clone(), - signature_sk.clone(), - encryption_pk, - "job::test::false".to_string(), - message_content.clone(), - profile_name.to_string(), - identity_name.to_string(), - identity_name.to_string(), - ) - .unwrap(); + // Extract the file name and extension + let filename = file_path.file_name().unwrap().to_string_lossy().to_string(); + // Prepare the response channel let (res_sender, res_receiver) = async_channel::bounded(1); + + // Send the command using V2ApiUploadFileToFolder commands_sender - .send(NodeCommand::APICreateFilesInboxWithSymmetricKey { msg, res: res_sender }) + .send(NodeCommand::V2ApiUploadFileToFolder { + bearer: bearer_token.to_string(), + filename, // Use the extracted filename + file: file_data, + path: folder_name.to_string(), + file_datetime: Some(Utc.with_ymd_and_hms(2024, 2, 1, 0, 0, 0).unwrap()), + res: res_sender, + }) .await .unwrap(); - let _ = res_receiver.recv().await.unwrap().expect("Failed to receive messages"); - // Upload file - let file_data = std::fs::read(file_path).map_err(|_| VRError::FailedPDFParsing).unwrap(); + let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); + eprintln!("upload_file resp to folder: {:?}", resp); +} + +#[allow(clippy::too_many_arguments)] +pub async fn upload_file_to_job( + commands_sender: &Sender, + job_id: &str, + file_path: &Path, + bearer_token: &str, +) { + eprintln!("file_path: {:?}", file_path); + + // Print current directory + let current_dir = std::env::current_dir().unwrap(); + println!("Current directory: {:?}", current_dir); - let cipher = Aes256Gcm::new(GenericArray::from_slice(&symmetrical_sk)); - let nonce = GenericArray::from_slice(&[0u8; 12]); - let nonce_slice = nonce.as_slice(); - let nonce_str = aes_nonce_to_hex_string(nonce_slice); - let ciphertext = cipher.encrypt(nonce, file_data.as_ref()).expect("encryption failure!"); + // Read file data + let file_data = std::fs::read(file_path) + .map_err(|_| ShinkaiFsError::FailedPDFParsing) + .unwrap(); + + // Extract the file name with extension + let filename = file_path.file_name().unwrap().to_string_lossy().to_string(); + // Prepare the response channel let (res_sender, res_receiver) = async_channel::bounded(1); + + // Send the command using V2ApiUploadFileToJob commands_sender - .send(NodeCommand::APIAddFileToInboxWithSymmetricKey { - filename: file_path.to_string_lossy().to_string(), - file: ciphertext, - public_key: hash_of_aes_encryption_key_hex(symmetrical_sk), - encrypted_nonce: nonce_str, + .send(NodeCommand::V2ApiUploadFileToJob { + bearer: bearer_token.to_string(), + job_id: job_id.to_string(), + filename, // Use the extracted filename + file: file_data, + file_datetime: Some(Utc.with_ymd_and_hms(2024, 2, 1, 0, 0, 0).unwrap()), res: res_sender, }) .await .unwrap(); - let res = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - eprintln!("upload_file resp to inbox: {:?}", res); - - // Convert File and Save to Folder - let payload = APIConvertFilesAndSaveToFolder { - path: folder_name.to_string(), - file_inbox: hash_of_aes_encryption_key_hex(symmetrical_sk), - file_datetime: Some(Utc.with_ymd_and_hms(2024, 2, 1, 0, 0, 0).unwrap()), - }; - let msg = generate_message_with_payload( - serde_json::to_string(&payload).unwrap(), - MessageSchemaType::ConvertFilesAndSaveToFolder, - encryption_sk.clone(), - signature_sk.clone(), - encryption_pk, - identity_name, - profile_name, - identity_name, - profile_name, - ); + let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); + eprintln!("upload_file_to_job resp: {:?}", resp); +} +pub async fn get_folder_name_for_job( + commands_sender: &Sender, + job_id: &str, + bearer_token: &str, +) -> Result { + // Prepare the response channel let (res_sender, res_receiver) = async_channel::bounded(1); + + // Send the command to get the folder name for the job commands_sender - .send(NodeCommand::APIConvertFilesAndSaveToFolder { msg, res: res_sender }) + .send(NodeCommand::V2ApiVecFSGetFolderNameForJob { + bearer: bearer_token.to_string(), + job_id: job_id.to_string(), + res: res_sender, + }) .await .unwrap(); - let resp = res_receiver.recv().await; - eprintln!("upload_file resp to folder: {:?}", resp); - let resp = resp.unwrap().expect("Failed to receive response"); - eprintln!("upload_file resp processed: {:?}", resp); + + // Receive and convert the Value to String + res_receiver + .recv() + .await + .unwrap() + .map(|value| value.as_str().unwrap_or_default().to_string()) +} + +pub async fn get_files_for_job( + commands_sender: &Sender, + job_id: &str, + bearer_token: &str, +) -> Result { + // Prepare the response channel + let (res_sender, res_receiver) = async_channel::bounded(1); + + // Send the command to retrieve files for the job + commands_sender + .send(NodeCommand::V2ApiVecFSRetrieveFilesForJob { + bearer: bearer_token.to_string(), + job_id: job_id.to_string(), + res: res_sender, + }) + .await + .unwrap(); + + // Receive and return the files as a JSON value + res_receiver.recv().await.unwrap() } diff --git a/shinkai-bin/shinkai-node/tests/it/vector_fs_api_tests.rs b/shinkai-bin/shinkai-node/tests/it/vector_fs_api_tests.rs index ac1623102..8694ddd53 100644 --- a/shinkai-bin/shinkai-node/tests/it/vector_fs_api_tests.rs +++ b/shinkai-bin/shinkai-node/tests/it/vector_fs_api_tests.rs @@ -1,937 +1,937 @@ -use aes_gcm::aead::{generic_array::GenericArray, Aead}; -use aes_gcm::Aes256Gcm; -use aes_gcm::KeyInit; -use base64::Engine; -use chrono::TimeZone; -use chrono::Utc; -use ed25519_dalek::SigningKey; -use shinkai_http_api::node_commands::NodeCommand; -use shinkai_message_primitives::schemas::llm_providers::serialized_llm_provider::{ - LLMProviderInterface, Ollama, SerializedLLMProvider, -}; -use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; -use shinkai_message_primitives::shinkai_message::shinkai_message::ShinkaiMessage; -use shinkai_message_primitives::shinkai_message::shinkai_message_schemas::{ - APIConvertFilesAndSaveToFolder, APIVecFsCopyItem, APIVecFsCreateFolder, APIVecFsDeleteFolder, APIVecFsDeleteItem, - APIVecFsMoveFolder, APIVecFsMoveItem, APIVecFsRetrievePathSimplifiedJson, APIVecFsRetrieveSourceFile, - APIVecFsRetrieveVectorSearchSimplifiedJson, APIVecFsSearchItems, MessageSchemaType, -}; -use shinkai_message_primitives::shinkai_utils::encryption::{clone_static_secret_key, EncryptionMethod}; -use shinkai_message_primitives::shinkai_utils::file_encryption::{ - aes_encryption_key_to_string, aes_nonce_to_hex_string, hash_of_aes_encryption_key_hex, - unsafe_deterministic_aes_encryption_key, -}; -use shinkai_message_primitives::shinkai_utils::shinkai_message_builder::ShinkaiMessageBuilder; -use shinkai_message_primitives::shinkai_utils::signatures::clone_signature_secret_key; -use shinkai_vector_resources::resource_errors::VRError; -use std::path::Path; -use std::sync::Arc; -use utils::test_boilerplate::run_test_one_node_network; -use x25519_dalek::{PublicKey as EncryptionPublicKey, StaticSecret as EncryptionStaticKey}; - -use crate::it::utils::shinkai_testing_framework::ShinkaiTestingFramework; - -use super::utils; -use super::utils::db_handlers::setup_node_storage_path; -use super::utils::node_test_api::{api_initial_registration_with_no_code_for_device, api_llm_provider_registration}; -use mockito::Server; - -#[allow(clippy::too_many_arguments)] -pub fn generate_message_with_payload( - payload: T, - schema: MessageSchemaType, - my_encryption_secret_key: EncryptionStaticKey, - my_signature_secret_key: SigningKey, - receiver_public_key: EncryptionPublicKey, - sender: &str, - sender_subidentity: &str, - recipient: &str, -) -> ShinkaiMessage { - let timestamp = Utc::now().format("%Y%m%dT%H%M%S%f").to_string(); - - ShinkaiMessageBuilder::new(my_encryption_secret_key, my_signature_secret_key, receiver_public_key) - .message_raw_content(payload.to_string()) - .body_encryption(EncryptionMethod::None) - .message_schema_type(schema) - .internal_metadata_with_inbox( - sender_subidentity.to_string(), - "".to_string(), - "".to_string(), - EncryptionMethod::None, - None, - ) - .external_metadata_with_schedule(recipient.to_string(), sender.to_string(), timestamp) - .build() - .unwrap() -} - -#[test] -fn vector_fs_api_tests() { - setup_node_storage_path(); - std::env::set_var("WELCOME_MESSAGE", "false"); - std::env::set_var("ONLY_TESTING_JS_TOOLS", "true"); - - - let mut server = Server::new(); - - run_test_one_node_network(|env| { - Box::pin(async move { - let node1_commands_sender = env.node1_commands_sender.clone(); - let node1_identity_name = env.node1_identity_name.clone(); - let node1_profile_name = env.node1_profile_name.clone(); - let node1_device_name = env.node1_device_name.clone(); - let node1_agent = env.node1_llm_provider.clone(); - let node1_encryption_pk = env.node1_encryption_pk; - let node1_device_encryption_sk = env.node1_device_encryption_sk.clone(); - let node1_profile_encryption_sk = env.node1_profile_encryption_sk.clone(); - let node1_device_identity_sk = clone_signature_secret_key(&env.node1_device_identity_sk); - let node1_profile_identity_sk = clone_signature_secret_key(&env.node1_profile_identity_sk); - let node1_abort_handler = env.node1_abort_handler; - - let node1_db_weak = Arc::downgrade(&env.node1_db); - - // For this test - let symmetrical_sk = unsafe_deterministic_aes_encryption_key(0); - - { - // Register a Profile in Node1 and verifies it - eprintln!("\n\nRegister a Device with main Profile in Node1 and verify it"); - api_initial_registration_with_no_code_for_device( - node1_commands_sender.clone(), - env.node1_profile_name.as_str(), - env.node1_identity_name.as_str(), - node1_encryption_pk, - node1_device_encryption_sk.clone(), - clone_signature_secret_key(&node1_device_identity_sk), - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_device_name.as_str(), - ) - .await; - } - { - // Register an Agent - eprintln!("\n\nRegister an Agent in Node1 and verify it"); - let agent_name = ShinkaiName::new( - format!( - "{}/{}/agent/{}", - node1_identity_name.clone(), - node1_profile_name.clone(), - node1_agent.clone() - ) - .to_string(), - ) - .unwrap(); - - // Note: this is mocked for Ollamas API - let _m = server - .mock("POST", "/api/generate") - .with_status(200) - .with_header("content-type", "application/json") - .with_body( - r#"{ - "model":"mixtral:8x7b-instruct-v0.1-q4_1", - "created_at":"2023-12-19T11:36:44.687874415Z", - "response":"{\"answer\": \"Why couldn't the bicycle stand up by itself? Because it was two-tired.\"}", - "done":true, - "context":[28705,733,16289,28793,28705,995,460,396,10023,13892,693,865,659,2735,298,272,3857,3036,304,574,1216,4788,298,4372,707,2996,272,2188,5312,28723,2378,459,1460,354,3629,2758,442,1871,297,574,4372,298,272,2188,28725,562,3768,1912,272,2188,390,1188,1871,390,2572,28723,415,2188,659,2261,28747,28705,387,1912,528,264,13015,28723,13,1047,368,506,2066,1871,298,5090,4372,272,2188,28742,28713,2996,28747,1992,19571,1413,272,2296,413,6848,28765,304,7771,2511,1112,28747,464,18437,464,24115,28742,464,14243,1423,464,11339,28705,1047,368,927,298,18896,680,1871,298,9222,4372,272,2188,28725,868,368,622,927,298,1073,9547,304,1605,27674,4916,28748,14104,272,6594,14060,395,680,1871,304,1073,302,264,3472,5709,298,1300,633,3036,28723,11147,354,28049,680,4842,567,10537,821,1552,28707,479,528,264,28832,28747,1992,19571,1413,272,2296,413,6848,28765,304,7771,2511,1112,28747,464,18437,464,2360,28742,464,14243,1423,28725,464,3499,1869,464,1427,28742,443,28742,28705,8789,3371,733,28748,16289,4490,28739,24115,1264,345,7638,3481,28742,28707,272,24521,1812,1876,582,486,3837,28804,5518,378,403,989,28733,28707,1360,611,28752], - "total_duration":29617027653, - "load_duration":7157879293, - "prompt_eval_count":203, - "prompt_eval_duration":19022360000, - "eval_count":25, - "eval_duration":3435284000 - }"#, - ) - .create(); - - let ollama = Ollama { - model_type: "mixtral:8x7b-instruct-v0.1-q4_1".to_string(), - }; - - let agent = SerializedLLMProvider { - id: node1_agent.clone().to_string(), - full_identity_name: agent_name, - api_key: Some("".to_string()), - external_url: Some(server.url()), - model: LLMProviderInterface::Ollama(ollama), - }; - api_llm_provider_registration( - node1_commands_sender.clone(), - clone_static_secret_key(&node1_profile_encryption_sk), - node1_encryption_pk, - clone_signature_secret_key(&node1_profile_identity_sk), - node1_identity_name.clone().as_str(), - node1_profile_name.clone().as_str(), - agent, - ) - .await; - } - // Send message (APICreateFilesInboxWithSymmetricKey) from Device subidentity to Node 1 - { - eprintln!("\n\n### Sending message (APICreateFilesInboxWithSymmetricKey) from profile subidentity to node 1\n\n"); - - let message_content = aes_encryption_key_to_string(symmetrical_sk); - let msg = ShinkaiMessageBuilder::create_files_inbox_with_sym_key( - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - "job::test::false".to_string(), - message_content.clone(), - node1_profile_name.to_string(), - node1_identity_name.to_string(), - node1_identity_name.to_string(), - ) - .unwrap(); - - let (res_sender, res_receiver) = async_channel::bounded(1); - node1_commands_sender - .send(NodeCommand::APICreateFilesInboxWithSymmetricKey { msg, res: res_sender }) - .await - .unwrap(); - let _ = res_receiver.recv().await.unwrap().expect("Failed to receive messages"); - } - { - // Initialize local PDF parser - ShinkaiTestingFramework::initialize_pdfium().await; - - // Create Folder - let payload = APIVecFsCreateFolder { - path: "/".to_string(), - folder_name: "test_folder".to_string(), - }; - - let msg = generate_message_with_payload( - serde_json::to_string(&payload).unwrap(), - MessageSchemaType::VecFsCreateFolder, - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - node1_identity_name.as_str(), - node1_profile_name.as_str(), - node1_identity_name.as_str(), - ); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIVecFSCreateFolder { msg, res: res_sender }) - .await - .unwrap(); - let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - eprintln!("resp: {:?}", resp); - } - { - // Create Folder - let payload = APIVecFsCreateFolder { - path: "/".to_string(), - folder_name: "test_folder2".to_string(), - }; - - let msg = generate_message_with_payload( - serde_json::to_string(&payload).unwrap(), - MessageSchemaType::VecFsCreateFolder, - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - node1_identity_name.as_str(), - node1_profile_name.as_str(), - node1_identity_name.as_str(), - ); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIVecFSCreateFolder { msg, res: res_sender }) - .await - .unwrap(); - let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - eprintln!("resp: {:?}", resp); - } - { - // Upload .vrkai file to inbox - // Prepare the file to be read - let filename = "../../files/shinkai_intro.vrkai"; - let file_path = Path::new(filename); - - // Read the file into a buffer - let file_data = std::fs::read(file_path).map_err(|_| VRError::FailedPDFParsing).unwrap(); - - // Encrypt the file using Aes256Gcm - let cipher = Aes256Gcm::new(GenericArray::from_slice(&symmetrical_sk)); - let nonce = GenericArray::from_slice(&[0u8; 12]); - let nonce_slice = nonce.as_slice(); - let nonce_str = aes_nonce_to_hex_string(nonce_slice); - let ciphertext = cipher.encrypt(nonce, file_data.as_ref()).expect("encryption failure!"); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIAddFileToInboxWithSymmetricKey { - filename: filename.to_string(), - file: ciphertext, - public_key: hash_of_aes_encryption_key_hex(symmetrical_sk), - encrypted_nonce: nonce_str, - res: res_sender, - }) - .await - .unwrap(); - - // Receive the response - let _ = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - } - { - // Convert File and Save to Folder - let payload = APIConvertFilesAndSaveToFolder { - path: "/test_folder".to_string(), - file_inbox: hash_of_aes_encryption_key_hex(symmetrical_sk), - file_datetime: Some(Utc.with_ymd_and_hms(2024, 2, 1, 0, 0, 0).unwrap()), - }; - - let msg = generate_message_with_payload( - serde_json::to_string(&payload).unwrap(), - MessageSchemaType::ConvertFilesAndSaveToFolder, - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - node1_identity_name.as_str(), - node1_profile_name.as_str(), - node1_identity_name.as_str(), - ); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIConvertFilesAndSaveToFolder { msg, res: res_sender }) - .await - .unwrap(); - let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - eprintln!("resp: {:?}", resp); - } - let mut retrieved_fs_json = String::new(); - { - // Recover file from path using APIVecFSRetrievePathSimplifiedJson - let payload = APIVecFsRetrievePathSimplifiedJson { - path: "/test_folder/shinkai_intro".to_string(), - }; - - let msg = generate_message_with_payload( - serde_json::to_string(&payload).unwrap(), - MessageSchemaType::VecFsRetrievePathSimplifiedJson, - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - node1_identity_name.as_str(), - node1_profile_name.as_str(), - node1_identity_name.as_str(), - ); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIVecFSRetrievePathSimplifiedJson { msg, res: res_sender }) - .await - .unwrap(); - let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - // eprintln!("resp for current file system files: {}", resp); - - // Assuming `resp` is now a serde_json::Value - let resp_json = serde_json::to_string(&resp).expect("Failed to convert response to string"); - // eprintln!("resp for current file system files: {}", resp_json); - - // TODO: convert to json and then compare - let expected_path = "/test_folder/shinkai_intro"; - assert!( - resp_json.contains(expected_path), - "Response does not contain the expected file path: {}", - expected_path - ); - retrieved_fs_json = resp_json; - } - { - // Upload .pdf file to inbox - // Prepare the file to be read - let filename = "../../files/shinkai_intro.pdf"; - let file_path = Path::new(filename); - - // Read the file into a buffer - let file_data = std::fs::read(file_path).map_err(|_| VRError::FailedPDFParsing).unwrap(); - - // Encrypt the file using Aes256Gcm - let cipher = Aes256Gcm::new(GenericArray::from_slice(&symmetrical_sk)); - let nonce = GenericArray::from_slice(&[0u8; 12]); - let nonce_slice = nonce.as_slice(); - let nonce_str = aes_nonce_to_hex_string(nonce_slice); - let ciphertext = cipher.encrypt(nonce, file_data.as_ref()).expect("encryption failure!"); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIAddFileToInboxWithSymmetricKey { - filename: filename.to_string(), - file: ciphertext, - public_key: hash_of_aes_encryption_key_hex(symmetrical_sk), - encrypted_nonce: nonce_str, - res: res_sender, - }) - .await - .unwrap(); - - // Receive the response - let _ = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - } - { - // Convert File and Save to Folder - let payload = APIConvertFilesAndSaveToFolder { - path: "/test_folder".to_string(), - file_inbox: hash_of_aes_encryption_key_hex(symmetrical_sk), - file_datetime: Some(Utc.with_ymd_and_hms(2024, 2, 1, 0, 0, 0).unwrap()), - }; - - let msg = generate_message_with_payload( - serde_json::to_string(&payload).unwrap(), - MessageSchemaType::ConvertFilesAndSaveToFolder, - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - node1_identity_name.as_str(), - node1_profile_name.as_str(), - node1_identity_name.as_str(), - ); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIConvertFilesAndSaveToFolder { msg, res: res_sender }) - .await - .unwrap(); - let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - eprintln!("resp: {:?}", resp); - } - { - // Recover file from path using APIVecFSRetrievePathSimplifiedJson - let payload = APIVecFsRetrievePathSimplifiedJson { - path: "/test_folder/shinkai_intro".to_string(), - }; - - let msg = generate_message_with_payload( - serde_json::to_string(&payload).unwrap(), - MessageSchemaType::VecFsRetrievePathSimplifiedJson, - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - node1_identity_name.as_str(), - node1_profile_name.as_str(), - node1_identity_name.as_str(), - ); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIVecFSRetrievePathSimplifiedJson { msg, res: res_sender }) - .await - .unwrap(); - let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - eprintln!("resp for current file system files: {:?}", resp); - - // Convert `resp` from serde_json::Value to String for comparison - let resp_json = serde_json::to_string(&resp).expect("Failed to convert response to string"); - - let expected_path = "/test_folder/shinkai_intro"; - assert!( - resp_json.contains(expected_path), - "Response does not contain the expected file path: {}", - expected_path - ); - // Assert that after updating the fs item with a new VR generated from the PDF (overwriting the one from the .vrkai), - // the filesystem json is different (because different timestamps/id on the item). - assert_ne!(resp_json, retrieved_fs_json); - } - { - // Retrieve source file - let payload = APIVecFsRetrieveSourceFile { - path: "/test_folder/shinkai_intro".to_string(), - }; - - let api_v2_key = std::env::var("API_V2_KEY").unwrap_or_else(|_| "SUPER_SECRET".to_string()); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::V2ApiRetrieveSourceFile { - bearer: api_v2_key, - payload, - res: res_sender, - }) - .await - .unwrap(); - let resp_base64 = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - - // Compare the response with the original file - let filename = "../../files/shinkai_intro.pdf"; - let file_path = Path::new(filename); - let file_data = std::fs::read(file_path).map_err(|_| VRError::FailedPDFParsing).unwrap(); - - let decoded_content = base64::engine::general_purpose::STANDARD - .decode(resp_base64.as_bytes()) - .expect("Failed to decode base64"); - assert_eq!(file_data, decoded_content); - } - - { - // Copy Item (we required creating a new folder to copy the item to) - { - // Create Folder - let payload = APIVecFsCreateFolder { - path: "/".to_string(), - folder_name: "test_folder3".to_string(), - }; - - let msg = generate_message_with_payload( - serde_json::to_string(&payload).unwrap(), - MessageSchemaType::VecFsCreateFolder, - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - node1_identity_name.as_str(), - node1_profile_name.as_str(), - node1_identity_name.as_str(), - ); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIVecFSCreateFolder { msg, res: res_sender }) - .await - .unwrap(); - let _ = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - } - // Copy item - let payload = APIVecFsCopyItem { - origin_path: "/test_folder/shinkai_intro".to_string(), - destination_path: "/test_folder3".to_string(), - }; - - let msg = generate_message_with_payload( - serde_json::to_string(&payload).unwrap(), - MessageSchemaType::VecFsCopyItem, - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - node1_identity_name.as_str(), - node1_profile_name.as_str(), - node1_identity_name.as_str(), - ); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIVecFSCopyItem { msg, res: res_sender }) - .await - .unwrap(); - let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - assert!( - resp.contains("Item copied successfully to /test_folder3"), - "Response does not contain the expected file path: /test_folder3/shinkai_intro" - ); - } - { - // Move item - let payload = APIVecFsMoveItem { - origin_path: "/test_folder3/shinkai_intro".to_string(), - destination_path: "/test_folder2".to_string(), - }; - - let msg = generate_message_with_payload( - serde_json::to_string(&payload).unwrap(), - MessageSchemaType::VecFsMoveItem, // Assuming you have a corresponding schema type for moving items - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - node1_identity_name.as_str(), - node1_profile_name.as_str(), - node1_identity_name.as_str(), - ); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIVecFSMoveItem { msg, res: res_sender }) // Assuming you have a corresponding NodeCommand for moving items - .await - .unwrap(); - let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - eprintln!("resp: {:?}", resp); - assert!( - resp.contains("Item moved successfully to /test_folder"), - "Response does not contain the expected file path: /test_folder" - ); - } - { - // Move Folder - let payload = APIVecFsMoveFolder { - origin_path: "/test_folder".to_string(), - destination_path: "/test_folder2".to_string(), - }; - - let msg = generate_message_with_payload( - serde_json::to_string(&payload).unwrap(), - MessageSchemaType::VecFsMoveFolder, - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - node1_identity_name.as_str(), - node1_profile_name.as_str(), - node1_identity_name.as_str(), - ); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIVecFSMoveFolder { msg, res: res_sender }) - .await - .unwrap(); - let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - eprintln!("resp: {:?}", resp); - } - { - // Recover file from path using APIVecFSRetrievePathSimplifiedJson - let payload = APIVecFsRetrievePathSimplifiedJson { path: "/".to_string() }; - - let msg = generate_message_with_payload( - serde_json::to_string(&payload).unwrap(), - MessageSchemaType::VecFsRetrievePathSimplifiedJson, - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - node1_identity_name.as_str(), - node1_profile_name.as_str(), - node1_identity_name.as_str(), - ); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIVecFSRetrievePathSimplifiedJson { msg, res: res_sender }) - .await - .unwrap(); - let parsed_resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - // eprintln!("resp for current file system files: {:?}", parsed_resp); - - /* - / - ├── test_folder2 - │ ├── test_folder - │ │ └── shinkai_intro - │ └── shinkai_intro - └── test_folder3 - */ - - // Assert the root contains 'test_folder2' and 'test_folder3' - assert!( - parsed_resp["child_folders"] - .as_array() - .unwrap() - .iter() - .any(|folder| folder["name"] == "test_folder2"), - "test_folder2 is missing" - ); - assert!( - parsed_resp["child_folders"] - .as_array() - .unwrap() - .iter() - .any(|folder| folder["name"] == "test_folder3"), - "test_folder3 is missing" - ); - - // Assert 'test_folder2' contains 'test_folder' and 'shinkai_intro' - let test_folder2 = parsed_resp["child_folders"] - .as_array() - .unwrap() - .iter() - .find(|folder| folder["name"] == "test_folder2") - .expect("test_folder2 not found"); - assert!( - test_folder2["child_folders"] - .as_array() - .unwrap() - .iter() - .any(|folder| folder["name"] == "test_folder"), - "test_folder inside test_folder2 is missing" - ); - assert!( - test_folder2["child_items"] - .as_array() - .unwrap() - .iter() - .any(|item| item["name"] == "shinkai_intro"), - "shinkai_intro directly inside test_folder2 is missing" - ); - - // Assert 'test_folder' inside 'test_folder2' contains 'shinkai_intro' - let test_folder_inside_test_folder2 = test_folder2["child_folders"] - .as_array() - .unwrap() - .iter() - .find(|folder| folder["name"] == "test_folder") - .expect("test_folder inside test_folder2 not found"); - assert!( - test_folder_inside_test_folder2["child_items"] - .as_array() - .unwrap() - .iter() - .any(|item| item["name"] == "shinkai_intro"), - "shinkai_intro inside test_folder inside test_folder2 is missing" - ); - } - { - // Do deep search - let payload = APIVecFsRetrieveVectorSearchSimplifiedJson { - search: "who wrote Shinkai?".to_string(), - path: Some("/test_folder2".to_string()), - max_results: Some(10), - max_files_to_scan: Some(100), - }; - - let msg = generate_message_with_payload( - serde_json::to_string(&payload).unwrap(), - MessageSchemaType::VecFsRetrieveVectorSearchSimplifiedJson, - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - node1_identity_name.as_str(), - node1_profile_name.as_str(), - node1_identity_name.as_str(), - ); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIVecFSRetrieveVectorSearchSimplifiedJson { msg, res: res_sender }) - .await - .unwrap(); - let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - for r in &resp { - eprintln!("\n\nSearch result: {:?}", r); - } - - let check_first = &resp[0].0 == &"Shinkai Network Manifesto (Early Preview)".to_string() - && (&resp[0].1 - == &vec![ - "test_folder2".to_string(), - "test_folder".to_string(), - "shinkai_intro".to_string(), - ] - || &resp[0].1 == &vec!["test_folder2".to_string(), "shinkai_intro".to_string()]); - - let check_second = &resp[1].0 == &"Shinkai Network Manifesto (Early Preview)".to_string() - && (&resp[1].1 - == &vec![ - "test_folder2".to_string(), - "test_folder".to_string(), - "shinkai_intro".to_string(), - ] - || &resp[1].1 == &vec!["test_folder2".to_string(), "shinkai_intro".to_string()]); - - assert!(!resp.is_empty(), "Response is empty."); - assert!(check_first && check_second); - } - { - // Do file search - let payload = APIVecFsSearchItems { - search: "shinkai".to_string(), - path: Some("/".to_string()), - max_results: Some(10), - max_files_to_scan: Some(100), - }; - - let msg = generate_message_with_payload( - serde_json::to_string(&payload).unwrap(), - MessageSchemaType::VecFsSearchItems, - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - node1_identity_name.as_str(), - node1_profile_name.as_str(), - node1_identity_name.as_str(), - ); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIVecFSSearchItems { msg, res: res_sender }) - .await - .unwrap(); - let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - eprintln!("resp seach items: {:?}", resp); - assert_eq!(resp.len(), 2, "Expected 2 search results, but got {}", resp.len()); - assert!( - resp.contains(&"/test_folder2/test_folder/shinkai_intro".to_string()), - "Response does not contain the expected file path: /test_folder2/test_folder/shinkai_intro" - ); - assert!( - resp.contains(&"/test_folder2/shinkai_intro".to_string()), - "Response does not contain the expected file path: /test_folder2/shinkai_intro" - ); - } - { - // Remove file - let payload = APIVecFsDeleteItem { - path: "/test_folder2/test_folder/shinkai_intro".to_string(), - }; - - let msg = generate_message_with_payload( - serde_json::to_string(&payload).unwrap(), - MessageSchemaType::VecFsDeleteItem, - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - node1_identity_name.as_str(), - node1_profile_name.as_str(), - node1_identity_name.as_str(), - ); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIVecFSDeleteItem { msg, res: res_sender }) - .await - .unwrap(); - let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - eprintln!("resp seach items delete item: {:?}", resp); - } - { - // remove folder - let payload = APIVecFsDeleteFolder { - path: "/test_folder2/test_folder".to_string(), - }; - - let msg = generate_message_with_payload( - serde_json::to_string(&payload).unwrap(), - MessageSchemaType::VecFsDeleteFolder, - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - node1_identity_name.as_str(), - node1_profile_name.as_str(), - node1_identity_name.as_str(), - ); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIVecFSDeleteFolder { msg, res: res_sender }) - .await - .unwrap(); - let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - eprintln!("resp seach items delete folder: {:?}", resp); - } - { - let payload = APIVecFsRetrievePathSimplifiedJson { path: "/".to_string() }; - - let msg = generate_message_with_payload( - serde_json::to_string(&payload).unwrap(), - MessageSchemaType::VecFsRetrievePathSimplifiedJson, - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - node1_identity_name.as_str(), - node1_profile_name.as_str(), - node1_identity_name.as_str(), - ); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIVecFSRetrievePathSimplifiedJson { msg, res: res_sender }) - .await - .unwrap(); - let parsed_resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - - // Assert root contains 'test_folder2' and 'test_folder3' - let root_folders = parsed_resp["child_folders"] - .as_array() - .expect("Expected child_folders to be an array"); - assert_eq!( - root_folders.len(), - 2, - "Expected 2 root folders, found {}", - root_folders.len() - ); - - let test_folder2 = root_folders - .iter() - .find(|&f| f["name"] == "test_folder2") - .expect("test_folder2 not found"); - let test_folder3 = root_folders - .iter() - .find(|&f| f["name"] == "test_folder3") - .expect("test_folder3 not found"); - - // Assert 'test_folder2' contains 'shinkai_intro' - let test_folder2_items = test_folder2["child_items"] - .as_array() - .expect("Expected child_items to be an array in test_folder2"); - assert_eq!( - test_folder2_items.len(), - 1, - "Expected 1 item in test_folder2, found {}", - test_folder2_items.len() - ); - assert_eq!( - test_folder2_items[0]["name"], "shinkai_intro", - "Expected item 'shinkai_intro' in test_folder2" - ); - - // Assert 'test_folder3' is empty - let test_folder3_folders = test_folder3["child_folders"] - .as_array() - .expect("Expected child_folders to be an array in test_folder3"); - let test_folder3_items = test_folder3["child_items"] - .as_array() - .expect("Expected child_items to be an array in test_folder3"); - assert!(test_folder3_folders.is_empty(), "Expected no folders in test_folder3"); - assert!(test_folder3_items.is_empty(), "Expected no items in test_folder3"); - } - node1_abort_handler.abort(); - }) - }); -} +// use aes_gcm::aead::{generic_array::GenericArray, Aead}; +// use aes_gcm::Aes256Gcm; +// use aes_gcm::KeyInit; +// use base64::Engine; +// use chrono::TimeZone; +// use chrono::Utc; +// use ed25519_dalek::SigningKey; +// use shinkai_http_api::node_commands::NodeCommand; +// use shinkai_message_primitives::schemas::llm_providers::serialized_llm_provider::{ +// LLMProviderInterface, Ollama, SerializedLLMProvider, +// }; +// use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; +// use shinkai_message_primitives::shinkai_message::shinkai_message::ShinkaiMessage; +// use shinkai_message_primitives::shinkai_message::shinkai_message_schemas::{ +// APIConvertFilesAndSaveToFolder, APIVecFsCopyItem, APIVecFsCreateFolder, APIVecFsDeleteFolder, APIVecFsDeleteItem, +// APIVecFsMoveFolder, APIVecFsMoveItem, APIVecFsRetrievePathSimplifiedJson, APIVecFsRetrieveSourceFile, +// APIVecFsRetrieveVectorSearchSimplifiedJson, APIVecFsSearchItems, MessageSchemaType, +// }; +// use shinkai_message_primitives::shinkai_utils::encryption::{clone_static_secret_key, EncryptionMethod}; +// use shinkai_message_primitives::shinkai_utils::file_encryption::{ +// aes_encryption_key_to_string, aes_nonce_to_hex_string, hash_of_aes_encryption_key_hex, +// unsafe_deterministic_aes_encryption_key, +// }; +// use shinkai_message_primitives::shinkai_utils::shinkai_message_builder::ShinkaiMessageBuilder; +// use shinkai_message_primitives::shinkai_utils::signatures::clone_signature_secret_key; +// use shinkai_vector_resources::resource_errors::VRError; +// use std::path::Path; +// use std::sync::Arc; +// use utils::test_boilerplate::run_test_one_node_network; +// use x25519_dalek::{PublicKey as EncryptionPublicKey, StaticSecret as EncryptionStaticKey}; + +// use crate::it::utils::shinkai_testing_framework::ShinkaiTestingFramework; + +// use super::utils; +// use super::utils::db_handlers::setup_node_storage_path; +// use super::utils::node_test_api::{api_initial_registration_with_no_code_for_device, api_llm_provider_registration}; +// use mockito::Server; + +// #[allow(clippy::too_many_arguments)] +// pub fn generate_message_with_payload( +// payload: T, +// schema: MessageSchemaType, +// my_encryption_secret_key: EncryptionStaticKey, +// my_signature_secret_key: SigningKey, +// receiver_public_key: EncryptionPublicKey, +// sender: &str, +// sender_subidentity: &str, +// recipient: &str, +// ) -> ShinkaiMessage { +// let timestamp = Utc::now().format("%Y%m%dT%H%M%S%f").to_string(); + +// ShinkaiMessageBuilder::new(my_encryption_secret_key, my_signature_secret_key, receiver_public_key) +// .message_raw_content(payload.to_string()) +// .body_encryption(EncryptionMethod::None) +// .message_schema_type(schema) +// .internal_metadata_with_inbox( +// sender_subidentity.to_string(), +// "".to_string(), +// "".to_string(), +// EncryptionMethod::None, +// None, +// ) +// .external_metadata_with_schedule(recipient.to_string(), sender.to_string(), timestamp) +// .build() +// .unwrap() +// } + +// #[test] +// fn vector_fs_api_tests() { +// setup_node_storage_path(); +// std::env::set_var("WELCOME_MESSAGE", "false"); +// std::env::set_var("ONLY_TESTING_JS_TOOLS", "true"); + + +// let mut server = Server::new(); + +// run_test_one_node_network(|env| { +// Box::pin(async move { +// let node1_commands_sender = env.node1_commands_sender.clone(); +// let node1_identity_name = env.node1_identity_name.clone(); +// let node1_profile_name = env.node1_profile_name.clone(); +// let node1_device_name = env.node1_device_name.clone(); +// let node1_agent = env.node1_llm_provider.clone(); +// let node1_encryption_pk = env.node1_encryption_pk; +// let node1_device_encryption_sk = env.node1_device_encryption_sk.clone(); +// let node1_profile_encryption_sk = env.node1_profile_encryption_sk.clone(); +// let node1_device_identity_sk = clone_signature_secret_key(&env.node1_device_identity_sk); +// let node1_profile_identity_sk = clone_signature_secret_key(&env.node1_profile_identity_sk); +// let node1_abort_handler = env.node1_abort_handler; + +// let node1_db_weak = Arc::downgrade(&env.node1_db); + +// // For this test +// let symmetrical_sk = unsafe_deterministic_aes_encryption_key(0); + +// { +// // Register a Profile in Node1 and verifies it +// eprintln!("\n\nRegister a Device with main Profile in Node1 and verify it"); +// api_initial_registration_with_no_code_for_device( +// node1_commands_sender.clone(), +// env.node1_profile_name.as_str(), +// env.node1_identity_name.as_str(), +// node1_encryption_pk, +// node1_device_encryption_sk.clone(), +// clone_signature_secret_key(&node1_device_identity_sk), +// node1_profile_encryption_sk.clone(), +// clone_signature_secret_key(&node1_profile_identity_sk), +// node1_device_name.as_str(), +// ) +// .await; +// } +// { +// // Register an Agent +// eprintln!("\n\nRegister an Agent in Node1 and verify it"); +// let agent_name = ShinkaiName::new( +// format!( +// "{}/{}/agent/{}", +// node1_identity_name.clone(), +// node1_profile_name.clone(), +// node1_agent.clone() +// ) +// .to_string(), +// ) +// .unwrap(); + +// // Note: this is mocked for Ollamas API +// let _m = server +// .mock("POST", "/api/generate") +// .with_status(200) +// .with_header("content-type", "application/json") +// .with_body( +// r#"{ +// "model":"mixtral:8x7b-instruct-v0.1-q4_1", +// "created_at":"2023-12-19T11:36:44.687874415Z", +// "response":"{\"answer\": \"Why couldn't the bicycle stand up by itself? Because it was two-tired.\"}", +// "done":true, +// "context":[28705,733,16289,28793,28705,995,460,396,10023,13892,693,865,659,2735,298,272,3857,3036,304,574,1216,4788,298,4372,707,2996,272,2188,5312,28723,2378,459,1460,354,3629,2758,442,1871,297,574,4372,298,272,2188,28725,562,3768,1912,272,2188,390,1188,1871,390,2572,28723,415,2188,659,2261,28747,28705,387,1912,528,264,13015,28723,13,1047,368,506,2066,1871,298,5090,4372,272,2188,28742,28713,2996,28747,1992,19571,1413,272,2296,413,6848,28765,304,7771,2511,1112,28747,464,18437,464,24115,28742,464,14243,1423,464,11339,28705,1047,368,927,298,18896,680,1871,298,9222,4372,272,2188,28725,868,368,622,927,298,1073,9547,304,1605,27674,4916,28748,14104,272,6594,14060,395,680,1871,304,1073,302,264,3472,5709,298,1300,633,3036,28723,11147,354,28049,680,4842,567,10537,821,1552,28707,479,528,264,28832,28747,1992,19571,1413,272,2296,413,6848,28765,304,7771,2511,1112,28747,464,18437,464,2360,28742,464,14243,1423,28725,464,3499,1869,464,1427,28742,443,28742,28705,8789,3371,733,28748,16289,4490,28739,24115,1264,345,7638,3481,28742,28707,272,24521,1812,1876,582,486,3837,28804,5518,378,403,989,28733,28707,1360,611,28752], +// "total_duration":29617027653, +// "load_duration":7157879293, +// "prompt_eval_count":203, +// "prompt_eval_duration":19022360000, +// "eval_count":25, +// "eval_duration":3435284000 +// }"#, +// ) +// .create(); + +// let ollama = Ollama { +// model_type: "mixtral:8x7b-instruct-v0.1-q4_1".to_string(), +// }; + +// let agent = SerializedLLMProvider { +// id: node1_agent.clone().to_string(), +// full_identity_name: agent_name, +// api_key: Some("".to_string()), +// external_url: Some(server.url()), +// model: LLMProviderInterface::Ollama(ollama), +// }; +// api_llm_provider_registration( +// node1_commands_sender.clone(), +// clone_static_secret_key(&node1_profile_encryption_sk), +// node1_encryption_pk, +// clone_signature_secret_key(&node1_profile_identity_sk), +// node1_identity_name.clone().as_str(), +// node1_profile_name.clone().as_str(), +// agent, +// ) +// .await; +// } +// // Send message (APICreateFilesInboxWithSymmetricKey) from Device subidentity to Node 1 +// { +// eprintln!("\n\n### Sending message (APICreateFilesInboxWithSymmetricKey) from profile subidentity to node 1\n\n"); + +// let message_content = aes_encryption_key_to_string(symmetrical_sk); +// let msg = ShinkaiMessageBuilder::create_files_inbox_with_sym_key( +// node1_profile_encryption_sk.clone(), +// clone_signature_secret_key(&node1_profile_identity_sk), +// node1_encryption_pk, +// "job::test::false".to_string(), +// message_content.clone(), +// node1_profile_name.to_string(), +// node1_identity_name.to_string(), +// node1_identity_name.to_string(), +// ) +// .unwrap(); + +// let (res_sender, res_receiver) = async_channel::bounded(1); +// node1_commands_sender +// .send(NodeCommand::APICreateFilesInboxWithSymmetricKey { msg, res: res_sender }) +// .await +// .unwrap(); +// let _ = res_receiver.recv().await.unwrap().expect("Failed to receive messages"); +// } +// { +// // Initialize local PDF parser +// ShinkaiTestingFramework::initialize_pdfium().await; + +// // Create Folder +// let payload = APIVecFsCreateFolder { +// path: "/".to_string(), +// folder_name: "test_folder".to_string(), +// }; + +// let msg = generate_message_with_payload( +// serde_json::to_string(&payload).unwrap(), +// MessageSchemaType::VecFsCreateFolder, +// node1_profile_encryption_sk.clone(), +// clone_signature_secret_key(&node1_profile_identity_sk), +// node1_encryption_pk, +// node1_identity_name.as_str(), +// node1_profile_name.as_str(), +// node1_identity_name.as_str(), +// ); + +// // Prepare the response channel +// let (res_sender, res_receiver) = async_channel::bounded(1); + +// // Send the command +// node1_commands_sender +// .send(NodeCommand::APIVecFSCreateFolder { msg, res: res_sender }) +// .await +// .unwrap(); +// let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); +// eprintln!("resp: {:?}", resp); +// } +// { +// // Create Folder +// let payload = APIVecFsCreateFolder { +// path: "/".to_string(), +// folder_name: "test_folder2".to_string(), +// }; + +// let msg = generate_message_with_payload( +// serde_json::to_string(&payload).unwrap(), +// MessageSchemaType::VecFsCreateFolder, +// node1_profile_encryption_sk.clone(), +// clone_signature_secret_key(&node1_profile_identity_sk), +// node1_encryption_pk, +// node1_identity_name.as_str(), +// node1_profile_name.as_str(), +// node1_identity_name.as_str(), +// ); + +// // Prepare the response channel +// let (res_sender, res_receiver) = async_channel::bounded(1); + +// // Send the command +// node1_commands_sender +// .send(NodeCommand::APIVecFSCreateFolder { msg, res: res_sender }) +// .await +// .unwrap(); +// let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); +// eprintln!("resp: {:?}", resp); +// } +// { +// // Upload .vrkai file to inbox +// // Prepare the file to be read +// let filename = "../../files/shinkai_intro.vrkai"; +// let file_path = Path::new(filename); + +// // Read the file into a buffer +// let file_data = std::fs::read(file_path).map_err(|_| VRError::FailedPDFParsing).unwrap(); + +// // Encrypt the file using Aes256Gcm +// let cipher = Aes256Gcm::new(GenericArray::from_slice(&symmetrical_sk)); +// let nonce = GenericArray::from_slice(&[0u8; 12]); +// let nonce_slice = nonce.as_slice(); +// let nonce_str = aes_nonce_to_hex_string(nonce_slice); +// let ciphertext = cipher.encrypt(nonce, file_data.as_ref()).expect("encryption failure!"); + +// // Prepare the response channel +// let (res_sender, res_receiver) = async_channel::bounded(1); + +// // Send the command +// node1_commands_sender +// .send(NodeCommand::APIAddFileToInboxWithSymmetricKey { +// filename: filename.to_string(), +// file: ciphertext, +// public_key: hash_of_aes_encryption_key_hex(symmetrical_sk), +// encrypted_nonce: nonce_str, +// res: res_sender, +// }) +// .await +// .unwrap(); + +// // Receive the response +// let _ = res_receiver.recv().await.unwrap().expect("Failed to receive response"); +// } +// { +// // Convert File and Save to Folder +// let payload = APIConvertFilesAndSaveToFolder { +// path: "/test_folder".to_string(), +// file_inbox: hash_of_aes_encryption_key_hex(symmetrical_sk), +// file_datetime: Some(Utc.with_ymd_and_hms(2024, 2, 1, 0, 0, 0).unwrap()), +// }; + +// let msg = generate_message_with_payload( +// serde_json::to_string(&payload).unwrap(), +// MessageSchemaType::ConvertFilesAndSaveToFolder, +// node1_profile_encryption_sk.clone(), +// clone_signature_secret_key(&node1_profile_identity_sk), +// node1_encryption_pk, +// node1_identity_name.as_str(), +// node1_profile_name.as_str(), +// node1_identity_name.as_str(), +// ); + +// // Prepare the response channel +// let (res_sender, res_receiver) = async_channel::bounded(1); + +// // Send the command +// node1_commands_sender +// .send(NodeCommand::APIConvertFilesAndSaveToFolder { msg, res: res_sender }) +// .await +// .unwrap(); +// let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); +// eprintln!("resp: {:?}", resp); +// } +// let mut retrieved_fs_json = String::new(); +// { +// // Recover file from path using APIVecFSRetrievePathSimplifiedJson +// let payload = APIVecFsRetrievePathSimplifiedJson { +// path: "/test_folder/shinkai_intro".to_string(), +// }; + +// let msg = generate_message_with_payload( +// serde_json::to_string(&payload).unwrap(), +// MessageSchemaType::VecFsRetrievePathSimplifiedJson, +// node1_profile_encryption_sk.clone(), +// clone_signature_secret_key(&node1_profile_identity_sk), +// node1_encryption_pk, +// node1_identity_name.as_str(), +// node1_profile_name.as_str(), +// node1_identity_name.as_str(), +// ); + +// // Prepare the response channel +// let (res_sender, res_receiver) = async_channel::bounded(1); + +// // Send the command +// node1_commands_sender +// .send(NodeCommand::APIVecFSRetrievePathSimplifiedJson { msg, res: res_sender }) +// .await +// .unwrap(); +// let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); +// // eprintln!("resp for current file system files: {}", resp); + +// // Assuming `resp` is now a serde_json::Value +// let resp_json = serde_json::to_string(&resp).expect("Failed to convert response to string"); +// // eprintln!("resp for current file system files: {}", resp_json); + +// // TODO: convert to json and then compare +// let expected_path = "/test_folder/shinkai_intro"; +// assert!( +// resp_json.contains(expected_path), +// "Response does not contain the expected file path: {}", +// expected_path +// ); +// retrieved_fs_json = resp_json; +// } +// { +// // Upload .pdf file to inbox +// // Prepare the file to be read +// let filename = "../../files/shinkai_intro.pdf"; +// let file_path = Path::new(filename); + +// // Read the file into a buffer +// let file_data = std::fs::read(file_path).map_err(|_| VRError::FailedPDFParsing).unwrap(); + +// // Encrypt the file using Aes256Gcm +// let cipher = Aes256Gcm::new(GenericArray::from_slice(&symmetrical_sk)); +// let nonce = GenericArray::from_slice(&[0u8; 12]); +// let nonce_slice = nonce.as_slice(); +// let nonce_str = aes_nonce_to_hex_string(nonce_slice); +// let ciphertext = cipher.encrypt(nonce, file_data.as_ref()).expect("encryption failure!"); + +// // Prepare the response channel +// let (res_sender, res_receiver) = async_channel::bounded(1); + +// // Send the command +// node1_commands_sender +// .send(NodeCommand::APIAddFileToInboxWithSymmetricKey { +// filename: filename.to_string(), +// file: ciphertext, +// public_key: hash_of_aes_encryption_key_hex(symmetrical_sk), +// encrypted_nonce: nonce_str, +// res: res_sender, +// }) +// .await +// .unwrap(); + +// // Receive the response +// let _ = res_receiver.recv().await.unwrap().expect("Failed to receive response"); +// } +// { +// // Convert File and Save to Folder +// let payload = APIConvertFilesAndSaveToFolder { +// path: "/test_folder".to_string(), +// file_inbox: hash_of_aes_encryption_key_hex(symmetrical_sk), +// file_datetime: Some(Utc.with_ymd_and_hms(2024, 2, 1, 0, 0, 0).unwrap()), +// }; + +// let msg = generate_message_with_payload( +// serde_json::to_string(&payload).unwrap(), +// MessageSchemaType::ConvertFilesAndSaveToFolder, +// node1_profile_encryption_sk.clone(), +// clone_signature_secret_key(&node1_profile_identity_sk), +// node1_encryption_pk, +// node1_identity_name.as_str(), +// node1_profile_name.as_str(), +// node1_identity_name.as_str(), +// ); + +// // Prepare the response channel +// let (res_sender, res_receiver) = async_channel::bounded(1); + +// // Send the command +// node1_commands_sender +// .send(NodeCommand::APIConvertFilesAndSaveToFolder { msg, res: res_sender }) +// .await +// .unwrap(); +// let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); +// eprintln!("resp: {:?}", resp); +// } +// { +// // Recover file from path using APIVecFSRetrievePathSimplifiedJson +// let payload = APIVecFsRetrievePathSimplifiedJson { +// path: "/test_folder/shinkai_intro".to_string(), +// }; + +// let msg = generate_message_with_payload( +// serde_json::to_string(&payload).unwrap(), +// MessageSchemaType::VecFsRetrievePathSimplifiedJson, +// node1_profile_encryption_sk.clone(), +// clone_signature_secret_key(&node1_profile_identity_sk), +// node1_encryption_pk, +// node1_identity_name.as_str(), +// node1_profile_name.as_str(), +// node1_identity_name.as_str(), +// ); + +// // Prepare the response channel +// let (res_sender, res_receiver) = async_channel::bounded(1); + +// // Send the command +// node1_commands_sender +// .send(NodeCommand::APIVecFSRetrievePathSimplifiedJson { msg, res: res_sender }) +// .await +// .unwrap(); +// let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); +// eprintln!("resp for current file system files: {:?}", resp); + +// // Convert `resp` from serde_json::Value to String for comparison +// let resp_json = serde_json::to_string(&resp).expect("Failed to convert response to string"); + +// let expected_path = "/test_folder/shinkai_intro"; +// assert!( +// resp_json.contains(expected_path), +// "Response does not contain the expected file path: {}", +// expected_path +// ); +// // Assert that after updating the fs item with a new VR generated from the PDF (overwriting the one from the .vrkai), +// // the filesystem json is different (because different timestamps/id on the item). +// assert_ne!(resp_json, retrieved_fs_json); +// } +// { +// // Retrieve source file +// let payload = APIVecFsRetrieveSourceFile { +// path: "/test_folder/shinkai_intro".to_string(), +// }; + +// let api_v2_key = std::env::var("API_V2_KEY").unwrap_or_else(|_| "SUPER_SECRET".to_string()); + +// // Prepare the response channel +// let (res_sender, res_receiver) = async_channel::bounded(1); + +// // Send the command +// node1_commands_sender +// .send(NodeCommand::V2ApiRetrieveSourceFile { +// bearer: api_v2_key, +// payload, +// res: res_sender, +// }) +// .await +// .unwrap(); +// let resp_base64 = res_receiver.recv().await.unwrap().expect("Failed to receive response"); + +// // Compare the response with the original file +// let filename = "../../files/shinkai_intro.pdf"; +// let file_path = Path::new(filename); +// let file_data = std::fs::read(file_path).map_err(|_| VRError::FailedPDFParsing).unwrap(); + +// let decoded_content = base64::engine::general_purpose::STANDARD +// .decode(resp_base64.as_bytes()) +// .expect("Failed to decode base64"); +// assert_eq!(file_data, decoded_content); +// } + +// { +// // Copy Item (we required creating a new folder to copy the item to) +// { +// // Create Folder +// let payload = APIVecFsCreateFolder { +// path: "/".to_string(), +// folder_name: "test_folder3".to_string(), +// }; + +// let msg = generate_message_with_payload( +// serde_json::to_string(&payload).unwrap(), +// MessageSchemaType::VecFsCreateFolder, +// node1_profile_encryption_sk.clone(), +// clone_signature_secret_key(&node1_profile_identity_sk), +// node1_encryption_pk, +// node1_identity_name.as_str(), +// node1_profile_name.as_str(), +// node1_identity_name.as_str(), +// ); + +// // Prepare the response channel +// let (res_sender, res_receiver) = async_channel::bounded(1); + +// // Send the command +// node1_commands_sender +// .send(NodeCommand::APIVecFSCreateFolder { msg, res: res_sender }) +// .await +// .unwrap(); +// let _ = res_receiver.recv().await.unwrap().expect("Failed to receive response"); +// } +// // Copy item +// let payload = APIVecFsCopyItem { +// origin_path: "/test_folder/shinkai_intro".to_string(), +// destination_path: "/test_folder3".to_string(), +// }; + +// let msg = generate_message_with_payload( +// serde_json::to_string(&payload).unwrap(), +// MessageSchemaType::VecFsCopyItem, +// node1_profile_encryption_sk.clone(), +// clone_signature_secret_key(&node1_profile_identity_sk), +// node1_encryption_pk, +// node1_identity_name.as_str(), +// node1_profile_name.as_str(), +// node1_identity_name.as_str(), +// ); + +// // Prepare the response channel +// let (res_sender, res_receiver) = async_channel::bounded(1); + +// // Send the command +// node1_commands_sender +// .send(NodeCommand::APIVecFSCopyItem { msg, res: res_sender }) +// .await +// .unwrap(); +// let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); +// assert!( +// resp.contains("Item copied successfully to /test_folder3"), +// "Response does not contain the expected file path: /test_folder3/shinkai_intro" +// ); +// } +// { +// // Move item +// let payload = APIVecFsMoveItem { +// origin_path: "/test_folder3/shinkai_intro".to_string(), +// destination_path: "/test_folder2".to_string(), +// }; + +// let msg = generate_message_with_payload( +// serde_json::to_string(&payload).unwrap(), +// MessageSchemaType::VecFsMoveItem, // Assuming you have a corresponding schema type for moving items +// node1_profile_encryption_sk.clone(), +// clone_signature_secret_key(&node1_profile_identity_sk), +// node1_encryption_pk, +// node1_identity_name.as_str(), +// node1_profile_name.as_str(), +// node1_identity_name.as_str(), +// ); + +// // Prepare the response channel +// let (res_sender, res_receiver) = async_channel::bounded(1); + +// // Send the command +// node1_commands_sender +// .send(NodeCommand::APIVecFSMoveItem { msg, res: res_sender }) // Assuming you have a corresponding NodeCommand for moving items +// .await +// .unwrap(); +// let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); +// eprintln!("resp: {:?}", resp); +// assert!( +// resp.contains("Item moved successfully to /test_folder"), +// "Response does not contain the expected file path: /test_folder" +// ); +// } +// { +// // Move Folder +// let payload = APIVecFsMoveFolder { +// origin_path: "/test_folder".to_string(), +// destination_path: "/test_folder2".to_string(), +// }; + +// let msg = generate_message_with_payload( +// serde_json::to_string(&payload).unwrap(), +// MessageSchemaType::VecFsMoveFolder, +// node1_profile_encryption_sk.clone(), +// clone_signature_secret_key(&node1_profile_identity_sk), +// node1_encryption_pk, +// node1_identity_name.as_str(), +// node1_profile_name.as_str(), +// node1_identity_name.as_str(), +// ); + +// // Prepare the response channel +// let (res_sender, res_receiver) = async_channel::bounded(1); + +// // Send the command +// node1_commands_sender +// .send(NodeCommand::APIVecFSMoveFolder { msg, res: res_sender }) +// .await +// .unwrap(); +// let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); +// eprintln!("resp: {:?}", resp); +// } +// { +// // Recover file from path using APIVecFSRetrievePathSimplifiedJson +// let payload = APIVecFsRetrievePathSimplifiedJson { path: "/".to_string() }; + +// let msg = generate_message_with_payload( +// serde_json::to_string(&payload).unwrap(), +// MessageSchemaType::VecFsRetrievePathSimplifiedJson, +// node1_profile_encryption_sk.clone(), +// clone_signature_secret_key(&node1_profile_identity_sk), +// node1_encryption_pk, +// node1_identity_name.as_str(), +// node1_profile_name.as_str(), +// node1_identity_name.as_str(), +// ); + +// // Prepare the response channel +// let (res_sender, res_receiver) = async_channel::bounded(1); + +// // Send the command +// node1_commands_sender +// .send(NodeCommand::APIVecFSRetrievePathSimplifiedJson { msg, res: res_sender }) +// .await +// .unwrap(); +// let parsed_resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); +// // eprintln!("resp for current file system files: {:?}", parsed_resp); + +// /* +// / +// ├── test_folder2 +// │ ├── test_folder +// │ │ └── shinkai_intro +// │ └── shinkai_intro +// └── test_folder3 +// */ + +// // Assert the root contains 'test_folder2' and 'test_folder3' +// assert!( +// parsed_resp["child_folders"] +// .as_array() +// .unwrap() +// .iter() +// .any(|folder| folder["name"] == "test_folder2"), +// "test_folder2 is missing" +// ); +// assert!( +// parsed_resp["child_folders"] +// .as_array() +// .unwrap() +// .iter() +// .any(|folder| folder["name"] == "test_folder3"), +// "test_folder3 is missing" +// ); + +// // Assert 'test_folder2' contains 'test_folder' and 'shinkai_intro' +// let test_folder2 = parsed_resp["child_folders"] +// .as_array() +// .unwrap() +// .iter() +// .find(|folder| folder["name"] == "test_folder2") +// .expect("test_folder2 not found"); +// assert!( +// test_folder2["child_folders"] +// .as_array() +// .unwrap() +// .iter() +// .any(|folder| folder["name"] == "test_folder"), +// "test_folder inside test_folder2 is missing" +// ); +// assert!( +// test_folder2["child_items"] +// .as_array() +// .unwrap() +// .iter() +// .any(|item| item["name"] == "shinkai_intro"), +// "shinkai_intro directly inside test_folder2 is missing" +// ); + +// // Assert 'test_folder' inside 'test_folder2' contains 'shinkai_intro' +// let test_folder_inside_test_folder2 = test_folder2["child_folders"] +// .as_array() +// .unwrap() +// .iter() +// .find(|folder| folder["name"] == "test_folder") +// .expect("test_folder inside test_folder2 not found"); +// assert!( +// test_folder_inside_test_folder2["child_items"] +// .as_array() +// .unwrap() +// .iter() +// .any(|item| item["name"] == "shinkai_intro"), +// "shinkai_intro inside test_folder inside test_folder2 is missing" +// ); +// } +// { +// // Do deep search +// let payload = APIVecFsRetrieveVectorSearchSimplifiedJson { +// search: "who wrote Shinkai?".to_string(), +// path: Some("/test_folder2".to_string()), +// max_results: Some(10), +// max_files_to_scan: Some(100), +// }; + +// let msg = generate_message_with_payload( +// serde_json::to_string(&payload).unwrap(), +// MessageSchemaType::VecFsRetrieveVectorSearchSimplifiedJson, +// node1_profile_encryption_sk.clone(), +// clone_signature_secret_key(&node1_profile_identity_sk), +// node1_encryption_pk, +// node1_identity_name.as_str(), +// node1_profile_name.as_str(), +// node1_identity_name.as_str(), +// ); + +// // Prepare the response channel +// let (res_sender, res_receiver) = async_channel::bounded(1); + +// // Send the command +// node1_commands_sender +// .send(NodeCommand::APIVecFSRetrieveVectorSearchSimplifiedJson { msg, res: res_sender }) +// .await +// .unwrap(); +// let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); +// for r in &resp { +// eprintln!("\n\nSearch result: {:?}", r); +// } + +// let check_first = &resp[0].0 == &"Shinkai Network Manifesto (Early Preview)".to_string() +// && (&resp[0].1 +// == &vec![ +// "test_folder2".to_string(), +// "test_folder".to_string(), +// "shinkai_intro".to_string(), +// ] +// || &resp[0].1 == &vec!["test_folder2".to_string(), "shinkai_intro".to_string()]); + +// let check_second = &resp[1].0 == &"Shinkai Network Manifesto (Early Preview)".to_string() +// && (&resp[1].1 +// == &vec![ +// "test_folder2".to_string(), +// "test_folder".to_string(), +// "shinkai_intro".to_string(), +// ] +// || &resp[1].1 == &vec!["test_folder2".to_string(), "shinkai_intro".to_string()]); + +// assert!(!resp.is_empty(), "Response is empty."); +// assert!(check_first && check_second); +// } +// { +// // Do file search +// let payload = APIVecFsSearchItems { +// search: "shinkai".to_string(), +// path: Some("/".to_string()), +// max_results: Some(10), +// max_files_to_scan: Some(100), +// }; + +// let msg = generate_message_with_payload( +// serde_json::to_string(&payload).unwrap(), +// MessageSchemaType::VecFsSearchItems, +// node1_profile_encryption_sk.clone(), +// clone_signature_secret_key(&node1_profile_identity_sk), +// node1_encryption_pk, +// node1_identity_name.as_str(), +// node1_profile_name.as_str(), +// node1_identity_name.as_str(), +// ); + +// // Prepare the response channel +// let (res_sender, res_receiver) = async_channel::bounded(1); + +// // Send the command +// node1_commands_sender +// .send(NodeCommand::APIVecFSSearchItems { msg, res: res_sender }) +// .await +// .unwrap(); +// let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); +// eprintln!("resp seach items: {:?}", resp); +// assert_eq!(resp.len(), 2, "Expected 2 search results, but got {}", resp.len()); +// assert!( +// resp.contains(&"/test_folder2/test_folder/shinkai_intro".to_string()), +// "Response does not contain the expected file path: /test_folder2/test_folder/shinkai_intro" +// ); +// assert!( +// resp.contains(&"/test_folder2/shinkai_intro".to_string()), +// "Response does not contain the expected file path: /test_folder2/shinkai_intro" +// ); +// } +// { +// // Remove file +// let payload = APIVecFsDeleteItem { +// path: "/test_folder2/test_folder/shinkai_intro".to_string(), +// }; + +// let msg = generate_message_with_payload( +// serde_json::to_string(&payload).unwrap(), +// MessageSchemaType::VecFsDeleteItem, +// node1_profile_encryption_sk.clone(), +// clone_signature_secret_key(&node1_profile_identity_sk), +// node1_encryption_pk, +// node1_identity_name.as_str(), +// node1_profile_name.as_str(), +// node1_identity_name.as_str(), +// ); + +// // Prepare the response channel +// let (res_sender, res_receiver) = async_channel::bounded(1); + +// // Send the command +// node1_commands_sender +// .send(NodeCommand::APIVecFSDeleteItem { msg, res: res_sender }) +// .await +// .unwrap(); +// let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); +// eprintln!("resp seach items delete item: {:?}", resp); +// } +// { +// // remove folder +// let payload = APIVecFsDeleteFolder { +// path: "/test_folder2/test_folder".to_string(), +// }; + +// let msg = generate_message_with_payload( +// serde_json::to_string(&payload).unwrap(), +// MessageSchemaType::VecFsDeleteFolder, +// node1_profile_encryption_sk.clone(), +// clone_signature_secret_key(&node1_profile_identity_sk), +// node1_encryption_pk, +// node1_identity_name.as_str(), +// node1_profile_name.as_str(), +// node1_identity_name.as_str(), +// ); + +// // Prepare the response channel +// let (res_sender, res_receiver) = async_channel::bounded(1); + +// // Send the command +// node1_commands_sender +// .send(NodeCommand::APIVecFSDeleteFolder { msg, res: res_sender }) +// .await +// .unwrap(); +// let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); +// eprintln!("resp seach items delete folder: {:?}", resp); +// } +// { +// let payload = APIVecFsRetrievePathSimplifiedJson { path: "/".to_string() }; + +// let msg = generate_message_with_payload( +// serde_json::to_string(&payload).unwrap(), +// MessageSchemaType::VecFsRetrievePathSimplifiedJson, +// node1_profile_encryption_sk.clone(), +// clone_signature_secret_key(&node1_profile_identity_sk), +// node1_encryption_pk, +// node1_identity_name.as_str(), +// node1_profile_name.as_str(), +// node1_identity_name.as_str(), +// ); + +// // Prepare the response channel +// let (res_sender, res_receiver) = async_channel::bounded(1); + +// // Send the command +// node1_commands_sender +// .send(NodeCommand::APIVecFSRetrievePathSimplifiedJson { msg, res: res_sender }) +// .await +// .unwrap(); +// let parsed_resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); + +// // Assert root contains 'test_folder2' and 'test_folder3' +// let root_folders = parsed_resp["child_folders"] +// .as_array() +// .expect("Expected child_folders to be an array"); +// assert_eq!( +// root_folders.len(), +// 2, +// "Expected 2 root folders, found {}", +// root_folders.len() +// ); + +// let test_folder2 = root_folders +// .iter() +// .find(|&f| f["name"] == "test_folder2") +// .expect("test_folder2 not found"); +// let test_folder3 = root_folders +// .iter() +// .find(|&f| f["name"] == "test_folder3") +// .expect("test_folder3 not found"); + +// // Assert 'test_folder2' contains 'shinkai_intro' +// let test_folder2_items = test_folder2["child_items"] +// .as_array() +// .expect("Expected child_items to be an array in test_folder2"); +// assert_eq!( +// test_folder2_items.len(), +// 1, +// "Expected 1 item in test_folder2, found {}", +// test_folder2_items.len() +// ); +// assert_eq!( +// test_folder2_items[0]["name"], "shinkai_intro", +// "Expected item 'shinkai_intro' in test_folder2" +// ); + +// // Assert 'test_folder3' is empty +// let test_folder3_folders = test_folder3["child_folders"] +// .as_array() +// .expect("Expected child_folders to be an array in test_folder3"); +// let test_folder3_items = test_folder3["child_items"] +// .as_array() +// .expect("Expected child_items to be an array in test_folder3"); +// assert!(test_folder3_folders.is_empty(), "Expected no folders in test_folder3"); +// assert!(test_folder3_items.is_empty(), "Expected no items in test_folder3"); +// } +// node1_abort_handler.abort(); +// }) +// }); +// } diff --git a/shinkai-bin/shinkai-node/tests/it/vector_fs_tests.rs b/shinkai-bin/shinkai-node/tests/it/vector_fs_tests.rs deleted file mode 100644 index 1bd5dc873..000000000 --- a/shinkai-bin/shinkai-node/tests/it/vector_fs_tests.rs +++ /dev/null @@ -1,1765 +0,0 @@ -use aes_gcm::aead::generic_array::GenericArray; -use aes_gcm::aead::Aead; -use aes_gcm::{Aes256Gcm, KeyInit}; -use chrono::{TimeZone, Utc}; -use mockito::Server; -use shinkai_http_api::node_commands::NodeCommand; -use shinkai_message_primitives::schemas::llm_providers::serialized_llm_provider::{ - LLMProviderInterface, Ollama, SerializedLLMProvider, -}; -use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; -use shinkai_message_primitives::shinkai_message::shinkai_message_schemas::{ - APIConvertFilesAndSaveToFolder, APIVecFsCreateFolder, APIVecFsRetrievePathSimplifiedJson, - APIVecFsRetrieveVectorSearchSimplifiedJson, MessageSchemaType, -}; -use shinkai_message_primitives::shinkai_utils::encryption::clone_static_secret_key; -use shinkai_message_primitives::shinkai_utils::file_encryption::{ - aes_encryption_key_to_string, aes_nonce_to_hex_string, hash_of_aes_encryption_key_hex, - unsafe_deterministic_aes_encryption_key, -}; -use shinkai_message_primitives::shinkai_utils::shinkai_message_builder::ShinkaiMessageBuilder; -use shinkai_message_primitives::shinkai_utils::signatures::clone_signature_secret_key; -use shinkai_node::llm_provider::execution::user_message_parser::ParsedUserMessage; -use shinkai_sqlite::SqliteManager; -use shinkai_vector_fs::vector_fs; -use shinkai_vector_fs::vector_fs::vector_fs::VectorFS; -use shinkai_vector_fs::vector_fs::vector_fs_permissions::{ReadPermission, WritePermission}; -use shinkai_vector_resources::data_tags::DataTag; -use shinkai_vector_resources::embedding_generator::{EmbeddingGenerator, RemoteEmbeddingGenerator}; -use shinkai_vector_resources::file_parser::file_parser::ShinkaiFileParser; -use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; -use shinkai_vector_resources::resource_errors::VRError; -use shinkai_vector_resources::source::{DistributionInfo, SourceFile, SourceFileMap, SourceFileType}; -use shinkai_vector_resources::vector_resource::{simplified_fs_types::*, VRPack}; -use shinkai_vector_resources::vector_resource::{ - BaseVectorResource, DocumentVectorResource, VRKai, VRPath, VRSourceReference, VectorResourceCore, - VectorResourceSearch, -}; -use std::collections::HashMap; -use std::fs; -use std::path::Path; -use std::sync::Arc; -use tokio::runtime::Runtime; -use tokio::sync::RwLock; - -use crate::it::utils::node_test_api::{ - api_initial_registration_with_no_code_for_device, api_llm_provider_registration, -}; -use crate::it::utils::shinkai_testing_framework::ShinkaiTestingFramework; -use crate::it::vector_fs_api_tests::generate_message_with_payload; - -use super::utils; -use super::utils::db_handlers::setup_node_storage_path; -use super::utils::test_boilerplate::run_test_one_node_network; - -fn setup() { - let path = Path::new("db_tests/"); - let _ = fs::remove_dir_all(path); - - setup_node_storage_path(); -} - -fn default_test_profile() -> ShinkaiName { - ShinkaiName::new("@@localhost.shinkai/profileName".to_string()).unwrap() -} - -fn node_name() -> ShinkaiName { - ShinkaiName::new("@@localhost.shinkai".to_string()).unwrap() -} - -async fn setup_default_vector_fs(db: Arc) -> VectorFS { - let generator = RemoteEmbeddingGenerator::new_default(); - let profile_list = vec![default_test_profile()]; - let supported_embedding_models = vec![EmbeddingModelType::OllamaTextEmbeddingsInference( - OllamaTextEmbeddingsInference::SnowflakeArcticEmbed_M, - )]; - - VectorFS::new(generator, supported_embedding_models, profile_list, db, node_name()) - .await - .unwrap() -} - -pub async fn get_shinkai_intro_doc_async( - generator: &RemoteEmbeddingGenerator, - data_tags: &Vec, -) -> Result<(DocumentVectorResource, SourceFileMap), VRError> { - // Initialize local PDF parser - ShinkaiTestingFramework::initialize_pdfium().await; - - // Read the pdf from file into a buffer - let source_file_name = "shinkai_intro.pdf"; - let buffer = std::fs::read(format!("../../files/{}", source_file_name)).map_err(|_| VRError::FailedPDFParsing)?; - - let desc = "An initial introduction to the Shinkai Network."; - let resource = ShinkaiFileParser::process_file_into_resource( - buffer.clone(), - generator, - "shinkai_intro.pdf".to_string(), - Some(desc.to_string()), - data_tags, - 500, - DistributionInfo::new_empty(), - ) - .await - .unwrap(); - - let file_type = SourceFileType::detect_file_type(source_file_name).unwrap(); - let source_file = SourceFile::new_standard_source_file(source_file_name.to_string(), file_type, buffer, None); - let mut map = HashMap::new(); - map.insert(VRPath::root(), source_file); - - Ok((resource.as_document_resource_cloned().unwrap(), SourceFileMap::new(map))) -} - -pub fn get_shinkai_intro_doc(generator: &RemoteEmbeddingGenerator, data_tags: &Vec) -> DocumentVectorResource { - // Create a new Tokio runtime - let rt = Runtime::new().unwrap(); - - // Use block_on to run the async-based get_shinkai_intro_doc_async function - let (resource, _) = rt.block_on(get_shinkai_intro_doc_async(generator, data_tags)).unwrap(); - - resource -} - -// // Test to be used to re-generate the VRKai/VRPack file whenever breaking changes take place. -// #[tokio::test] -// async fn test_gen_vrkai() { -// setup(); -// let generator = RemoteEmbeddingGenerator::new_default(); -// let (doc_resource, source_file_map) = get_shinkai_intro_doc_async(&generator, &vec![]) -// .await -// .expect("Failed to get shinkai intro doc"); -// let resource = BaseVectorResource::Document(doc_resource); -// // With source file map -// // let vrkai = VRKai::new(resource, Some(source_file_map), None); -// // Without source file map -// let vrkai = VRKai::new(resource, None); -// let vrkai_bytes = vrkai.encode_as_bytes().expect("Failed to prepare VRKai bytes"); -// std::fs::write("../../files/shinkai_intro.vrkai", &vrkai_bytes).expect("Failed to write VRKai bytes to file"); - -// let mut vrpack = VRPack::new_empty("shinkai-intro"); -// vrpack.insert_vrkai(&vrkai, VRPath::root()); -// let vrpack_bytes = vrpack.encode_as_bytes().expect("Failed to prepare VRPack bytes"); -// std::fs::write("../../files/shinkai_intro.vrpack", &vrpack_bytes).expect("Failed to write VRPack bytes to file"); - -// // Read back and parse the VRKai file to verify it can be successfully decoded -// let vrkai_bytes_read = std::fs::read("../../files/shinkai_intro.vrkai").expect("Failed to read VRKai file"); -// let parsed_vrkai = VRKai::from_bytes(&vrkai_bytes_read).expect("Failed to decode VRKai"); -// assert_eq!( -// parsed_vrkai.encode_as_bytes().unwrap(), -// vrkai_bytes, -// "VRKai bytes mismatch after parsing" -// ); - -// // Read back and parse the VRPack file to verify it can be successfully decoded -// let vrpack_bytes_read = std::fs::read("../../files/shinkai_intro.vrpack").expect("Failed to read VRPack file"); -// let parsed_vrpack = VRPack::from_bytes(&vrpack_bytes_read).expect("Failed to decode VRPack"); -// assert_eq!( -// parsed_vrpack.encode_as_bytes().unwrap(), -// vrpack_bytes, -// "VRPack bytes mismatch after parsing" -// ); -// } - -#[tokio::test] -async fn test_vrkai_vrpack_vector_search() { - setup(); - let generator = RemoteEmbeddingGenerator::new_default(); - - // Read VRKai from file as utf8 string - let vrkai_str = std::fs::read_to_string("../../files/shinkai_intro.vrkai").expect("Failed to read VRKai from file"); - let vrkai = VRKai::from_base64(&vrkai_str).expect("Failed to decode VRKai from string"); - - // Read VRPack from file as utf8 string - let vrpack_bytes_read = std::fs::read("../../files/shinkai_intro.vrpack").expect("Failed to read VRPack file"); - let vrpack = VRPack::from_bytes(&vrpack_bytes_read).expect("Failed to decode VRPack"); - - // Perform vector search on VRKai - let query_string = "What is Shinkai?".to_string(); - let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); - let vrkai_search_results = vrkai.vector_search(query_embedding, 100); - - // Perform vector search on VRPack - let vrpack_search_results = vrpack - .dynamic_deep_vector_search(query_string, 100, 100, generator, vec![]) - .await - .unwrap(); - - // Validate search results are equal - assert_eq!(vrkai_search_results.len(), vrpack_search_results.len()); - for (vrkai_result, vrpack_result) in vrkai_search_results.iter().zip(vrpack_search_results.iter()) { - assert_eq!(vrkai_result.retrieval_path, vrpack_result.retrieval_path); - } -} - -#[tokio::test] -async fn test_vector_fs_initializes_new_profile_automatically() { - setup(); - let db = utils::db_handlers::setup_test_db(); - let db = Arc::new(db); - let vector_fs = setup_default_vector_fs(db.clone()).await; - - let fs_internals = vector_fs.get_profile_fs_internals_cloned(&default_test_profile()).await; - assert!(fs_internals.is_ok()) -} - -#[tokio::test] -async fn test_vector_fs_saving_reading() { - setup(); - let db = utils::db_handlers::setup_test_db(); - let db = Arc::new(db); - let generator = RemoteEmbeddingGenerator::new_default(); - let mut vector_fs = setup_default_vector_fs(db.clone()).await; - - let path = VRPath::new(); - let writer = vector_fs - .new_writer(default_test_profile(), path.clone(), default_test_profile()) - .await - .unwrap(); - let folder_name = "first_folder"; - vector_fs.create_new_folder(&writer, folder_name).await.unwrap(); - let writer = vector_fs - .new_writer( - default_test_profile(), - path.push_cloned(folder_name.to_string()), - default_test_profile(), - ) - .await - .unwrap(); - let folder_name_2 = "second_folder"; - vector_fs.create_new_folder(&writer, folder_name_2).await.unwrap(); - - // Validate new folder path points to an entry at all (not empty), then specifically a folder, and finally not to an item. - let folder_path = path.push_cloned(folder_name.to_string()); - assert!(vector_fs - .validate_path_points_to_entry(folder_path.clone(), &writer.profile) - .await - .is_ok()); - assert!(vector_fs - .validate_path_points_to_folder(folder_path.clone(), &writer.profile) - .await - .is_ok()); - assert!(vector_fs - .validate_path_points_to_item(folder_path.clone(), &writer.profile) - .await - .is_err()); - - // Create a Vector Resource and source file to be added into the VectorFS - let (doc_resource, source_file_map) = get_shinkai_intro_doc_async(&generator, &vec![]).await.unwrap(); - let resource = BaseVectorResource::Document(doc_resource); - let writer = vector_fs - .new_writer(default_test_profile(), folder_path.clone(), default_test_profile()) - .await - .unwrap(); - vector_fs - .save_vector_resource_in_folder(&writer, resource.clone(), Some(source_file_map.clone())) - .await - .unwrap(); - - // Validate new item path points to an entry at all (not empty), then specifically an item, and finally not to a folder. - let item_path = folder_path.push_cloned(resource.as_trait_object().name().to_string()); - assert!(vector_fs - .validate_path_points_to_entry(item_path.clone(), &writer.profile) - .await - .is_ok()); - assert!(vector_fs - .validate_path_points_to_item(item_path.clone(), &writer.profile) - .await - .is_ok()); - assert!(vector_fs - .validate_path_points_to_folder(item_path.clone(), &writer.profile) - .await - .is_err()); - - let internals = vector_fs - .get_profile_fs_internals_cloned(&default_test_profile()) - .await - .unwrap(); - // internals.fs_core_resource.print_all_nodes_exhaustive(None, true, false); - - // Sets the permission to private from default Whitelist (for later test cases) - let perm_writer = vector_fs - .new_writer(default_test_profile(), item_path.clone(), default_test_profile()) - .await - .unwrap(); - vector_fs - .set_path_permission(&perm_writer, ReadPermission::Private, WritePermission::Private) - .await - .unwrap(); - - // Retrieve the Vector Resource & Source File Map from the db - // Test both retrieve interfaces - let reader = vector_fs - .new_reader(default_test_profile(), item_path.clone(), default_test_profile()) - .await - .unwrap(); - let ret_vrkai = vector_fs.retrieve_vrkai(&reader).await.unwrap(); - let (ret_resource, ret_source_file_map) = (ret_vrkai.resource, ret_vrkai.sfm); - assert_eq!(ret_resource, resource); - assert_eq!(ret_source_file_map, Some(source_file_map.clone())); - - println!("Keywords: {:?}", ret_resource.as_trait_object().keywords()); - assert!(ret_resource.as_trait_object().keywords().keyword_list.len() > 0); - assert!(ret_resource.as_trait_object().keywords().keywords_embedding.is_some()); - - let reader = vector_fs - .new_reader(default_test_profile(), folder_path.clone(), default_test_profile()) - .await - .unwrap(); - let ret_vrkai = vector_fs - .retrieve_vrkai_in_folder(&reader, resource.as_trait_object().name().to_string()) - .await - .unwrap(); - let (ret_resource, ret_source_file_map) = (ret_vrkai.resource, ret_vrkai.sfm); - - assert_eq!(ret_resource, resource); - assert_eq!(ret_source_file_map, Some(source_file_map.clone())); - - // - // Vector Search Tests - // - - // First add a 2nd VR into the VecFS - let generator = RemoteEmbeddingGenerator::new_default(); - let mut doc = DocumentVectorResource::new_empty( - "3 Animal Facts", - Some("A bunch of facts about animals and wildlife"), - VRSourceReference::new_uri_ref("animalwildlife.com"), - true, - ); - doc.set_embedding_model_used(generator.model_type()); - doc.keywords_mut() - .set_keywords(vec!["animal".to_string(), "wild life".to_string()]); - doc.update_resource_embedding(&generator, None).await.unwrap(); - let fact1 = "Dogs are creatures with 4 legs that bark."; - let fact1_embedding = generator.generate_embedding_default(fact1).await.unwrap(); - let fact2 = "Camels are slow animals with large humps."; - let fact2_embedding = generator.generate_embedding_default(fact2).await.unwrap(); - let fact3 = "Seals swim in the ocean."; - let fact3_embedding = generator.generate_embedding_default(fact3).await.unwrap(); - doc.append_text_node(fact1, None, fact1_embedding.clone(), &vec![]) - .unwrap(); - doc.append_text_node(fact2, None, fact2_embedding.clone(), &vec![]) - .unwrap(); - doc.append_text_node(fact3, None, fact3_embedding.clone(), &vec![]) - .unwrap(); - - let writer = vector_fs - .new_writer(default_test_profile(), folder_path.clone(), default_test_profile()) - .await - .unwrap(); - let item = vector_fs - .save_vector_resource_in_folder( - &writer, - BaseVectorResource::Document(doc), - Some(source_file_map.clone()), - ) - .await - .unwrap(); - - // Sets the permission to Private from default Whitelist (for later test cases) - let perm_writer = vector_fs - .new_writer(default_test_profile(), item.path.clone(), default_test_profile()) - .await - .unwrap(); - vector_fs - .set_path_permission(&perm_writer, ReadPermission::Private, WritePermission::Private) - .await - .unwrap(); - - // Searching for FSItems - let reader = vector_fs - .new_reader(default_test_profile(), VRPath::root(), default_test_profile()) - .await - .unwrap(); - let query_string = "Who is building Shinkai?".to_string(); - println!("Query String: {}", query_string); - let query_embedding = vector_fs - .generate_query_embedding_using_reader(query_string, &reader) - .await - .unwrap(); - let res = vector_fs - .vector_search_fs_item(&reader, query_embedding, 100) - .await - .unwrap(); - assert_eq!(res[0].name(), "shinkai_intro"); - - vector_fs.print_profile_vector_fs_resource(reader.profile.clone()).await; - // Searching into the Vector Resources themselves in the VectorFS to acquire internal nodes - let reader = vector_fs - .new_reader(default_test_profile(), VRPath::root(), default_test_profile()) - .await - .unwrap(); - let query_string = "Who is building Shinkai?".to_string(); - println!("Query String: {}", query_string); - let query_embedding = vector_fs - .generate_query_embedding_using_reader(query_string.clone(), &reader) - .await - .unwrap(); - let res = vector_fs - .deep_vector_search(&reader, query_string.clone(), 100, 100, vec![]) - .await - .unwrap(); - assert_eq!( - "Shinkai Network Manifesto (Early Preview)", - res[0] - .resource_retrieved_node - .node - .get_text_content() - .unwrap() - .to_string() - ); - let res = vector_fs - .vector_search_vector_resource(&reader, query_embedding, 1) - .await - .unwrap(); - assert_eq!("shinkai_intro", res[0].as_trait_object().name()); - - // Animal facts search - let query_string = "What do you know about camels?".to_string(); - println!("Query String: {}", query_string); - let res = vector_fs - .deep_vector_search(&reader, query_string.clone(), 100, 100, vec![]) - .await - .unwrap(); - assert_eq!( - "Camels are slow animals with large humps.", - res[0] - .resource_retrieved_node - .node - .get_text_content() - .unwrap() - .to_string() - ); - - // Vector Search W/Full VR Retrieval - let query_string = "What are popular animals?".to_string(); - println!("Query String: {}", query_string); - let query_embedding = vector_fs - .generate_query_embedding_using_reader(query_string, &reader) - .await - .unwrap(); - let res = vector_fs - .vector_search_vector_resource(&reader, query_embedding, 100) - .await - .unwrap(); - assert_eq!("3 Animal Facts", res[0].as_trait_object().name()); - - let query_string = "Shinkai intro pdf".to_string(); - println!("Query String: {}", query_string); - let query_embedding = vector_fs - .generate_query_embedding_using_reader(query_string, &reader) - .await - .unwrap(); - let res = vector_fs - .vector_search_vector_resource(&reader, query_embedding, 100) - .await - .unwrap(); - assert_eq!("shinkai_intro", res[0].as_trait_object().name()); - - // Validate permissions checking in reader gen - let invalid_requester = - ShinkaiName::from_node_and_profile_names("alice".to_string(), "mainProfile".to_string()).unwrap(); - let reader = vector_fs - .new_reader(invalid_requester.clone(), VRPath::root(), default_test_profile()) - .await; - assert!(reader.is_err()); - - // Validate permissions checking in Vector Search - let writer = vector_fs - .new_writer(default_test_profile(), VRPath::root(), default_test_profile()) - .await - .unwrap(); - vector_fs - .set_path_permission(&writer, ReadPermission::Whitelist, WritePermission::Private) - .await - .unwrap(); - vector_fs - .set_whitelist_permission( - &writer, - invalid_requester.clone(), - shinkai_vector_fs::vector_fs::vector_fs_permissions::WhitelistPermission::Read, - ) - .await - .unwrap(); - - let reader = vector_fs - .new_reader(invalid_requester.clone(), VRPath::root(), default_test_profile()) - .await - .unwrap(); - let query_string = "Shinkai intro pdf".to_string(); - let query_embedding = vector_fs - .generate_query_embedding_using_reader(query_string, &reader) - .await - .unwrap(); - let res = vector_fs - .vector_search_vector_resource(&reader, query_embedding.clone(), 100) - .await - .unwrap(); - assert_eq!(res.len(), 0); - - // Now give permission to first folder and see if results return the VRHeader in it - let first_folder_path = VRPath::new().push_cloned(folder_name.to_string()); - let writer = vector_fs - .new_writer( - default_test_profile(), - first_folder_path.clone(), - default_test_profile(), - ) - .await - .unwrap(); - vector_fs - .set_path_permission(&writer, ReadPermission::Whitelist, WritePermission::Private) - .await - .unwrap(); - vector_fs - .set_whitelist_permission( - &writer, - invalid_requester.clone(), - shinkai_vector_fs::vector_fs::vector_fs_permissions::WhitelistPermission::Read, - ) - .await - .unwrap(); - - { - let internals = vector_fs - .get_profile_fs_internals_cloned(&default_test_profile()) - .await - .unwrap(); - - println!("FS permissions: {:?}", internals.permissions_index.fs_permissions); - } - - let reader = vector_fs - .new_reader( - invalid_requester.clone(), - first_folder_path.clone(), - default_test_profile(), - ) - .await - .unwrap(); - let res = vector_fs - .vector_search_vector_resource(&reader, query_embedding.clone(), 100) - .await - .unwrap(); - assert!(res.len() == 0); - let res = vector_fs - .vector_search_vr_header(&reader, query_embedding.clone(), 100) - .await - .unwrap(); - assert!(res.len() > 0); - - // Now give permission to the item in the folder and see that the resource is returned - let writer = vector_fs - .new_writer( - default_test_profile(), - first_folder_path.push_cloned("shinkai_intro".to_string()), - default_test_profile(), - ) - .await - .unwrap(); - vector_fs - .set_path_permission(&writer, ReadPermission::Whitelist, WritePermission::Private) - .await - .unwrap(); - vector_fs - .set_whitelist_permission( - &writer, - invalid_requester.clone(), - vector_fs::vector_fs_permissions::WhitelistPermission::Read, - ) - .await - .unwrap(); - let res = vector_fs - .vector_search_vector_resource(&reader, query_embedding.clone(), 100) - .await - .unwrap(); - assert!(!res.is_empty()); -} - -#[tokio::test] -async fn test_vector_fs_operations() { - setup(); - let db = utils::db_handlers::setup_test_db(); - let db = Arc::new(db); - let generator = RemoteEmbeddingGenerator::new_default(); - let mut vector_fs = setup_default_vector_fs(db.clone()).await; - - let writer = vector_fs - .new_writer(default_test_profile(), VRPath::root(), default_test_profile()) - .await - .unwrap(); - let folder_name = "first_folder"; - let first_folder_path = VRPath::root().push_cloned(folder_name.to_string()); - vector_fs.create_new_folder(&writer, folder_name).await.unwrap(); - - // Sets the permission to Private from default Whitelist (for later test cases) - let perm_writer = vector_fs - .new_writer( - default_test_profile(), - first_folder_path.clone(), - default_test_profile(), - ) - .await - .unwrap(); - vector_fs - .set_path_permission(&perm_writer, ReadPermission::Private, WritePermission::Private) - .await - .unwrap(); - - // Create a folder inside of first_folder - let writer = vector_fs - .new_writer( - default_test_profile(), - first_folder_path.clone(), - default_test_profile(), - ) - .await - .unwrap(); - let folder_name_2 = "second_folder"; - vector_fs.create_new_folder(&writer, folder_name_2).await.unwrap(); - let second_folder_path = first_folder_path.push_cloned(folder_name_2.to_string()); - - // Sets the permission to Private from default Whitelist (for later test cases) - let perm_writer = vector_fs - .new_writer( - default_test_profile(), - second_folder_path.clone(), - default_test_profile(), - ) - .await - .unwrap(); - vector_fs - .set_path_permission(&perm_writer, ReadPermission::Private, WritePermission::Private) - .await - .unwrap(); - - // Create a Vector Resource and source file to be added into the VectorFS - let (doc_resource, source_file_map) = get_shinkai_intro_doc_async(&generator, &vec![]).await.unwrap(); - let resource = BaseVectorResource::Document(doc_resource); - let resource_name = resource.as_trait_object().name(); - let resource_ref_string = resource.as_trait_object().reference_string(); - let resource_merkle_root = resource.as_trait_object().get_merkle_root(); - let resource_node_count = resource.as_document_resource_cloned().unwrap().node_count(); - let writer = vector_fs - .new_writer( - default_test_profile(), - first_folder_path.clone(), - default_test_profile(), - ) - .await - .unwrap(); - let first_folder_item = vector_fs - .save_vector_resource_in_folder(&writer, resource.clone(), Some(source_file_map.clone())) - .await - .unwrap(); - - // - // Copy Tests - // - - let writer = vector_fs - .new_writer(default_test_profile(), VRPath::root(), default_test_profile()) - .await - .unwrap(); - let new_root_folder_name = "new_root_folder".to_string(); - vector_fs - .create_new_folder(&writer, &new_root_folder_name) - .await - .unwrap(); - let new_root_folder_path = VRPath::root().push_cloned(new_root_folder_name.clone()); - - // Sets the permission to Private from default Whitelist (for later test cases) - let perm_writer = vector_fs - .new_writer( - default_test_profile(), - new_root_folder_path.clone(), - default_test_profile(), - ) - .await - .unwrap(); - vector_fs - .set_path_permission(&perm_writer, ReadPermission::Private, WritePermission::Private) - .await - .unwrap(); - - // Copy item from 1st folder into new root folder - let orig_writer = vector_fs - .new_writer( - default_test_profile(), - first_folder_item.path.clone(), - default_test_profile(), - ) - .await - .unwrap(); - let dest_reader = orig_writer - .new_reader_copied_data(new_root_folder_path.clone(), &mut vector_fs) - .await - .unwrap(); - vector_fs - .copy_item(&orig_writer, new_root_folder_path.clone()) - .await - .unwrap(); - let mut retrieved_vr = vector_fs - .retrieve_vector_resource_in_folder(&dest_reader, resource_name.to_string()) - .await - .unwrap(); - - assert_eq!(resource_name, retrieved_vr.as_trait_object().name()); - assert_eq!( - resource_node_count, - retrieved_vr.as_document_resource().unwrap().node_count() - ); - assert_eq!(resource_merkle_root, retrieved_vr.as_trait_object().get_merkle_root()); - assert_ne!(resource_ref_string, retrieved_vr.as_trait_object().reference_string()); - - vector_fs.print_profile_vector_fs_resource(default_test_profile()).await; - - // Copy from new root folder to 2nd folder inside of first folder - let root_folder_file_path = new_root_folder_path.push_cloned(resource_name.to_string()); - let orig_writer = vector_fs - .new_writer(default_test_profile(), root_folder_file_path, default_test_profile()) - .await - .unwrap(); - let dest_reader = orig_writer - .new_reader_copied_data(second_folder_path.clone(), &mut vector_fs) - .await - .unwrap(); - vector_fs - .copy_item(&orig_writer, second_folder_path.clone()) - .await - .unwrap(); - let mut retrieved_vr = vector_fs - .retrieve_vector_resource_in_folder(&dest_reader, resource_name.to_string()) - .await - .unwrap(); - - assert_eq!(resource_name, retrieved_vr.as_trait_object().name()); - assert_eq!( - resource_node_count, - retrieved_vr.as_document_resource().unwrap().node_count() - ); - assert_eq!(resource_merkle_root, retrieved_vr.as_trait_object().get_merkle_root()); - assert_ne!(resource_ref_string, retrieved_vr.as_trait_object().reference_string()); - - vector_fs.print_profile_vector_fs_resource(default_test_profile()).await; - - // Copy first folder as a whole into new root folder - let new_root_folder_first_folder_path = new_root_folder_path.push_cloned(folder_name.to_string()); - let orig_writer = vector_fs - .new_writer( - default_test_profile(), - first_folder_path.clone(), - default_test_profile(), - ) - .await - .unwrap(); - vector_fs - .copy_folder(&orig_writer, new_root_folder_path.clone()) - .await - .unwrap(); - let dest_reader = orig_writer - .new_reader_copied_data(new_root_folder_first_folder_path.clone(), &mut vector_fs) - .await - .unwrap(); - let mut retrieved_vr = vector_fs - .retrieve_vector_resource_in_folder(&dest_reader, resource_name.to_string()) - .await - .unwrap(); - - assert_eq!(resource_name, retrieved_vr.as_trait_object().name()); - assert_eq!( - resource_node_count, - retrieved_vr.as_document_resource().unwrap().node_count() - ); - assert_eq!(resource_merkle_root, retrieved_vr.as_trait_object().get_merkle_root()); - assert_ne!(resource_ref_string, retrieved_vr.as_trait_object().reference_string()); - - vector_fs.print_profile_vector_fs_resource(default_test_profile()).await; - - let node = vector_fs - ._retrieve_core_resource_node_at_path(dest_reader.path.clone(), &dest_reader.profile) - .await - .unwrap(); - println!( - "Folder keywords: {:?}", - node.node - .get_vector_resource_content() - .unwrap() - .as_trait_object() - .keywords() - ); - - // Copying into a folder which does not exist fails - let non_existent_folder_path = VRPath::root().push_cloned("non_existent_folder".to_string()); - let orig_writer = vector_fs - .new_writer( - default_test_profile(), - first_folder_path.clone(), - default_test_profile(), - ) - .await - .unwrap(); - let copy_result = vector_fs - .copy_folder(&orig_writer, non_existent_folder_path.clone()) - .await; - assert!(copy_result.is_err()); - - // - // Move/Deletion Tests For Items - // - - // Moving item from one folder to another means previous path is empty & file is in new location - let item_to_move_path = first_folder_path.push_cloned(resource_name.to_string()); - let destination_folder_path = second_folder_path.clone(); - let new_location_path = destination_folder_path.push_cloned(resource_name.to_string()); - let orig_writer = vector_fs - .new_writer( - default_test_profile(), - item_to_move_path.clone(), - default_test_profile(), - ) - .await - .unwrap(); - - let dest_writer = vector_fs - .new_writer( - default_test_profile(), - new_location_path.clone(), - default_test_profile(), - ) - .await - .unwrap(); - - // Validate item deletion works - vector_fs.delete_item(&dest_writer).await.unwrap(); - - let new_location_check = vector_fs - .validate_path_points_to_entry(new_location_path.clone(), &default_test_profile()) - .await - .is_err(); - assert!(new_location_check, "The item should now not exist."); - - // Validate item moving works - vector_fs - .move_item(&orig_writer, destination_folder_path.clone()) - .await - .unwrap(); - - let orig_location_check = vector_fs - .validate_path_points_to_entry(item_to_move_path.clone(), &default_test_profile()) - .await - .is_err(); - assert!( - orig_location_check, - "The item should no longer exist in the original location." - ); - - let new_location_check = vector_fs - .validate_path_points_to_entry(new_location_path.clone(), &default_test_profile()) - .await - .is_ok(); - assert!(new_location_check, "The item should now exist in the new location."); - - // - // Update VR description test - // - let writer = dest_writer.clone(); - let reader = dest_writer - .new_reader_copied_data(dest_writer.path.clone(), &mut vector_fs) - .await - .unwrap(); - - let retrieved_vr = vector_fs.retrieve_vector_resource(&reader).await.unwrap(); - let old_description = retrieved_vr.as_trait_object().description(); - - let new_description = "New description".to_string(); - vector_fs - .update_item_resource_description(&writer, new_description.to_string()) - .await - .unwrap(); - - let updated_retrieved_vr = vector_fs.retrieve_vector_resource(&reader).await.unwrap(); - - assert_ne!(old_description, updated_retrieved_vr.as_trait_object().description()); - assert_eq!( - new_description, - updated_retrieved_vr - .as_trait_object() - .description() - .unwrap() - .to_string() - ); - - // VRPack creation & unpacking into VecFS tests - // - - vector_fs.print_profile_vector_fs_resource(default_test_profile()).await; - - let reader = orig_writer - .new_reader_copied_data(VRPath::root(), &mut vector_fs) - .await - .unwrap(); - let vrpack = vector_fs.retrieve_vrpack(&reader).await.unwrap(); - - vrpack - .resource - .as_trait_object() - .print_all_nodes_exhaustive(None, true, false); - - let unpacked_kais = vrpack.unpack_all_vrkais().unwrap(); - - assert_eq!(unpacked_kais.len(), 4); - - // Now retrieve vrpack for non-root folder - let reader = orig_writer - .new_reader_copied_data( - VRPath::root().push_cloned("new_root_folder".to_string()), - &mut vector_fs, - ) - .await - .unwrap(); - - println!("\n\n\nVectorFS:"); - vector_fs.print_profile_vector_fs_resource(default_test_profile()).await; - - let vrpack = vector_fs.retrieve_vrpack(&reader).await.unwrap(); - - println!("\n\n\nVRPack:"); - vrpack.print_internal_structure(None); - - let unpacked_kais = vrpack.unpack_all_vrkais().unwrap(); - - assert_eq!(unpacked_kais.len(), 3); - - // Now testing unpacking back into the VectorFS - - let unpack_path = VRPath::root().push_cloned("unpacked".to_string()); - assert!(vector_fs - .validate_path_points_to_entry(unpack_path.clone(), &default_test_profile()) - .await - .is_err()); - - // Prepare a writer for the 'unpacked' folder - let unpack_writer = vector_fs - .new_writer(default_test_profile(), unpack_path.clone(), default_test_profile()) - .await - .unwrap(); - - // Unpack the VRPack into the 'unpacked' folder - vector_fs - .extract_vrpack_in_folder(&unpack_writer, vrpack.clone()) - .await - .unwrap(); - - // Verify the 'unpacked' folder now exists - assert!(vector_fs - .validate_path_points_to_folder(unpack_path.clone(), &unpack_writer.profile) - .await - .is_ok()); - - let unpack_writer = vector_fs - .new_writer( - default_test_profile().clone(), - unpack_path.clone(), - default_test_profile(), - ) - .await - .unwrap(); - let json = vector_fs.retrieve_fs_path_simplified_json(&reader).await.unwrap(); - let simplified_folder = SimplifiedFSEntry::from_json(&json).unwrap(); - - assert_eq!(simplified_folder.clone().as_folder().unwrap().child_items.len(), 1); - assert_eq!(simplified_folder.as_folder().unwrap().child_folders.len(), 1); - - vector_fs.print_profile_vector_fs_resource(default_test_profile()).await; - - // Compare original vrpack with new re-created vrpack - - let old_vrpack = vrpack.clone(); - let old_vrpack_contents = old_vrpack.unpack_all_vrkais().unwrap(); - - let reader = orig_writer - .new_reader_copied_data( - VRPath::from_string("/unpacked/new_root_folder").unwrap(), - &mut vector_fs, - ) - .await - .unwrap(); - let new_vrpack = vector_fs.retrieve_vrpack(&reader).await.unwrap(); - let new_vrpack_contents = new_vrpack.unpack_all_vrkais().unwrap(); - - println!("\n\nOld VRPack:"); - old_vrpack.print_internal_structure(None); - println!("\n\nNew VRPack:"); - new_vrpack.print_internal_structure(None); - - let mut old_vrpack_map = old_vrpack_contents - .into_iter() - .map(|(vrkai, path)| (path, vrkai)) - .collect::>(); - - for (new_vrkai, new_path) in new_vrpack_contents { - if let Some(old_vrkai) = old_vrpack_map.remove(&new_path) { - assert_eq!( - old_vrkai.resource.as_trait_object().reference_string(), - new_vrkai.resource.as_trait_object().reference_string(), - "Mismatch for path: {}", - new_path - ); - } else { - panic!("New path not found in old VRPack contents: {}", new_path); - } - } - - assert!( - old_vrpack_map.is_empty(), - "Not all old VRPack contents were found in new: {:?}", - old_vrpack_map.keys().collect::>() - ); - - // Cleanup after vrpack tests - let deletion_writer = unpack_writer - .new_writer_copied_data(VRPath::root().push_cloned("unpacked".to_string()), &mut vector_fs) - .await - .unwrap(); - vector_fs.delete_folder(&deletion_writer).await.unwrap(); - - // - // Move/Deletion Tests for Folders - // - - // Moving a folder from one location to another means the previous path is empty & the folder is in the new location - let folder_name = "new_root_folder".to_string(); - let folder_to_move_path = VRPath::root().push_cloned(folder_name.to_string()); - let destination_folder_path = second_folder_path.clone(); - let new_folder_location_path = destination_folder_path.push_cloned(folder_name.to_string()); - - let orig_folder_writer = vector_fs - .new_writer( - default_test_profile(), - folder_to_move_path.clone(), - default_test_profile(), - ) - .await - .unwrap(); - - // Validate folder moving works - - vector_fs - .move_folder(&orig_folder_writer, destination_folder_path.clone()) - .await - .unwrap(); - - // vector_fs.print_profile_vector_fs_resource(default_test_profile()); - - let orig_folder_location_check = vector_fs - .validate_path_points_to_entry(folder_to_move_path.clone(), &default_test_profile()) - .await - .is_err(); - assert!( - orig_folder_location_check, - "The folder should no longer exist in the original location." - ); - - let new_folder_location_check = vector_fs - .validate_path_points_to_entry(new_folder_location_path.clone(), &default_test_profile()) - .await - .is_ok(); - assert!( - new_folder_location_check, - "The folder should now exist in the new location." - ); - - // Validate folder deletion works - let folder_to_delete_writer = vector_fs - .new_writer( - default_test_profile(), - new_folder_location_path.clone(), - default_test_profile(), - ) - .await - .unwrap(); - - vector_fs.delete_folder(&folder_to_delete_writer).await.unwrap(); - - let folder_deletion_check = vector_fs - .validate_path_points_to_entry(new_folder_location_path.clone(), &default_test_profile()) - .await - .is_err(); - assert!(folder_deletion_check, "The folder should now not exist."); - - // - // Validate that for every folder/item, there is a matching path permission, and no more - // - let reader = orig_writer - .new_reader_copied_data(VRPath::root(), &mut vector_fs) - .await - .unwrap(); - - let fs_internals = vector_fs - .get_profile_fs_internals_cloned(&default_test_profile()) - .await - .unwrap(); - - println!("\n\n\nVectorFS:"); - fs_internals - .fs_core_resource - .print_all_nodes_exhaustive(None, true, false); - - let all_read_perms = vector_fs - .find_paths_with_read_permissions_as_hashmap(&reader, vec![ReadPermission::Public, ReadPermission::Private]) - .await - .unwrap(); - let all_write_perms = vector_fs - .find_paths_with_write_permissions_as_hashmap(&reader, vec![WritePermission::Private]) - .await - .unwrap(); - let read_perms_count = all_read_perms.len(); - let write_perms_count = all_write_perms.len(); - - let ret_nodes = fs_internals.fs_core_resource.retrieve_nodes_exhaustive_unordered(None); - let all_internals_paths = ret_nodes.iter().map(|p| p.retrieval_path.clone()); - let paths_count = all_internals_paths.len(); - - println!("All read read perms: {:?}", all_read_perms.keys()); - println!("All write write perms: {:?}", all_write_perms.keys()); - - for path in all_internals_paths { - println!("Path: {}", path); - assert_eq!(all_read_perms.contains_key(&path), true); - assert_eq!(all_write_perms.contains_key(&path), true); - } - for path in all_read_perms.keys() { - assert_eq!(all_write_perms.contains_key(&path), true); - } - for path in all_write_perms.keys() { - assert_eq!(all_read_perms.contains_key(&path), true); - } - assert_eq!(read_perms_count, paths_count); - assert_eq!(write_perms_count, paths_count); - - // - // Validate that after everything, in-memory state == fsdb state after reverting - // - let reader = orig_writer - .new_reader_copied_data(VRPath::root(), &mut vector_fs) - .await - .unwrap(); - let writer = orig_writer - .new_writer_copied_data(VRPath::root(), &mut vector_fs) - .await - .unwrap(); - let current_state = vector_fs.retrieve_fs_path_simplified_json(&reader).await.unwrap(); - vector_fs - .revert_internals_to_last_db_save(&writer.profile, &writer.profile) - .await - .unwrap(); - let new_state = vector_fs.retrieve_fs_path_simplified_json(&reader).await.unwrap(); - - assert_eq!(current_state, new_state); - - // Verify that - - // - // Verify Simplified FSEntry types parse properly - // - let reader = orig_writer - .new_reader_copied_data(VRPath::root(), &mut vector_fs) - .await - .unwrap(); - let root_json = vector_fs.retrieve_fs_path_simplified_json(&reader).await.unwrap(); - - let simplified_root = SimplifiedFSEntry::from_json(&root_json); - - assert!(simplified_root.is_ok()); - - let reader = orig_writer - .new_reader_copied_data( - VRPath::from_string("/first_folder/second_folder/").unwrap(), - &mut vector_fs, - ) - .await - .unwrap(); - let json = vector_fs.retrieve_fs_path_simplified_json(&reader).await.unwrap(); - // println!("\n\n folder: {:?}", json); - - let simplified_folder = SimplifiedFSEntry::from_json(&json); - assert!(simplified_folder.is_ok()); - - let reader = orig_writer - .new_reader_copied_data( - VRPath::from_string("/first_folder/second_folder/shinkai_intro").unwrap(), - &mut vector_fs, - ) - .await - .unwrap(); - let json = vector_fs.retrieve_fs_path_simplified_json(&reader).await.unwrap(); - // println!("\n\n item: {:?}", json); - - let simplified_folder = SimplifiedFSEntry::from_json(&json); - assert!(simplified_folder.is_ok()); -} - -#[tokio::test] -async fn test_folder_empty_check_reuse() { - setup(); - let db = utils::db_handlers::setup_test_db(); - let db = Arc::new(db); - let generator = RemoteEmbeddingGenerator::new_default(); - let vector_fs = setup_default_vector_fs(db.clone()).await; - - // Create a new folder that will be checked for emptiness, then filled - let folder_name = "test_folder"; - let folder_path = VRPath::root().push_cloned(folder_name.to_string()); - let writer = vector_fs - .new_writer(default_test_profile(), VRPath::root(), default_test_profile()) - .await - .unwrap(); - vector_fs.create_new_folder(&writer, folder_name).await.unwrap(); - - // Check if the new folder is empty initially - let reader = vector_fs - .new_reader(default_test_profile(), folder_path.clone(), default_test_profile()) - .await - .unwrap(); - assert!( - vector_fs.is_folder_empty(&reader).await.unwrap(), - "The folder should initially be empty." - ); - - // Add a document to the folder, making it non-empty - let (doc_resource, source_file_map) = get_shinkai_intro_doc_async(&generator, &vec![]).await.unwrap(); - let resource = BaseVectorResource::Document(doc_resource); - let writer = vector_fs - .new_writer(default_test_profile(), folder_path.clone(), default_test_profile()) - .await - .unwrap(); - vector_fs - .save_vector_resource_in_folder(&writer, resource.clone(), Some(source_file_map.clone())) - .await - .unwrap(); - - // Re-check if the folder is now non-empty - let reader = vector_fs - .new_reader(default_test_profile(), folder_path.clone(), default_test_profile()) - .await - .unwrap(); - assert!( - !vector_fs.is_folder_empty(&reader).await.unwrap(), - "The folder should now be non-empty." - ); - - // Create a subfolder within the initial folder - let subfolder_name = "subfolder1"; - let subfolder_path = folder_path.push_cloned(subfolder_name.to_string()); - vector_fs.create_new_folder(&writer, subfolder_name).await.unwrap(); - - let writer = vector_fs - .new_writer(default_test_profile(), subfolder_path.clone(), default_test_profile()) - .await - .unwrap(); - - let subfolder_name = "subfolder2"; - vector_fs.create_new_folder(&writer, subfolder_name).await.unwrap(); - - // Check if the folder is still recognized as non-empty after adding a subfolder - // This is to ensure the folder's non-empty status is consistent with its content state - let reader = vector_fs - .new_reader(default_test_profile(), subfolder_path, default_test_profile()) - .await - .unwrap(); - assert!( - !vector_fs.is_folder_empty(&reader).await.unwrap(), - "The folder should still be non-empty after adding a subfolder." - ); -} - -#[tokio::test] -async fn test_remove_code_blocks_with_parsed_user_message() { - // Example strings containing code blocks - let example1 = "Here is some text.\n```\nlet x = 10;\n```\nAnd here is more text."; - let example2 = "Another example with a `single backtick`, and a code block:\n```\nfn main() {\n println!(\"Hello, world!\");\n}\n```\nEnd of example."; - let example3 = "Text before code block 1.\n```\nCode Block 1\n```\nText between code block 1 and 2.\n```\nCode Block 2\n```\nText between code block 2 and 3.\n```\nCode Block 3\n```\nText after code block 3."; - - // Create a parsed job task for each example - let parsed_user_message1 = ParsedUserMessage::new(example1.to_string()); - let parsed_user_message2 = ParsedUserMessage::new(example2.to_string()); - let parsed_user_message3 = ParsedUserMessage::new(example3.to_string()); - - // Extract only the code blocks from each parsed job task - let code_blocks1 = parsed_user_message1.get_output_string_filtered(true, false); - let code_blocks2 = parsed_user_message2.get_output_string_filtered(true, false); - let code_blocks3 = parsed_user_message3.get_output_string_filtered(true, false); - - // Expected code blocks strings - let expected_code_blocks1 = "```\nlet x = 10;\n```"; - let expected_code_blocks2 = "```\nfn main() {\n println!(\"Hello, world!\");\n}\n```"; - let expected_code_blocks3 = "```\nCode Block 1\n```\n\n```\nCode Block 2\n```\n\n```\nCode Block 3\n```"; - - // Assert that the extracted code blocks match the expected strings - assert_eq!(code_blocks1, expected_code_blocks1); - assert_eq!(code_blocks2, expected_code_blocks2); - assert_eq!(code_blocks3, expected_code_blocks3); -} - -// #[tokio::test] -// async fn test_parse_list_elements() { -// // Example strings containing different types of lists -// let example1 = "Here is some text.\n- Item 1\n- Item 2\nAnd here is more text."; -// let example2 = "Another example text.\n* Item 1\n* Item 2\n* Item 3\nEnd of example."; -// let example3 = "Text before numbered list.\n1. Item 1\n2. Item 2\n3. Item 3\nText after numbered list."; - -// // Create a parsed job task for each example -// let parsed_user_message1 = ParsedUserMessage::new(example1.to_string()); -// let parsed_user_message2 = ParsedUserMessage::new(example2.to_string()); -// let parsed_user_message3 = ParsedUserMessage::new(example3.to_string()); - -// // Assuming a method to count list elements in the parsed job task -// let list_count1 = parsed_user_message1.get_elements_filtered(true, true, false).len(); -// let list_count2 = parsed_user_message2.get_elements_filtered(true, true, false).len(); -// let list_count3 = parsed_user_message3.get_elements_filtered(true, true, false).len(); - -// // Expected number of list elements -// let expected_list_count1 = 2; -// let expected_list_count2 = 3; -// let expected_list_count3 = 3; - -// // Assert that the counted list elements match the expected numbers -// assert_eq!( -// list_count1, expected_list_count1, -// "List count in example1 does not match." -// ); -// assert_eq!( -// list_count2, expected_list_count2, -// "List count in example2 does not match." -// ); -// assert_eq!( -// list_count3, expected_list_count3, -// "List count in example3 does not match." -// ); - -// // Print each list element for visual inspection (assuming a method to iterate and print list elements) -// println!("List elements in example1:"); -// parsed_user_message1.print_list_elements(); -// println!("List elements in example2:"); -// parsed_user_message2.print_list_elements(); -// println!("List elements in example3:"); -// parsed_user_message3.print_list_elements(); -// } - -#[test] -fn vector_search_multiple_embedding_models_test() { - setup(); - std::env::set_var("WELCOME_MESSAGE", "false"); - - let server = Server::new(); - - run_test_one_node_network(|env| { - Box::pin(async move { - let node1_commands_sender = env.node1_commands_sender.clone(); - let node1_identity_name = env.node1_identity_name.clone(); - let node1_profile_name = env.node1_profile_name.clone(); - let node1_device_name = env.node1_device_name.clone(); - let node1_agent = env.node1_llm_provider.clone(); - let node1_encryption_pk = env.node1_encryption_pk; - let node1_device_encryption_sk = env.node1_device_encryption_sk.clone(); - let node1_profile_encryption_sk = env.node1_profile_encryption_sk.clone(); - let node1_device_identity_sk = clone_signature_secret_key(&env.node1_device_identity_sk); - let node1_profile_identity_sk = clone_signature_secret_key(&env.node1_profile_identity_sk); - let node1_abort_handler = env.node1_abort_handler; - - let node1_db_weak = Arc::downgrade(&env.node1_db); - - // For this test - let symmetrical_sk = unsafe_deterministic_aes_encryption_key(0); - - { - // Register a Profile in Node1 and verifies it - eprintln!("\n\nRegister a Device with main Profile in Node1 and verify it"); - api_initial_registration_with_no_code_for_device( - node1_commands_sender.clone(), - env.node1_profile_name.as_str(), - env.node1_identity_name.as_str(), - node1_encryption_pk, - node1_device_encryption_sk.clone(), - clone_signature_secret_key(&node1_device_identity_sk), - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_device_name.as_str(), - ) - .await; - } - - { - // Register an Agent - eprintln!("\n\nRegister an Agent in Node1 and verify it"); - let agent_name = ShinkaiName::new( - format!( - "{}/{}/agent/{}", - node1_identity_name.clone(), - node1_profile_name.clone(), - node1_agent.clone() - ) - .to_string(), - ) - .unwrap(); - - let ollama = Ollama { - model_type: "mixtral:8x7b-instruct-v0.1-q4_1".to_string(), - }; - - let agent = SerializedLLMProvider { - id: node1_agent.clone().to_string(), - full_identity_name: agent_name, - api_key: Some("".to_string()), - external_url: Some(server.url()), - model: LLMProviderInterface::Ollama(ollama), - }; - api_llm_provider_registration( - node1_commands_sender.clone(), - clone_static_secret_key(&node1_profile_encryption_sk), - node1_encryption_pk, - clone_signature_secret_key(&node1_profile_identity_sk), - node1_identity_name.clone().as_str(), - node1_profile_name.clone().as_str(), - agent, - ) - .await; - } - // Send message (APICreateFilesInboxWithSymmetricKey) from Device subidentity to Node 1 - { - eprintln!("\n\n### Sending message (APICreateFilesInboxWithSymmetricKey) from profile subidentity to node 1\n\n"); - - let message_content = aes_encryption_key_to_string(symmetrical_sk); - let msg = ShinkaiMessageBuilder::create_files_inbox_with_sym_key( - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - "job::test::false".to_string(), - message_content.clone(), - node1_profile_name.to_string(), - node1_identity_name.to_string(), - node1_identity_name.to_string(), - ) - .unwrap(); - - let (res_sender, res_receiver) = async_channel::bounded(1); - node1_commands_sender - .send(NodeCommand::APICreateFilesInboxWithSymmetricKey { msg, res: res_sender }) - .await - .unwrap(); - let _ = res_receiver.recv().await.unwrap().expect("Failed to receive messages"); - } - { - // Update supported embedding models - let payload = [ - OllamaTextEmbeddingsInference::SnowflakeArcticEmbed_M.to_string(), - OllamaTextEmbeddingsInference::JinaEmbeddingsV2BaseEs.to_string(), - ]; - - let msg = generate_message_with_payload( - serde_json::to_string(&payload).unwrap(), - MessageSchemaType::UpdateSupportedEmbeddingModels, - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - node1_identity_name.as_str(), - node1_profile_name.as_str(), - node1_identity_name.as_str(), - ); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIUpdateSupportedEmbeddingModels { msg, res: res_sender }) - .await - .unwrap(); - - // Receive the response - let _ = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - } - { - // Initialize local PDF parser - ShinkaiTestingFramework::initialize_pdfium().await; - - // Create Folder - let payload = APIVecFsCreateFolder { - path: "/".to_string(), - folder_name: "test_folder".to_string(), - }; - - let msg = generate_message_with_payload( - serde_json::to_string(&payload).unwrap(), - MessageSchemaType::VecFsCreateFolder, - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - node1_identity_name.as_str(), - node1_profile_name.as_str(), - node1_identity_name.as_str(), - ); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIVecFSCreateFolder { msg, res: res_sender }) - .await - .unwrap(); - let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - eprintln!("resp: {:?}", resp); - } - { - // Upload .vrkai file with jina es embeddings to inbox - // Prepare the file to be read - let filename = "../../files/hispania_jina_es.vrkai"; - let file_path = Path::new(filename); - - // Read the file into a buffer - let file_data = std::fs::read(file_path).map_err(|_| VRError::FailedPDFParsing).unwrap(); - - // Encrypt the file using Aes256Gcm - let cipher = Aes256Gcm::new(GenericArray::from_slice(&symmetrical_sk)); - let nonce = GenericArray::from_slice(&[0u8; 12]); - let nonce_slice = nonce.as_slice(); - let nonce_str = aes_nonce_to_hex_string(nonce_slice); - let ciphertext = cipher.encrypt(nonce, file_data.as_ref()).expect("encryption failure!"); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIAddFileToInboxWithSymmetricKey { - filename: filename.to_string(), - file: ciphertext, - public_key: hash_of_aes_encryption_key_hex(symmetrical_sk), - encrypted_nonce: nonce_str, - res: res_sender, - }) - .await - .unwrap(); - - // Receive the response - let _ = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - } - { - // Convert File and Save to Folder - let payload = APIConvertFilesAndSaveToFolder { - path: "/test_folder".to_string(), - file_inbox: hash_of_aes_encryption_key_hex(symmetrical_sk), - file_datetime: Some(Utc.with_ymd_and_hms(2024, 2, 1, 0, 0, 0).unwrap()), - }; - - let msg = generate_message_with_payload( - serde_json::to_string(&payload).unwrap(), - MessageSchemaType::ConvertFilesAndSaveToFolder, - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - node1_identity_name.as_str(), - node1_profile_name.as_str(), - node1_identity_name.as_str(), - ); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIConvertFilesAndSaveToFolder { msg, res: res_sender }) - .await - .unwrap(); - let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - eprintln!("resp: {:?}", resp); - } - { - // Recover file from path using APIVecFSRetrievePathSimplifiedJson - let payload = APIVecFsRetrievePathSimplifiedJson { - path: "/test_folder/hispania".to_string(), - }; - - let msg = generate_message_with_payload( - serde_json::to_string(&payload).unwrap(), - MessageSchemaType::VecFsRetrievePathSimplifiedJson, - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - node1_identity_name.as_str(), - node1_profile_name.as_str(), - node1_identity_name.as_str(), - ); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIVecFSRetrievePathSimplifiedJson { msg, res: res_sender }) - .await - .unwrap(); - let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - // eprintln!("resp for current file system files: {}", resp); - - // Assuming `resp` is now a serde_json::Value - let resp_json = serde_json::to_string(&resp).expect("Failed to convert response to string"); - // eprintln!("resp for current file system files: {}", resp_json); - - // TODO: convert to json and then compare - let expected_path = "/test_folder/hispania"; - assert!( - resp_json.contains(expected_path), - "Response does not contain the expected file path: {}", - expected_path - ); - } - { - // Upload .vrkai file to inbox - // Prepare the file to be read - let filename = "../../files/short_story.md"; - let file_path = Path::new(filename); - - // Read the file into a buffer - let file_data = std::fs::read(file_path).map_err(|_| VRError::FailedPDFParsing).unwrap(); - - // Encrypt the file using Aes256Gcm - let cipher = Aes256Gcm::new(GenericArray::from_slice(&symmetrical_sk)); - let nonce = GenericArray::from_slice(&[0u8; 12]); - let nonce_slice = nonce.as_slice(); - let nonce_str = aes_nonce_to_hex_string(nonce_slice); - let ciphertext = cipher.encrypt(nonce, file_data.as_ref()).expect("encryption failure!"); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIAddFileToInboxWithSymmetricKey { - filename: filename.to_string(), - file: ciphertext, - public_key: hash_of_aes_encryption_key_hex(symmetrical_sk), - encrypted_nonce: nonce_str, - res: res_sender, - }) - .await - .unwrap(); - - // Receive the response - let _ = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - } - { - // Convert File and Save to Folder - let payload = APIConvertFilesAndSaveToFolder { - path: "/test_folder".to_string(), - file_inbox: hash_of_aes_encryption_key_hex(symmetrical_sk), - file_datetime: Some(Utc.with_ymd_and_hms(2024, 2, 1, 0, 0, 0).unwrap()), - }; - - let msg = generate_message_with_payload( - serde_json::to_string(&payload).unwrap(), - MessageSchemaType::ConvertFilesAndSaveToFolder, - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - node1_identity_name.as_str(), - node1_profile_name.as_str(), - node1_identity_name.as_str(), - ); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIConvertFilesAndSaveToFolder { msg, res: res_sender }) - .await - .unwrap(); - let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - eprintln!("resp: {:?}", resp); - } - { - // Recover file from path using APIVecFSRetrievePathSimplifiedJson - let payload = APIVecFsRetrievePathSimplifiedJson { - path: "/test_folder/short_story".to_string(), - }; - - let msg = generate_message_with_payload( - serde_json::to_string(&payload).unwrap(), - MessageSchemaType::VecFsRetrievePathSimplifiedJson, - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - node1_identity_name.as_str(), - node1_profile_name.as_str(), - node1_identity_name.as_str(), - ); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIVecFSRetrievePathSimplifiedJson { msg, res: res_sender }) - .await - .unwrap(); - let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - // eprintln!("resp for current file system files: {}", resp); - - // Assuming `resp` is now a serde_json::Value - let resp_json = serde_json::to_string(&resp).expect("Failed to convert response to string"); - // eprintln!("resp for current file system files: {}", resp_json); - - // TODO: convert to json and then compare - let expected_path = "/test_folder/short_story"; - assert!( - resp_json.contains(expected_path), - "Response does not contain the expected file path: {}", - expected_path - ); - } - { - // Do deep search - let payload = APIVecFsRetrieveVectorSearchSimplifiedJson { - search: "Dónde estaba ubicada la capital principal?".to_string(), - path: None, - max_results: Some(10), - max_files_to_scan: Some(100), - }; - - let msg = generate_message_with_payload( - serde_json::to_string(&payload).unwrap(), - MessageSchemaType::VecFsRetrieveVectorSearchSimplifiedJson, - node1_profile_encryption_sk.clone(), - clone_signature_secret_key(&node1_profile_identity_sk), - node1_encryption_pk, - node1_identity_name.as_str(), - node1_profile_name.as_str(), - node1_identity_name.as_str(), - ); - - // Prepare the response channel - let (res_sender, res_receiver) = async_channel::bounded(1); - - // Send the command - node1_commands_sender - .send(NodeCommand::APIVecFSRetrieveVectorSearchSimplifiedJson { msg, res: res_sender }) - .await - .unwrap(); - let resp = res_receiver.recv().await.unwrap().expect("Failed to receive response"); - for r in &resp { - eprintln!("\n\nSearch result: {:?}", r); - } - - assert!(!resp.is_empty(), "Response is empty."); - assert!(&resp - .iter() - .any(|r| r.0.contains("principal capital estaba situada en Qart Hadasht"))); - } - node1_abort_handler.abort(); - }) - }); -} diff --git a/shinkai-bin/shinkai-node/tests/it/websocket_tests.rs b/shinkai-bin/shinkai-node/tests/it/websocket_tests.rs index 4de3a7104..f3e446845 100644 --- a/shinkai-bin/shinkai-node/tests/it/websocket_tests.rs +++ b/shinkai-bin/shinkai-node/tests/it/websocket_tests.rs @@ -7,6 +7,8 @@ use ed25519_dalek::SigningKey; use futures::SinkExt; use futures::StreamExt; +use shinkai_embedding::model_type::EmbeddingModelType; +use shinkai_embedding::model_type::OllamaTextEmbeddingsInference; use shinkai_message_primitives::schemas::identity::Identity; use shinkai_message_primitives::schemas::identity::StandardIdentity; use shinkai_message_primitives::schemas::identity::StandardIdentityType; @@ -26,13 +28,12 @@ use shinkai_message_primitives::shinkai_utils::encryption::unsafe_deterministic_ use shinkai_message_primitives::shinkai_utils::encryption::EncryptionMethod; use shinkai_message_primitives::shinkai_utils::file_encryption::aes_encryption_key_to_string; use shinkai_message_primitives::shinkai_utils::file_encryption::unsafe_deterministic_aes_encryption_key; -use shinkai_message_primitives::shinkai_utils::job_scope::JobScope; +use shinkai_message_primitives::shinkai_utils::job_scope::MinimalJobScope; use shinkai_message_primitives::shinkai_utils::shinkai_message_builder::ShinkaiMessageBuilder; use shinkai_message_primitives::shinkai_utils::signatures::unsafe_deterministic_signature_keypair; use shinkai_node::managers::identity_manager::IdentityManagerTrait; use shinkai_node::network::{ws_manager::WebSocketManager, ws_routes::run_ws_api}; use shinkai_sqlite::SqliteManager; -use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use std::path::PathBuf; use std::sync::Arc; use tempfile::NamedTempFile; @@ -262,7 +263,7 @@ async fn test_websocket() { }; let _ = shinkai_db.insert_profile(sender_subidentity.clone()); - let scope = JobScope::new_default(); + let scope = MinimalJobScope::default(); match shinkai_db.create_new_job(job_id1, agent_id.clone(), scope.clone(), false, None, None) { Ok(_) => (), Err(e) => panic!("Failed to create a new job: {}", e), @@ -563,7 +564,7 @@ async fn test_websocket_smart_inbox() { }; let _ = shinkai_db.insert_profile(sender_subidentity.clone()); - let scope = JobScope::new_default(); + let scope = MinimalJobScope::default(); match shinkai_db.create_new_job(job_id1, agent_id.clone(), scope.clone(), false, None, None) { Ok(_) => (), Err(e) => panic!("Failed to create a new job: {}", e), diff --git a/shinkai-bin/shinkai-node/tests/it_mod.rs b/shinkai-bin/shinkai-node/tests/it_mod.rs index 9ca81b293..271c4f21a 100644 --- a/shinkai-bin/shinkai-node/tests/it_mod.rs +++ b/shinkai-bin/shinkai-node/tests/it_mod.rs @@ -9,7 +9,6 @@ mod it { mod db_job_tests; mod db_llm_providers_tests; mod db_restore_tests; - mod encrypted_files_tests; mod get_onchain_identity_tests; mod job_branchs_retries_tests; mod job_concurrency_in_seq_tests; @@ -23,7 +22,6 @@ mod it { mod planner_integration_tests; mod utils; mod vector_fs_api_tests; - mod vector_fs_tests; mod websocket_tests; mod change_nodes_name_tests; diff --git a/shinkai-libs/shinkai-embedding/Cargo.toml b/shinkai-libs/shinkai-embedding/Cargo.toml new file mode 100644 index 000000000..43ac07833 --- /dev/null +++ b/shinkai-libs/shinkai-embedding/Cargo.toml @@ -0,0 +1,31 @@ +[package] +name = "shinkai_embedding" +version = { workspace = true } +edition = { workspace = true } +authors = { workspace = true } + +[dependencies] +bincode = { workspace = true } +serde_json = { workspace = true } +rand = { workspace = true } +blake3 = { workspace = true } +chrono = { workspace = true } +thiserror = "2.0.3" +reqwest = { workspace = true, features = [ + "json", + "tokio-native-tls", + "blocking", + "multipart", + "default-tls", +] } +lazy_static = "1.5.0" +async-trait = { workspace = true } +keyphrases = { workspace = true } +futures = { workspace = true } +csv = "1.1.6" +utoipa = "4.2.3" +regex = { workspace = true } + +[dependencies.serde] +workspace = true +features = ["derive"] \ No newline at end of file diff --git a/shinkai-libs/shinkai-vector-resources/src/embedding_generator.rs b/shinkai-libs/shinkai-embedding/src/embedding_generator.rs similarity index 66% rename from shinkai-libs/shinkai-vector-resources/src/embedding_generator.rs rename to shinkai-libs/shinkai-embedding/src/embedding_generator.rs index c7ef66880..cec5b4952 100644 --- a/shinkai-libs/shinkai-vector-resources/src/embedding_generator.rs +++ b/shinkai-libs/shinkai-embedding/src/embedding_generator.rs @@ -1,17 +1,19 @@ -use crate::embeddings::Embedding; use crate::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; -use crate::resource_errors::VRError; +use crate::shinkai_embedding_errors::ShinkaiEmbeddingError; use async_trait::async_trait; use lazy_static::lazy_static; -#[cfg(feature = "desktop-only")] + use reqwest::blocking::Client; -#[cfg(feature = "desktop-only")] + use reqwest::Client as AsyncClient; -use serde::{Deserialize, Serialize}; use reqwest::ClientBuilder; +use serde::{Deserialize, Serialize}; use std::time::Duration; +// TODO: remove duplicate methods +// TODO: remove blocking / non-blocking methods + lazy_static! { pub static ref DEFAULT_EMBEDDINGS_SERVER_URL: &'static str = "https://internal.shinkai.com/x-embed-api/"; pub static ref DEFAULT_EMBEDDINGS_LOCAL_URL: &'static str = "http://localhost:11434/"; @@ -26,60 +28,53 @@ pub trait EmbeddingGenerator: Sync + Send { /// Generates an embedding from the given input string, and assigns the /// provided id. - fn generate_embedding_blocking(&self, input_string: &str, id: &str) -> Result; + fn generate_embedding_blocking(&self, input_string: &str) -> Result, ShinkaiEmbeddingError>; /// Generate an Embedding for an input string, sets id to a default value /// of empty string. - fn generate_embedding_default_blocking(&self, input_string: &str) -> Result { - self.generate_embedding_blocking(input_string, "") + fn generate_embedding_default_blocking(&self, input_string: &str) -> Result, ShinkaiEmbeddingError> { + self.generate_embedding_blocking(input_string) } /// Generates embeddings from the given list of input strings and ids. - fn generate_embeddings_blocking( - &self, - input_strings: &Vec, - ids: &Vec, - ) -> Result, VRError>; + fn generate_embeddings_blocking(&self, input_strings: &Vec) -> Result>, ShinkaiEmbeddingError>; /// Generate Embeddings for a list of input strings, sets ids to default. - fn generate_embeddings_blocking_default(&self, input_strings: &Vec) -> Result, VRError> { - let ids: Vec = vec!["".to_string(); input_strings.len()]; - self.generate_embeddings_blocking(input_strings, &ids) + fn generate_embeddings_blocking_default( + &self, + input_strings: &Vec, + ) -> Result>, ShinkaiEmbeddingError> { + self.generate_embeddings_blocking(input_strings) } /// Generates an embedding from the given input string, and assigns the /// provided id. - async fn generate_embedding(&self, input_string: &str, id: &str) -> Result; + async fn generate_embedding(&self, input_string: &str) -> Result, ShinkaiEmbeddingError>; /// Generate an Embedding for an input string, sets id to a default value /// of empty string. - async fn generate_embedding_default(&self, input_string: &str) -> Result { - self.generate_embedding(input_string, "").await + async fn generate_embedding_default(&self, input_string: &str) -> Result, ShinkaiEmbeddingError> { + self.generate_embedding(input_string).await } + // ### TODO: remove all these duplicate methods /// Generates embeddings from the given list of input strings and ids. - async fn generate_embeddings( - &self, - input_strings: &Vec, - ids: &Vec, - ) -> Result, VRError>; + async fn generate_embeddings(&self, input_strings: &Vec) -> Result>, ShinkaiEmbeddingError>; /// Generate Embeddings for a list of input strings, sets ids to default - async fn generate_embeddings_default(&self, input_strings: &Vec) -> Result, VRError> { - let ids: Vec = vec!["".to_string(); input_strings.len()]; - self.generate_embeddings(input_strings, &ids).await + async fn generate_embeddings_default(&self, input_strings: &Vec) -> Result>, ShinkaiEmbeddingError> { + self.generate_embeddings(input_strings).await } } #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -#[cfg(feature = "desktop-only")] + pub struct RemoteEmbeddingGenerator { pub model_type: EmbeddingModelType, pub api_url: String, pub api_key: Option, } -#[cfg(feature = "desktop-only")] #[async_trait] impl EmbeddingGenerator for RemoteEmbeddingGenerator { /// Clones self and wraps it in a Box @@ -87,36 +82,20 @@ impl EmbeddingGenerator for RemoteEmbeddingGenerator { Box::new(self.clone()) } - #[cfg(feature = "desktop-only")] /// Generate Embeddings for an input list of strings by using the external API. /// This method batch generates whenever possible to increase speed. /// Note this method is blocking. - fn generate_embeddings_blocking( - &self, - input_strings: &Vec, - ids: &Vec, - ) -> Result, VRError> { + fn generate_embeddings_blocking(&self, input_strings: &Vec) -> Result>, ShinkaiEmbeddingError> { let input_strings: Vec = input_strings .iter() .map(|s| s.chars().take(self.model_type.max_input_token_count()).collect()) .collect(); match self.model_type { - EmbeddingModelType::TextEmbeddingsInference(_) => { - self.generate_embedding_tei_blocking(input_strings.clone(), ids.clone()) - } EmbeddingModelType::OllamaTextEmbeddingsInference(_) => { let mut embeddings = Vec::new(); - for (input_string, id) in input_strings.iter().zip(ids) { - let embedding = self.generate_embedding_ollama_blocking(input_string, id)?; - embeddings.push(embedding); - } - Ok(embeddings) - } - _ => { - let mut embeddings = Vec::new(); - for (input_string, id) in input_strings.iter().zip(ids) { - let embedding = self.generate_embedding_open_ai_blocking(input_string, id)?; + for input_string in input_strings.iter() { + let embedding = self.generate_embedding_ollama_blocking(input_string)?; embeddings.push(embedding); } Ok(embeddings) @@ -124,20 +103,18 @@ impl EmbeddingGenerator for RemoteEmbeddingGenerator { } } - #[cfg(feature = "desktop-only")] /// Generate an Embedding for an input string by using the external API. /// Note this method is blocking. - fn generate_embedding_blocking(&self, input_string: &str, id: &str) -> Result { + fn generate_embedding_blocking(&self, input_string: &str) -> Result, ShinkaiEmbeddingError> { let input_strings = [input_string.to_string()]; let input_strings: Vec = input_strings .iter() .map(|s| s.chars().take(self.model_type.max_input_token_count()).collect()) .collect(); - let ids = vec![id.to_string()]; - let results = self.generate_embeddings_blocking(&input_strings, &ids)?; + let results = self.generate_embeddings_blocking(&input_strings)?; if results.is_empty() { - Err(VRError::FailedEmbeddingGeneration( + Err(ShinkaiEmbeddingError::FailedEmbeddingGeneration( "No results returned from the embedding generation".to_string(), )) } else { @@ -145,57 +122,39 @@ impl EmbeddingGenerator for RemoteEmbeddingGenerator { } } - #[cfg(feature = "desktop-only")] /// Generate an Embedding for an input string by using the external API. /// This method batch generates whenever possible to increase speed. - async fn generate_embeddings( - &self, - input_strings: &Vec, - ids: &Vec, - ) -> Result, VRError> { + async fn generate_embeddings(&self, input_strings: &Vec) -> Result>, ShinkaiEmbeddingError> { let input_strings: Vec = input_strings .iter() .map(|s| s.chars().take(self.model_type.max_input_token_count()).collect()) .collect(); match self.model_type.clone() { - EmbeddingModelType::TextEmbeddingsInference(_) => { - self.generate_embedding_tei(input_strings.clone(), ids.clone()).await - } EmbeddingModelType::OllamaTextEmbeddingsInference(model) => { let mut embeddings = Vec::new(); - for (input_string, id) in input_strings.iter().zip(ids) { + for input_string in input_strings.iter() { let embedding = self - .generate_embedding_ollama(input_string.clone(), id.clone(), model.to_string()) + .generate_embedding_ollama(input_string.clone(), model.to_string()) .await?; embeddings.push(embedding); } Ok(embeddings) } - _ => { - let mut embeddings = Vec::new(); - for (input_string, id) in input_strings.iter().zip(ids) { - let embedding = self.generate_embedding_open_ai(input_string, id).await?; - embeddings.push(embedding); - } - Ok(embeddings) - } } } - #[cfg(feature = "desktop-only")] /// Generate an Embedding for an input string by using the external API. - async fn generate_embedding(&self, input_string: &str, id: &str) -> Result { + async fn generate_embedding(&self, input_string: &str) -> Result, ShinkaiEmbeddingError> { let input_strings = [input_string.to_string()]; let input_strings: Vec = input_strings .iter() .map(|s| s.chars().take(self.model_type.max_input_token_count()).collect()) .collect(); - let ids = vec![id.to_string()]; - let results = self.generate_embeddings(&input_strings, &ids).await?; + let results = self.generate_embeddings(&input_strings).await?; if results.is_empty() { - Err(VRError::FailedEmbeddingGeneration( + Err(ShinkaiEmbeddingError::FailedEmbeddingGeneration( "No results returned from the embedding generation".to_string(), )) } else { @@ -214,7 +173,6 @@ impl EmbeddingGenerator for RemoteEmbeddingGenerator { } } -#[cfg(feature = "desktop-only")] impl RemoteEmbeddingGenerator { /// Create a RemoteEmbeddingGenerator pub fn new(model_type: EmbeddingModelType, api_url: &str, api_key: Option) -> RemoteEmbeddingGenerator { @@ -235,8 +193,8 @@ impl RemoteEmbeddingGenerator { api_key: None, } } - /// Create a RemoteEmbeddingGenerator that uses the default model and server - pub fn new_default_local() -> RemoteEmbeddingGenerator { + /// Create a RemoteEmbeddingGenerator that uses the default model and server + pub fn new_default_local() -> RemoteEmbeddingGenerator { let model_architecture = EmbeddingModelType::OllamaTextEmbeddingsInference(OllamaTextEmbeddingsInference::SnowflakeArcticEmbed_M); RemoteEmbeddingGenerator { @@ -266,15 +224,13 @@ impl RemoteEmbeddingGenerator { } } - #[cfg(feature = "desktop-only")] /// Generates embeddings using Hugging Face's Text Embedding Interface server /// pub async fn generate_embedding_open_ai(&self, input_string: &str, id: &str) -> Result { pub async fn generate_embedding_ollama( &self, input_string: String, - id: String, model: String, - ) -> Result { + ) -> Result, ShinkaiEmbeddingError> { let max_retries = 3; let mut retry_count = 0; let mut shortening_retry = 0; @@ -311,14 +267,10 @@ impl RemoteEmbeddingGenerator { response.json::().await; match embedding_response { Ok(embedding_response) => { - let embedding = Embedding { - id: String::from(id), - vector: embedding_response.embedding, - }; - return Ok(embedding); + return Ok(embedding_response.embedding); } Err(err) => { - return Err(VRError::RequestFailed(format!( + return Err(ShinkaiEmbeddingError::RequestFailed(format!( "Failed to deserialize response JSON: {}", err ))); @@ -338,7 +290,7 @@ impl RemoteEmbeddingGenerator { retry_count = 0; shortening_retry += 1; if shortening_retry > 10 { - return Err(VRError::RequestFailed(format!( + return Err(ShinkaiEmbeddingError::RequestFailed(format!( "HTTP request failed after multiple recursive iterations shortening input. Status: {}", response.status() ))); @@ -346,7 +298,7 @@ impl RemoteEmbeddingGenerator { continue; } Ok(response) => { - return Err(VRError::RequestFailed(format!( + return Err(ShinkaiEmbeddingError::RequestFailed(format!( "HTTP request failed with status: {}", response.status() ))); @@ -356,7 +308,7 @@ impl RemoteEmbeddingGenerator { retry_count += 1; continue; } else { - return Err(VRError::RequestFailed(format!( + return Err(ShinkaiEmbeddingError::RequestFailed(format!( "HTTP request failed after {} retries: {}", max_retries, err ))); @@ -366,9 +318,8 @@ impl RemoteEmbeddingGenerator { } } - #[cfg(feature = "desktop-only")] /// Generate an Embedding for an input string by using the external Ollama API. - fn generate_embedding_ollama_blocking(&self, input_string: &str, id: &str) -> Result { + fn generate_embedding_ollama_blocking(&self, input_string: &str) -> Result, ShinkaiEmbeddingError> { // Prepare the request body let request_body = OllamaEmbeddingsRequestBody { model: self.model_type.to_string(), @@ -392,37 +343,25 @@ impl RemoteEmbeddingGenerator { // Send the request and check for errors let response = request.send().map_err(|err| { // Handle any HTTP client errors here (e.g., request creation failure) - VRError::RequestFailed(format!("HTTP request failed: {}", err)) + ShinkaiEmbeddingError::RequestFailed(format!("HTTP request failed: {}", err)) })?; // Check if the response is successful if response.status().is_success() { - // Deserialize the response JSON into a struct - let embedding_response: OllamaEmbeddingsResponse = response - .json() - .map_err(|err| VRError::RequestFailed(format!("Failed to deserialize response JSON: {}", err)))?; - - // Use the response to create an Embedding instance - Ok(Embedding { - id: String::from(id), - vector: embedding_response.embedding, - }) + let embedding_response: OllamaEmbeddingsResponse = response.json().map_err(|err| { + ShinkaiEmbeddingError::RequestFailed(format!("Failed to deserialize response JSON: {}", err)) + })?; + Ok(embedding_response.embedding) } else { - // Handle non-successful HTTP responses (e.g., server error) - Err(VRError::RequestFailed(format!( + Err(ShinkaiEmbeddingError::RequestFailed(format!( "HTTP request failed with status: {}", response.status() ))) } } - #[cfg(feature = "desktop-only")] /// Generates embeddings using Hugging Face's Text Embedding Interface server - pub async fn generate_embedding_tei( - &self, - input_strings: Vec, - ids: Vec, - ) -> Result, VRError> { + pub async fn generate_embedding_tei(&self, input_strings: Vec) -> Result>, ShinkaiEmbeddingError> { let max_retries = 3; let mut retry_count = 0; let mut shortening_retry = 0; @@ -457,21 +396,10 @@ impl RemoteEmbeddingGenerator { let embedding_response: Result>, _> = response.json::>>().await; match embedding_response { Ok(embedding_response) => { - // Create a Vec by iterating over ids and embeddings - let embeddings: Result, _> = ids - .iter() - .zip(embedding_response.into_iter()) - .map(|(id, embedding)| { - Ok(Embedding { - id: id.clone(), - vector: embedding, - }) - }) - .collect(); - return embeddings; + return Ok(embedding_response); } Err(err) => { - return Err(VRError::RequestFailed(format!( + return Err(ShinkaiEmbeddingError::RequestFailed(format!( "Failed to deserialize response JSON: {}", err ))); @@ -500,7 +428,7 @@ impl RemoteEmbeddingGenerator { retry_count = 0; shortening_retry += 1; if shortening_retry > 10 { - return Err(VRError::RequestFailed(format!( + return Err(ShinkaiEmbeddingError::RequestFailed(format!( "HTTP request failed after multiple recursive iterations shortening input. Status: {}", response.status() ))); @@ -508,7 +436,7 @@ impl RemoteEmbeddingGenerator { continue; } Ok(response) => { - return Err(VRError::RequestFailed(format!( + return Err(ShinkaiEmbeddingError::RequestFailed(format!( "HTTP request failed with status: {}", response.status() ))); @@ -518,7 +446,7 @@ impl RemoteEmbeddingGenerator { retry_count += 1; continue; } else { - return Err(VRError::RequestFailed(format!( + return Err(ShinkaiEmbeddingError::RequestFailed(format!( "HTTP request failed after {} retries: {}", max_retries, err ))); @@ -528,13 +456,8 @@ impl RemoteEmbeddingGenerator { } } - #[cfg(feature = "desktop-only")] /// Generates embeddings using a Hugging Face Text Embeddings Inference server - fn generate_embedding_tei_blocking( - &self, - input_strings: Vec, - ids: Vec, - ) -> Result, VRError> { + fn generate_embedding_tei_blocking(&self, input_strings: Vec) -> Result>, ShinkaiEmbeddingError> { // Prepare the request body let request_body = EmbeddingArrayRequestBody { inputs: input_strings.iter().map(|s| s.to_string()).collect(), @@ -545,7 +468,7 @@ impl RemoteEmbeddingGenerator { let client = Client::builder() .timeout(timeout) .build() - .map_err(|err| VRError::RequestFailed(format!("Failed to create HTTP client: {}", err)))?; + .map_err(|err| ShinkaiEmbeddingError::RequestFailed(format!("Failed to create HTTP client: {}", err)))?; // Build the request let mut request = client @@ -564,7 +487,11 @@ impl RemoteEmbeddingGenerator { let response = loop { let cloned_request = match request.try_clone() { Some(req) => req, - None => return Err(VRError::RequestFailed("Failed to clone request for retry".into())), + None => { + return Err(ShinkaiEmbeddingError::RequestFailed( + "Failed to clone request for retry".into(), + )) + } }; match cloned_request.send() { Ok(response) => break response, @@ -577,7 +504,7 @@ impl RemoteEmbeddingGenerator { ); std::thread::sleep(Duration::from_secs(1)); // Optional: Add a delay between retries } else { - return Err(VRError::RequestFailed(format!( + return Err(ShinkaiEmbeddingError::RequestFailed(format!( "HTTP request failed after {} retries: {}", max_retries, err ))); @@ -589,41 +516,24 @@ impl RemoteEmbeddingGenerator { // Check if the response is successful if response.status().is_success() { let embedding_response: Result>, _> = response.json::>>(); - match embedding_response { - Ok(embedding_response) => { - // Create a Vec by iterating over ids and embeddings - let embeddings: Result, _> = ids - .iter() - .zip(embedding_response.into_iter()) - .map(|(id, embedding)| { - Ok(Embedding { - id: id.clone(), - vector: embedding, - }) - }) - .collect(); - - // Return the embeddings - embeddings - } - Err(err) => Err(VRError::RequestFailed(format!( + Ok(embedding_response) => Ok(embedding_response), + Err(err) => Err(ShinkaiEmbeddingError::RequestFailed(format!( "Failed to deserialize response JSON: {}", err ))), } } else { // Handle non-successful HTTP responses (e.g., server error) - Err(VRError::RequestFailed(format!( + Err(ShinkaiEmbeddingError::RequestFailed(format!( "HTTP request failed with status: {}", response.status() ))) } } - #[cfg(feature = "desktop-only")] /// Generate an Embedding for an input string by using the external OpenAI-matching API. - pub async fn generate_embedding_open_ai(&self, input_string: &str, id: &str) -> Result { + pub async fn generate_embedding_open_ai(&self, input_string: &str) -> Result, ShinkaiEmbeddingError> { // Prepare the request body let request_body = EmbeddingRequestBody { input: String::from(input_string), @@ -647,35 +557,30 @@ impl RemoteEmbeddingGenerator { // Send the request and check for errors let response = request.send().await.map_err(|err| { // Handle any HTTP client errors here (e.g., request creation failure) - VRError::RequestFailed(format!("HTTP request failed: {}", err)) + ShinkaiEmbeddingError::RequestFailed(format!("HTTP request failed: {}", err)) })?; // Check if the response is successful if response.status().is_success() { // Deserialize the response JSON into a struct (assuming you have an // EmbeddingResponse struct) - let embedding_response: EmbeddingResponse = response - .json() - .await - .map_err(|err| VRError::RequestFailed(format!("Failed to deserialize response JSON: {}", err)))?; + let embedding_response: EmbeddingResponse = response.json().await.map_err(|err| { + ShinkaiEmbeddingError::RequestFailed(format!("Failed to deserialize response JSON: {}", err)) + })?; // Use the response to create an Embedding instance - Ok(Embedding { - id: String::from(id), - vector: embedding_response.data[0].embedding.clone(), - }) + Ok(embedding_response.data[0].embedding.clone()) } else { // Handle non-successful HTTP responses (e.g., server error) - Err(VRError::RequestFailed(format!( + Err(ShinkaiEmbeddingError::RequestFailed(format!( "HTTP request failed with status: {}", response.status() ))) } } - #[cfg(feature = "desktop-only")] /// Generate an Embedding for an input string by using the external OpenAI-matching API. - fn generate_embedding_open_ai_blocking(&self, input_string: &str, id: &str) -> Result { + fn generate_embedding_open_ai_blocking(&self, input_string: &str) -> Result, ShinkaiEmbeddingError> { // Prepare the request body let request_body = EmbeddingRequestBody { input: String::from(input_string), @@ -699,25 +604,22 @@ impl RemoteEmbeddingGenerator { // Send the request and check for errors let response = request.send().map_err(|err| { // Handle any HTTP client errors here (e.g., request creation failure) - VRError::RequestFailed(format!("HTTP request failed: {}", err)) + ShinkaiEmbeddingError::RequestFailed(format!("HTTP request failed: {}", err)) })?; // Check if the response is successful if response.status().is_success() { // Deserialize the response JSON into a struct (assuming you have an // EmbeddingResponse struct) - let embedding_response: EmbeddingResponse = response - .json() - .map_err(|err| VRError::RequestFailed(format!("Failed to deserialize response JSON: {}", err)))?; + let embedding_response: EmbeddingResponse = response.json().map_err(|err| { + ShinkaiEmbeddingError::RequestFailed(format!("Failed to deserialize response JSON: {}", err)) + })?; // Use the response to create an Embedding instance - Ok(Embedding { - id: String::from(id), - vector: embedding_response.data[0].embedding.clone(), - }) + Ok(embedding_response.data[0].embedding.clone()) } else { // Handle non-successful HTTP responses (e.g., server error) - Err(VRError::RequestFailed(format!( + Err(ShinkaiEmbeddingError::RequestFailed(format!( "HTTP request failed with status: {}", response.status() ))) @@ -767,71 +669,3 @@ struct OllamaEmbeddingsRequestBody { struct OllamaEmbeddingsResponse { embedding: Vec, } - -// /// An Embedding Generator for Local LLMs, such as LLama, Bloom, Pythia, etc. -// pub struct LocalEmbeddingGenerator { -// model: Box, -// model_type: EmbeddingModelType, -// } - -// impl EmbeddingGenerator for LocalEmbeddingGenerator { -// /// Generate an Embedding for an input string. -// /// - `id`: The id to be associated with the embeddings. -// fn generate_embedding(&self, input_string: &str, id: &str) -> Result { -// let mut session = self.model.start_session(Default::default()); -// let mut output_request = llm::OutputRequest { -// all_logits: None, -// embeddings: Some(Vec::new()), -// }; -// let vocab = self.model.tokenizer(); -// let beginning_of_sentence = true; - -// let tokens = vocab -// .tokenize(input_string, beginning_of_sentence) -// .map_err(|_| VRError::FailedEmbeddingGeneration)?; - -// let query_token_ids = tokens.iter().map(|(_, tok)| *tok).collect::>(); - -// self.model.evaluate(&mut session, &query_token_ids, &mut output_request); - -// let vector = output_request -// .embeddings -// .ok_or_else(|| VRError::FailedEmbeddingGeneration)?; - -// Ok(Embedding { -// id: String::from(id), -// vector, -// }) -// } - -// fn model_type(&self) -> EmbeddingModelType { -// self.model_type.clone() -// } -// } - -// impl LocalEmbeddingGenerator { -// /// Create a new LocalEmbeddingGenerator with a specified model. -// pub fn new(model: Box, model_architecture: ModelArchitecture) -> Self { -// Self { -// model, -// model_type: EmbeddingModelType::LocalModel(LocalModel::from_model_architecture(model_architecture)), -// } -// } - -// /// Create a new LocalEmbeddingGenerator that uses the default model. -// /// Intended to be used just for testing. -// pub fn new_default() -> Self { - -// let DEFAULT_LOCAL_MODEL_PATH: &'static str = "models/pythia-160m-q4_0.bin"; -// let model_architecture = llm::ModelArchitecture::GptNeoX; -// let model = llm::load_dynamic( -// Some(model_architecture), -// std::path::Path::new(&*DEFAULT_LOCAL_MODEL_PATH), -// llm::TokenizerSource::Embedded, -// Default::default(), -// load_callback, -// ) -// .unwrap_or_else(|err| panic!("Failed to load model: {}", err)); -// LocalEmbeddingGenerator::new(model, model_architecture) -// } -// } diff --git a/shinkai-libs/shinkai-embedding/src/lib.rs b/shinkai-libs/shinkai-embedding/src/lib.rs new file mode 100644 index 000000000..8ad43d457 --- /dev/null +++ b/shinkai-libs/shinkai-embedding/src/lib.rs @@ -0,0 +1,4 @@ +pub mod embedding_generator; +pub mod model_type; +pub mod shinkai_embedding_errors; +pub mod mock_generator; \ No newline at end of file diff --git a/shinkai-libs/shinkai-embedding/src/mock_generator.rs b/shinkai-libs/shinkai-embedding/src/mock_generator.rs new file mode 100644 index 000000000..bd2ee8251 --- /dev/null +++ b/shinkai-libs/shinkai-embedding/src/mock_generator.rs @@ -0,0 +1,50 @@ +use crate::model_type::EmbeddingModelType; +use crate::shinkai_embedding_errors::ShinkaiEmbeddingError; +use async_trait::async_trait; +use crate::embedding_generator::EmbeddingGenerator; + +#[derive(Clone)] +pub struct MockGenerator { + model_type: EmbeddingModelType, + num_embeddings: usize, +} + +impl MockGenerator { + pub fn new(model_type: EmbeddingModelType, num_embeddings: usize) -> Self { + MockGenerator { + model_type, + num_embeddings, + } + } +} + +#[async_trait] +impl EmbeddingGenerator for MockGenerator { + fn model_type(&self) -> EmbeddingModelType { + self.model_type.clone() + } + + fn set_model_type(&mut self, model_type: EmbeddingModelType) { + self.model_type = model_type; + } + + fn box_clone(&self) -> Box { + Box::new((*self).clone()) + } + + fn generate_embedding_blocking(&self, _input_string: &str) -> Result, ShinkaiEmbeddingError> { + Ok(vec![0.0; self.num_embeddings]) + } + + fn generate_embeddings_blocking(&self, input_strings: &Vec) -> Result>, ShinkaiEmbeddingError> { + Ok(input_strings.iter().map(|_| vec![0.0; self.num_embeddings]).collect()) + } + + async fn generate_embedding(&self, _input_string: &str) -> Result, ShinkaiEmbeddingError> { + Ok(vec![0.0; self.num_embeddings]) + } + + async fn generate_embeddings(&self, input_strings: &Vec) -> Result>, ShinkaiEmbeddingError> { + Ok(input_strings.iter().map(|_| vec![0.0; self.num_embeddings]).collect()) + } +} diff --git a/shinkai-libs/shinkai-embedding/src/model_type.rs b/shinkai-libs/shinkai-embedding/src/model_type.rs new file mode 100644 index 000000000..f7fd7a652 --- /dev/null +++ b/shinkai-libs/shinkai-embedding/src/model_type.rs @@ -0,0 +1,144 @@ +use std::fmt; +use std::hash::Hash; + +use crate::shinkai_embedding_errors::ShinkaiEmbeddingError; + +pub type EmbeddingModelTypeString = String; + +#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize, Hash)] +pub enum EmbeddingModelType { + OllamaTextEmbeddingsInference(OllamaTextEmbeddingsInference), +} + +impl EmbeddingModelType { + pub fn from_string(s: &str) -> Result { + OllamaTextEmbeddingsInference::from_string(s) + .map(EmbeddingModelType::OllamaTextEmbeddingsInference) + .map_err(|_| ShinkaiEmbeddingError::InvalidModelArchitecture) + } + + pub fn max_input_token_count(&self) -> usize { + match self { + EmbeddingModelType::OllamaTextEmbeddingsInference(model) => model.max_input_token_count(), + } + } + + pub fn embedding_normalization_factor(&self) -> f32 { + match self { + EmbeddingModelType::OllamaTextEmbeddingsInference(model) => model.embedding_normalization_factor(), + } + } + + pub fn vector_dimensions(&self) -> Result { + match self { + EmbeddingModelType::OllamaTextEmbeddingsInference(model) => model.vector_dimensions(), + } + } +} + +impl fmt::Display for EmbeddingModelType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self { + EmbeddingModelType::OllamaTextEmbeddingsInference(model) => write!(f, "{}", model), + } + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)] +pub enum OllamaTextEmbeddingsInference { + AllMiniLML6v2, + SnowflakeArcticEmbed_M, + JinaEmbeddingsV2BaseEs, + Other(String), +} + +impl OllamaTextEmbeddingsInference { + const ALL_MINI_LML6V2: &'static str = "all-minilm:l6-v2"; + const SNOWFLAKE_ARCTIC_EMBED_M: &'static str = "snowflake-arctic-embed:xs"; + const JINA_EMBEDDINGS_V2_BASE_ES: &'static str = "jina/jina-embeddings-v2-base-es:latest"; + + pub fn from_string(s: &str) -> Result { + match s { + Self::ALL_MINI_LML6V2 => Ok(Self::AllMiniLML6v2), + Self::SNOWFLAKE_ARCTIC_EMBED_M => Ok(Self::SnowflakeArcticEmbed_M), + Self::JINA_EMBEDDINGS_V2_BASE_ES => Ok(Self::JinaEmbeddingsV2BaseEs), + _ => Err(ShinkaiEmbeddingError::InvalidModelArchitecture), + } + } + + pub fn max_input_token_count(&self) -> usize { + match self { + Self::JinaEmbeddingsV2BaseEs => 1024, + _ => 512, + } + } + + pub fn embedding_normalization_factor(&self) -> f32 { + match self { + Self::JinaEmbeddingsV2BaseEs => 1.5, + _ => 1.0, + } + } + + pub fn vector_dimensions(&self) -> Result { + match self { + Self::SnowflakeArcticEmbed_M => Ok(384), + Self::JinaEmbeddingsV2BaseEs => Ok(768), + _ => Err(ShinkaiEmbeddingError::UnimplementedModelDimensions(format!("{:?}", self))), + } + } +} + +impl fmt::Display for OllamaTextEmbeddingsInference { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self { + Self::AllMiniLML6v2 => write!(f, "{}", Self::ALL_MINI_LML6V2), + Self::SnowflakeArcticEmbed_M => write!(f, "{}", Self::SNOWFLAKE_ARCTIC_EMBED_M), + Self::JinaEmbeddingsV2BaseEs => write!(f, "{}", Self::JINA_EMBEDDINGS_V2_BASE_ES), + Self::Other(name) => write!(f, "{}", name), + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_parse_snowflake_arctic_embed_xs() { + let model_str = "snowflake-arctic-embed:xs"; + let parsed_model = OllamaTextEmbeddingsInference::from_string(model_str); + assert_eq!(parsed_model, Ok(OllamaTextEmbeddingsInference::SnowflakeArcticEmbed_M)); + } + + #[test] + fn test_parse_jina_embeddings_v2_base_es() { + let model_str = "jina/jina-embeddings-v2-base-es:latest"; + let parsed_model = OllamaTextEmbeddingsInference::from_string(model_str); + assert_eq!(parsed_model, Ok(OllamaTextEmbeddingsInference::JinaEmbeddingsV2BaseEs)); + } + + #[test] + fn test_parse_snowflake_arctic_embed_xs_as_embedding_model_type() { + let model_str = "snowflake-arctic-embed:xs"; + let parsed_model = EmbeddingModelType::from_string(model_str); + assert_eq!( + parsed_model, + Ok(EmbeddingModelType::OllamaTextEmbeddingsInference( + OllamaTextEmbeddingsInference::SnowflakeArcticEmbed_M + )) + ); + } + + #[test] + fn test_parse_jina_embeddings_v2_base_es_as_embedding_model_type() { + let model_str = "jina/jina-embeddings-v2-base-es:latest"; + let parsed_model = EmbeddingModelType::from_string(model_str); + assert_eq!( + parsed_model, + Ok(EmbeddingModelType::OllamaTextEmbeddingsInference( + OllamaTextEmbeddingsInference::JinaEmbeddingsV2BaseEs + )) + ); + } +} \ No newline at end of file diff --git a/shinkai-libs/shinkai-embedding/src/shinkai_embedding_errors.rs b/shinkai-libs/shinkai-embedding/src/shinkai_embedding_errors.rs new file mode 100644 index 000000000..5295de0fd --- /dev/null +++ b/shinkai-libs/shinkai-embedding/src/shinkai_embedding_errors.rs @@ -0,0 +1,19 @@ +use thiserror::Error; + +#[derive(Error, Debug, PartialEq)] +pub enum ShinkaiEmbeddingError { + #[error("Request failed")] + RequestFailed(String), + #[error("Invalid model architecture")] + InvalidModelArchitecture, + #[error("Unimplemented model dimensions")] + UnimplementedModelDimensions(String), + #[error("Failed embedding generation")] + FailedEmbeddingGeneration(String), +} + +impl From for ShinkaiEmbeddingError { + fn from(error: reqwest::Error) -> Self { + ShinkaiEmbeddingError::RequestFailed(error.to_string()) + } +} diff --git a/shinkai-libs/shinkai-fs/Cargo.toml b/shinkai-libs/shinkai-fs/Cargo.toml new file mode 100644 index 000000000..498985927 --- /dev/null +++ b/shinkai-libs/shinkai-fs/Cargo.toml @@ -0,0 +1,47 @@ +[package] +name = "shinkai_fs" +version = { workspace = true } +edition = { workspace = true } +authors = { workspace = true } + +[dependencies] +shinkai_message_primitives = { workspace = true } +shinkai_embedding = { workspace = true } +shinkai_sqlite = { workspace = true } +shinkai_ocr = { workspace = true } +bincode = { workspace = true } +serde_json = { workspace = true } +rand = { workspace = true } +blake3 = { workspace = true } +tokio = { workspace = true, features = ["full"] } +chrono = { workspace = true } +comrak = { version = "0.22.0", default-features = true } +thiserror = "2.0.3" +reqwest = { workspace = true } +lazy_static = "1.5.0" +async-trait = { workspace = true } +keyphrases = { workspace = true } +futures = { workspace = true } +scraper = "0.19.0" +urlencoding = "2.1.0" + +csv = "1.1.6" +utoipa = "4.2.3" +regex = { workspace = true } + +[dependencies.serde] +workspace = true +features = ["derive"] + +[dev-dependencies] +tempfile = "3.10.1" +serial_test = "0.5" + +[[test]] +name = "pdf_parsing_tests" +path = "tests/pdf_parsing_tests.rs" +required-features = ["static-pdf-parser"] + +# [[test]] +# name = "vector_resource_tests" +# path = "tests/vector_resource_tests.rs" diff --git a/shinkai-libs/shinkai-fs/src/lib.rs b/shinkai-libs/shinkai-fs/src/lib.rs new file mode 100644 index 000000000..2a9aada98 --- /dev/null +++ b/shinkai-libs/shinkai-fs/src/lib.rs @@ -0,0 +1,6 @@ +pub mod shinkai_fs_error; +pub mod shinkai_file_manager; +pub mod shinkai_file_manager_ops; +pub mod simple_parser; +pub mod test_utils; +pub mod vrkai; diff --git a/shinkai-libs/shinkai-fs/src/shinkai_file_manager.rs b/shinkai-libs/shinkai-fs/src/shinkai_file_manager.rs new file mode 100644 index 000000000..36a213a74 --- /dev/null +++ b/shinkai-libs/shinkai-fs/src/shinkai_file_manager.rs @@ -0,0 +1,743 @@ +use std::collections::HashMap; +use std::fs; +use std::time::SystemTime; + +use chrono::{DateTime, Utc}; +use serde::Serializer; +use serde::{Deserialize, Serialize}; +use shinkai_embedding::embedding_generator::EmbeddingGenerator; +use shinkai_message_primitives::schemas::shinkai_fs::{ParsedFile, ShinkaiFileChunk}; +use shinkai_message_primitives::shinkai_utils::shinkai_path::ShinkaiPath; +use shinkai_message_primitives::shinkai_utils::utils::count_tokens_from_message_llama3; +use shinkai_sqlite::SqliteManager; +use utoipa::ToSchema; + +use crate::shinkai_fs_error::ShinkaiFsError; +use crate::simple_parser::simple_parser::SimpleParser; + +pub struct ShinkaiFileManager; + +#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, ToSchema)] +pub struct FileInfo { + pub path: String, + pub is_directory: bool, + #[serde(serialize_with = "serialize_system_time")] + pub created_time: Option, + #[serde(serialize_with = "serialize_system_time")] + pub modified_time: Option, + pub has_embeddings: bool, + pub children: Option>, + pub size: Option, // None if directory + pub name: String, // e.g. "my_doc.docx" +} + +#[derive(PartialEq, Serialize, Deserialize, Clone, ToSchema)] +pub enum FileProcessingMode { + Auto, + NoParsing, + MustParse, +} + +impl ShinkaiFileManager { + /// Save a file to disk and process it for embeddings based on the mode. + pub async fn save_and_process_file( + dest_path: ShinkaiPath, + data: Vec, + sqlite_manager: &SqliteManager, + mode: FileProcessingMode, + generator: &dyn EmbeddingGenerator, + ) -> Result<(), ShinkaiFsError> { + // Save the file to disk + Self::write_file_to_fs(dest_path.clone(), data)?; + + // Process the file for embeddings if the mode is not NoParsing + if mode != FileProcessingMode::NoParsing { + let _ = Self::process_embeddings_for_file(dest_path, sqlite_manager, mode, generator).await; + } + + Ok(()) + } + + /// Process file: If not in DB, add it. If supported, generate chunks. + /// If already processed, consider checking if file changed (not implemented here). + pub async fn process_embeddings_for_file( + path: ShinkaiPath, + sqlite_manager: &SqliteManager, + mode: FileProcessingMode, // TODO: maybe we dont need this? + generator: &dyn EmbeddingGenerator, + ) -> Result<(), ShinkaiFsError> { + if mode == FileProcessingMode::NoParsing { + return Ok(()); + } + + // Compute the relative path + let rel_path = path.relative_path(); + eprintln!("rel_path: {:?}", rel_path); + + // Check if the file is already processed + if let Some(_parsed_file) = sqlite_manager.get_parsed_file_by_rel_path(&rel_path)? { + // TODO: check if the file has changed since last processing + return Ok(()); + } + + // Steps to process a file: + // 1. Read the file content to ensure accessibility. + // 2. Divide the file content into manageable chunks. + // 3. Generate embeddings for each chunk using the specified model. + // 4. Construct a ParsedFile object and associate it with its chunks. + // 5. Persist the ParsedFile and its chunks into the database. + + // 1- Parse the file + let max_node_text_size = generator.model_type().max_input_token_count(); + let mut text_groups = SimpleParser::parse_file(path.clone(), max_node_text_size.try_into().unwrap())?; + + // Generate embeddings for each text group and assign them directly + for text_group in &mut text_groups { + let embedding = generator.generate_embedding_default(&text_group.text).await?; + text_group.embedding = Some(embedding); + } + + // Calculate total characters from all text groups + let total_characters = text_groups.iter().map(|group| group.text.chars().count() as i64).sum(); + + // Calculate total tokens using llama3 token counting + let total_tokens = text_groups.iter() + .map(|group| count_tokens_from_message_llama3(&group.text) as i64) + .sum(); + + // Add the parsed file to the database + let parsed_file = ParsedFile { + id: None, // Expected. The DB will auto-generate the id. + relative_path: rel_path.to_string(), + original_extension: path.extension().map(|s| s.to_string()), + description: None, // TODO: connect this + source: None, // TODO: connect this + embedding_model_used: Some(generator.model_type().to_string()), + keywords: None, // TODO: connect this + distribution_info: None, // TODO: connect this + created_time: Some(Self::current_timestamp()), + tags: None, // TODO: connect this + total_tokens: Some(total_tokens), + total_characters: Some(total_characters), + }; + + sqlite_manager.add_parsed_file(&parsed_file)?; + + // Retrieve the parsed file ID + let parsed_file_id = sqlite_manager + .get_parsed_file_by_rel_path(&rel_path)? + .ok_or(ShinkaiFsError::FailedToRetrieveParsedFileID)? + .id + .unwrap(); + + // Create and add chunks to the database + for (position, text_group) in text_groups.iter().enumerate() { + let chunk = ShinkaiFileChunk { + chunk_id: None, + parsed_file_id, + position: position as i64, + content: text_group.text.clone(), + }; + sqlite_manager + .create_chunk_with_embedding(&chunk, Some(&text_group.embedding.as_ref().unwrap().clone()))?; + } + + Ok(()) + } + + pub fn get_all_files_and_folders_for_job( + job_id: &str, + sqlite_manager: &SqliteManager, + ) -> Result, ShinkaiFsError> { + // Get the job folder name using the SqliteManager + let folder_path = sqlite_manager.get_job_folder_name(job_id)?; + + // Use the existing list_directory_contents method to get the files and folders + Self::list_directory_contents(folder_path, sqlite_manager) + } + + /// Single-level listing only (no recursion). + pub fn list_directory_contents( + path: ShinkaiPath, + sqlite_manager: &SqliteManager, + ) -> Result, ShinkaiFsError> { + Self::gather_directory_contents(&path, sqlite_manager, /*current_depth=*/0, /*max_depth=*/0) + } + + /// Recursively list files/folders up to `max_depth`. + pub fn list_directory_contents_with_depth( + path: ShinkaiPath, + sqlite_manager: &SqliteManager, + max_depth: usize, + ) -> Result, ShinkaiFsError> { + Self::gather_directory_contents(&path, sqlite_manager, /*current_depth=*/0, max_depth) + } + + /// Private helper that does the actual directory reading. + /// - `current_depth` starts at 0 + /// - If `current_depth < max_depth`, we recurse into subdirectories + fn gather_directory_contents( + path: &ShinkaiPath, + sqlite_manager: &SqliteManager, + current_depth: usize, + max_depth: usize, + ) -> Result, ShinkaiFsError> { + let mut contents = Vec::new(); + let rel_path = path.relative_path(); + + for entry in std::fs::read_dir(path.as_path())? { + let entry = entry?; + let metadata = entry.metadata()?; + + let file_name = entry.file_name().into_string().unwrap_or_default(); + let shinkai_path = ShinkaiPath::new(&format!("{}/{}", rel_path, file_name)); + + let mut file_info = FileInfo { + path: shinkai_path.relative_path().to_string(), + is_directory: metadata.is_dir(), + created_time: metadata.created().ok(), + modified_time: metadata.modified().ok(), + has_embeddings: false, + children: None, + size: if metadata.is_file() { + Some(metadata.len()) + } else { + None + }, + name: file_name.clone(), + }; + + // If it's a directory and we can still go deeper, recurse + if file_info.is_directory && current_depth < max_depth { + file_info.children = Some(Self::gather_directory_contents( + &shinkai_path, + sqlite_manager, + current_depth + 1, + max_depth, + )?); + } else if !file_info.is_directory { + // Lookup embeddings directly in the DB + let maybe_parsed_file = sqlite_manager.get_parsed_file_by_rel_path(&file_info.path)?; + file_info.has_embeddings = maybe_parsed_file.is_some(); + } + + contents.push(file_info); + } + Ok(contents) + } + + /// Constructs the full path for a file within a job folder. + pub fn construct_job_file_path( + job_id: &str, + file_name: &str, + sqlite_manager: &SqliteManager, + ) -> Result { + // Get the job folder path + let folder_path = sqlite_manager.get_and_create_job_folder(job_id)?; + + // Get the relative path from the job folder to avoid double base path + let relative_path = folder_path.relative_path(); + + // Construct the relative path for the file + let file_relative_path = format!("{}/{}", relative_path, file_name); + + // Create a new ShinkaiPath from the relative path + Ok(ShinkaiPath::from_string(file_relative_path)) + } + + /// Save a file to a job-specific directory and process it for embeddings. + /// This function determines the job folder path, constructs the file path, + /// and then saves and processes the file using the specified mode and generator. + pub async fn save_and_process_file_with_jobid( + job_id: &str, + file_name: String, + data: Vec, + sqlite_manager: &SqliteManager, + mode: FileProcessingMode, + generator: &dyn EmbeddingGenerator, + ) -> Result { + // Use the new construct_job_file_path function + let shinkai_path = Self::construct_job_file_path(job_id, &file_name, sqlite_manager)?; + + // Use the existing save_and_process_file function to save and process the file + Self::save_and_process_file(shinkai_path.clone(), data, sqlite_manager, mode, generator).await?; + + Ok(shinkai_path) + } + + /// Get the content of a file based on a ShinkaiPath. + pub fn get_file_content(path: ShinkaiPath) -> Result, ShinkaiFsError> { + let content = fs::read(path.as_path()) + .map_err(|_| ShinkaiFsError::FailedToReadFile(path.as_path().to_string_lossy().to_string()))?; + Ok(content) + } +} + +// Custom serializer for SystemTime to ISO8601 +fn serialize_system_time(time: &Option, serializer: S) -> Result +where + S: Serializer, +{ + if let Some(system_time) = time { + let datetime: DateTime = (*system_time).into(); + return serializer.serialize_some(&datetime.to_rfc3339()); + } + serializer.serialize_none() +} + +#[cfg(test)] +mod tests { + use super::*; + use serial_test::serial; + use shinkai_embedding::mock_generator::MockGenerator; + use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; + use shinkai_message_primitives::schemas::shinkai_fs::ParsedFile; + use shinkai_message_primitives::shinkai_utils::job_scope::MinimalJobScope; + use std::fs::{self, File}; + use std::io::Write; + use std::path::{Path, PathBuf}; + use tempfile::{tempdir, NamedTempFile}; + + fn setup_test_db() -> SqliteManager { + let temp_file = NamedTempFile::new().unwrap(); + let db_path = PathBuf::from(temp_file.path()); + eprintln!("db_path: {:?}", db_path); + + // Delete the database file if it exists + if db_path.exists() { + std::fs::remove_file(&db_path).unwrap_or_else(|e| { + eprintln!("Failed to delete existing database file: {}", e); + }); + } + + let api_url = String::new(); + let model_type = + EmbeddingModelType::OllamaTextEmbeddingsInference(OllamaTextEmbeddingsInference::SnowflakeArcticEmbed_M); + + SqliteManager::new(db_path, api_url, model_type).unwrap() + } + + fn create_test_parsed_file(id: i64, relative_path: &str) -> ParsedFile { + ParsedFile { + id: Some(id), + relative_path: relative_path.to_string(), + original_extension: None, + description: None, + source: None, + embedding_model_used: None, + keywords: None, + distribution_info: None, + created_time: None, + tags: None, + total_tokens: None, + total_characters: None, + } + } + + // Helper function to set up a test environment + fn setup_test_environment() -> (SqliteManager, tempfile::TempDir, ShinkaiPath, MockGenerator) { + let db = setup_test_db(); + + // Initialize the database tables + let conn = db.get_connection().unwrap(); + SqliteManager::initialize_filesystem_tables(&conn).unwrap(); + + // Create a temporary directory and file path + let dir = tempdir().unwrap(); + let file_path = "test_file.txt".to_string(); + + // Set the environment variable to the temporary directory path + std::env::set_var("NODE_STORAGE_PATH", dir.path().to_string_lossy().to_string()); + + let vr_path = ShinkaiPath::from_base_path(); + eprintln!("vr_path: {:?}", vr_path.as_path()); + + // Check if the directory exists, and create it if it doesn't + if !Path::new(&vr_path.as_path()).exists() { + let _ = fs::create_dir_all(&vr_path.as_path()).map_err(|e| { + eprintln!("Failed to create directory {}: {}", vr_path.as_path().display(), e); + }); + } + + // Create a mock embedding generator + let model_type = + EmbeddingModelType::OllamaTextEmbeddingsInference(OllamaTextEmbeddingsInference::SnowflakeArcticEmbed_M); + let generator = MockGenerator::new(model_type, 384); // 128 is the number of floats in the mock embedding + + (db, dir, ShinkaiPath::from_string(file_path), generator) + } + + fn create_new_job(db: &SqliteManager, job_id: String, agent_id: String, scope: MinimalJobScope) { + match db.create_new_job(job_id, agent_id, scope, false, None, None) { + Ok(_) => (), + Err(e) => panic!("Failed to create a new job: {}", e), + } + } + + // Helper function to write large content to a file + fn write_large_content(file: &mut File) { + let large_content = [ + "This is the first part of the test file. It contains some initial text to start the file processing. ", + "Here is the second part of the test file. It adds more content to ensure the file is large enough. ", + "Finally, this is the third part of the test file. It completes the content needed for multiple chunks. ", + "Additional content to ensure the file is sufficiently large for testing purposes. This should help in generating multiple chunks. ", + "More content to further increase the size of the file. This should definitely ensure multiple chunks are created. ", + "Even more content to make sure we exceed the threshold for chunking. This is important for testing the chunking logic. ", + "Continuing to add content to ensure the file is large enough. This should be more than sufficient for the test. ", + "Final addition of content to make sure we have enough text. This should cover all bases for the chunking test." + ].join(""); + writeln!(file, "{}", large_content).unwrap(); + } + + #[test] + #[serial] + fn test_list_directory_contents() { + let (db, _dir, _shinkai_path, _generator) = setup_test_environment(); + + // Create a temporary directory + let dir_path = ShinkaiPath::from_base_path(); + + // Create a subdirectory and a file inside the temporary directory + let subdir_path = ShinkaiPath::from_string("subdir".to_string()); + fs::create_dir(&subdir_path.path).unwrap(); + + let file_path = ShinkaiPath::from_string("test_file.txt".to_string()); + let mut file = File::create(&file_path.path).unwrap(); + writeln!(file, "Hello, Shinkai!").unwrap(); + + // Call the function to list directory contents + let contents = ShinkaiFileManager::list_directory_contents(dir_path, &db).unwrap(); + + // Check that the directory contents are correct + assert_eq!(contents.len(), 2); + + let mut found_subdir = false; + let mut found_file = false; + + for entry in contents { + if entry.path == "subdir" && entry.is_directory { + found_subdir = true; + } else if entry.path == "test_file.txt" && !entry.is_directory { + found_file = true; + } + } + + assert!(found_subdir, "Subdirectory 'subdir' should be found."); + assert!(found_file, "File 'test_file.txt' should be found."); + } + + #[test] + #[serial] + fn test_list_directory_contents_with_db_entries() { + let (db, _dir, _shinkai_path, _generator) = setup_test_environment(); + + // Initialize the database tables + let conn = db.get_connection().unwrap(); + SqliteManager::initialize_filesystem_tables(&conn).unwrap(); + + let pf1_path = ShinkaiPath::from_string("january.txt".to_string()); + let pf2_path = ShinkaiPath::from_string("february.txt".to_string()); + + // Add parsed files with different relative paths + let pf1 = create_test_parsed_file(1, &pf1_path.relative_path()); + let pf2 = create_test_parsed_file(2, &pf2_path.relative_path()); + db.add_parsed_file(&pf1).unwrap(); + db.add_parsed_file(&pf2).unwrap(); + + // Create a temporary directory + let dir_path = ShinkaiPath::from_base_path(); + + // Create files in the temporary directory to match the database entries + let mut file1 = File::create(&pf1_path.as_path()).unwrap(); + writeln!(file1, "January report").unwrap(); + + let mut file2 = File::create(&pf2_path.as_path()).unwrap(); + writeln!(file2, "February report").unwrap(); + + // Create a file that is not in the database + let pf3_path = ShinkaiPath::from_string("march.txt".to_string()); + let mut file3 = File::create(&pf3_path.as_path()).unwrap(); + writeln!(file3, "March report").unwrap(); + + // Create a subdirectory + let subdir_path = ShinkaiPath::from_string("subdir".to_string()); + fs::create_dir(&subdir_path.as_path()).unwrap(); + + // Call the function to list directory contents + let contents = ShinkaiFileManager::list_directory_contents(dir_path, &db).unwrap(); + eprintln!("contents: {:?}", contents); + + // Check that the directory contents are correct + assert_eq!(contents.len(), 4); + + let mut found_january = false; + let mut found_february = false; + let mut found_march = false; + let mut found_subdir = false; + + for entry in contents { + if entry.path == "january.txt" && !entry.is_directory { + found_january = true; + assert!(entry.has_embeddings, "File 'january.txt' should have embeddings."); + } else if entry.path == "february.txt" && !entry.is_directory { + found_february = true; + assert!(entry.has_embeddings, "File 'february.txt' should have embeddings."); + } else if entry.path == "march.txt" && !entry.is_directory { + found_march = true; + assert!(!entry.has_embeddings, "File 'march.txt' should not have embeddings."); + } else if entry.path == "subdir" && entry.is_directory { + found_subdir = true; + } + } + + assert!(found_january, "File 'january.txt' should be found."); + assert!(found_february, "File 'february.txt' should be found."); + assert!(found_march, "File 'march.txt' should be found."); + assert!(found_subdir, "Directory 'subdir' should be found."); + } + + #[tokio::test] + #[serial] + async fn test_process_file() { + let (db, dir, shinkai_path, generator) = setup_test_environment(); + + // Create and write to the file + let mut file = File::create(shinkai_path.as_path()).unwrap(); + write_large_content(&mut file); + + // Call the process_embeddings_for_file function + let result = ShinkaiFileManager::process_embeddings_for_file( + shinkai_path.clone(), + &db, + FileProcessingMode::Auto, + &generator, + ) + .await; + + // Assert the result is Ok + assert!(result.is_ok()); + + // Verify the file is added to the database + let parsed_file = db.get_parsed_file_by_rel_path("test_file.txt").unwrap(); + assert!(parsed_file.is_some()); + + // Verify the chunks are added to the database + let parsed_file_id = parsed_file.unwrap().id.unwrap(); + let chunks = db.get_chunks_for_parsed_file(parsed_file_id).unwrap(); + println!("chunks: {:?}", chunks); // Debugging output + assert!(chunks.len() >= 2, "Expected at least 2 chunks, found {}", chunks.len()); + + // Clean up + dir.close().unwrap(); + } + + #[tokio::test] + #[serial] + async fn test_save_and_process_file() { + let (db, dir, shinkai_path, generator) = setup_test_environment(); + + // Prepare the data to be written + let mut file = File::create(shinkai_path.as_path()).unwrap(); + write_large_content(&mut file); + let data = std::fs::read(shinkai_path.as_path()).unwrap(); + + // Call the save_and_process_file function + let result = ShinkaiFileManager::save_and_process_file( + shinkai_path.clone(), + data, + &db, + FileProcessingMode::Auto, + &generator, + ) + .await; + + // Assert the result is Ok + assert!(result.is_ok()); + + // Verify the file is added to the database + let parsed_file = db.get_parsed_file_by_rel_path("test_file.txt").unwrap(); + assert!(parsed_file.is_some()); + + // Verify the chunks are added to the database + let parsed_file_id = parsed_file.unwrap().id.unwrap(); + let chunks = db.get_chunks_for_parsed_file(parsed_file_id).unwrap(); + assert!(chunks.len() >= 2, "Expected at least 2 chunks, found {}", chunks.len()); + + // Clean up + dir.close().unwrap(); + } + + #[tokio::test] + #[serial] + async fn test_create_job_and_upload_file() { + let (db, _dir, _shinkai_path, generator) = setup_test_environment(); + + let job_id = "test_job".to_string(); + let job_inbox = "job_inbox::test_job::false".to_string(); + let agent_id = "agent_test".to_string(); + let scope = MinimalJobScope::default(); + + // Create a new job + create_new_job(&db, job_id.clone(), agent_id.clone(), scope); + + // Update the smart inbox name + let new_inbox_name = "Updated Inbox Name"; + db.unsafe_update_smart_inbox_name(&job_inbox, new_inbox_name).unwrap(); + + // Get and create the job folder + let folder_path = db.get_and_create_job_folder(&job_id).unwrap(); + + // Prepare the data to be written + let file_name = "test_file.txt"; + let file_content = b"Hello, Shinkai!".to_vec(); + let file_path = folder_path.as_path().join(file_name); + let file_path = ShinkaiPath::from_string(file_path.to_string_lossy().to_string()); + + // Use save_and_process_file to save and process the file + let result = ShinkaiFileManager::save_and_process_file( + file_path.clone(), + file_content, + &db, + FileProcessingMode::Auto, + &generator, + ) + .await; + + // Assert the result is Ok + assert!(result.is_ok()); + + // Verify the file is added to the database + let folder_and_filename = file_path.relative_path(); + + let parsed_file = db.get_parsed_file_by_rel_path(&folder_and_filename).unwrap(); + assert!(parsed_file.is_some()); + + // List directory contents and check the file is listed + let contents = ShinkaiFileManager::list_directory_contents(folder_path, &db).unwrap(); + eprintln!("conents: {:?}", contents); + let file_names: Vec = contents.iter().map(|info| info.path.clone()).collect(); + assert!( + file_names.iter().any(|path| path.contains(&file_name)), + "File '{}' should be listed in the directory contents.", + file_name + ); + } + + #[test] + #[serial] + fn test_get_file_content() { + let (_db, _dir, _shinkai_path, _generator) = setup_test_environment(); + + // Create a specific file path within the temporary directory + let file_name = "test_file.txt"; + let file_path = ShinkaiPath::from_string(file_name.to_string()); + + // Create and write to the file + let mut file = File::create(file_path.as_path()).unwrap(); + writeln!(file, "Hello, Shinkai!").unwrap(); + + // Call the get_file_content function + let content = ShinkaiFileManager::get_file_content(file_path.clone()); + + // Assert the content is as expected + assert!(content.is_ok()); + assert_eq!(content.unwrap(), b"Hello, Shinkai!\n".to_vec()); + } + + #[test] + #[serial] + fn test_construct_job_file_path() { + let db = setup_test_db(); + let job_id = "test_job"; + let agent_id = "agent_test"; + let scope = MinimalJobScope::default(); + + // Create a new job in the database + db.create_new_job(job_id.to_string(), agent_id.to_string(), scope, false, None, None) + .expect("Failed to create a new job"); + + // Call the construct_job_file_path function + let file_name = "test_file.txt"; + let result = ShinkaiFileManager::construct_job_file_path(job_id, file_name, &db); + eprintln!("result: {:?}", result); + + // Assert the result is Ok + assert!(result.is_ok()); + + // Verify the constructed path + let shinkai_path = result.unwrap(); + let expected_folder_path = db.get_and_create_job_folder(job_id).unwrap(); + let expected_path = expected_folder_path.as_path().join(file_name); + assert_eq!(shinkai_path.as_path().to_string_lossy(), expected_path.to_string_lossy()); + } + + #[test] + #[serial] + fn test_list_directory_contents_with_depth() { + let (db, _dir, _shinkai_path, _generator) = setup_test_environment(); + + // Create a temporary directory structure + let base_dir = ShinkaiPath::from_base_path(); + let level1_dir = base_dir.as_path().join("level1"); + let level2_dir = level1_dir.join("level2"); + let level3_dir = level2_dir.join("level3"); + + fs::create_dir_all(&level3_dir.as_path()).unwrap(); + + // Create files at different levels + let file1_path = level1_dir.join("file1.txt"); + let file2_path = level2_dir.join("file2.txt"); + let file3_path = level3_dir.join("file3.txt"); + + File::create(&file1_path.as_path()).unwrap(); + File::create(&file2_path.as_path()).unwrap(); + File::create(&file3_path.as_path()).unwrap(); + + // Add parsed files with embeddings to the database + let pf1 = create_test_parsed_file(1, &ShinkaiPath::from_string("level1/file1.txt".to_string()).relative_path()); + let pf2 = create_test_parsed_file(2, &ShinkaiPath::from_string("level1/level2/file2.txt".to_string()).relative_path()); + db.add_parsed_file(&pf1).unwrap(); + db.add_parsed_file(&pf2).unwrap(); + + // Call the function to list directory contents with depth 3 + let contents = ShinkaiFileManager::list_directory_contents_with_depth(base_dir, &db, 3).unwrap(); + eprintln!("contents: {:?}", contents); + + // Check that the directory contents are correct + assert_eq!(contents.len(), 1); // Only one top-level directory + + let level1_info = &contents[0]; + assert_eq!(level1_info.path, "level1"); + assert!(level1_info.is_directory); + assert!(level1_info.children.is_some()); + + let level2_contents = level1_info.children.as_ref().unwrap(); + assert_eq!(level2_contents.len(), 2); // One directory and one file + + let file1_info = level2_contents.iter().find(|info| info.path == "level1/file1.txt").unwrap(); + assert!(!file1_info.is_directory); + assert!(file1_info.has_embeddings, "File 'level1/file1.txt' should have embeddings."); + + let level2_info = level2_contents.iter().find(|info| info.path == "level1/level2").unwrap(); + assert!(level2_info.is_directory); + assert!(level2_info.children.is_some()); + + let level3_contents = level2_info.children.as_ref().unwrap(); + assert_eq!(level3_contents.len(), 2); // One directory and one file + + let file2_info = level3_contents.iter().find(|info| info.path == "level1/level2/file2.txt").unwrap(); + assert!(!file2_info.is_directory); + assert!(file2_info.has_embeddings, "File 'level1/level2/file2.txt' should have embeddings."); + + let level3_info = level3_contents.iter().find(|info| info.path == "level1/level2/level3").unwrap(); + assert!(level3_info.is_directory); + assert!(level3_info.children.is_some()); + + let level3_files = level3_info.children.as_ref().unwrap(); + assert_eq!(level3_files.len(), 1); // Only one file + + let file3_info = level3_files.iter().find(|info| info.path == "level1/level2/level3/file3.txt").unwrap(); + assert!(!file3_info.is_directory); + assert!(!file3_info.has_embeddings, "File 'level1/level2/level3/file3.txt' should not have embeddings."); + } +} diff --git a/shinkai-libs/shinkai-fs/src/shinkai_file_manager_ops.rs b/shinkai-libs/shinkai-fs/src/shinkai_file_manager_ops.rs new file mode 100644 index 000000000..12f5e657e --- /dev/null +++ b/shinkai-libs/shinkai-fs/src/shinkai_file_manager_ops.rs @@ -0,0 +1,671 @@ +use std::fs; + +use shinkai_message_primitives::shinkai_utils::shinkai_path::ShinkaiPath; +use shinkai_sqlite::SqliteManager; + +use shinkai_message_primitives::schemas::shinkai_fs::ParsedFile; + +use crate::shinkai_file_manager::ShinkaiFileManager; +use crate::shinkai_fs_error::ShinkaiFsError; + +impl ShinkaiFileManager { + /// Add a file: writes a file from `data` to a relative path under `base_dir`. + pub fn write_file_to_fs(dest_path: ShinkaiPath, data: Vec) -> Result<(), ShinkaiFsError> { + // Ensure the parent directory exists + fs::create_dir_all(dest_path.as_path().parent().unwrap())?; + + // Write the data to the destination path + fs::write(dest_path.as_path(), data)?; + + Ok(()) + } + + /// Remove file: deletes file from filesystem and DB. + pub fn remove_file(path: ShinkaiPath, sqlite_manager: &SqliteManager) -> Result<(), ShinkaiFsError> { + // Check if file exists on filesystem + if !path.exists() { + return Err(ShinkaiFsError::FileNotFoundOnFilesystem); + } + + // Remove from filesystem + fs::remove_file(path.as_path())?; + + // Update DB + let rel_path = path.relative_path(); + if let Some(parsed_file) = sqlite_manager.get_parsed_file_by_rel_path(&rel_path)? { + if let Some(parsed_file_id) = parsed_file.id { + // Remove associated chunks if they exist + if let Ok(chunks) = sqlite_manager.get_chunks_for_parsed_file(parsed_file_id) { + for chunk in chunks { + if let Some(chunk_id) = chunk.chunk_id { + sqlite_manager.remove_chunk_with_embedding(chunk_id)?; + } + } + } + // Remove the parsed file entry + sqlite_manager.remove_parsed_file(parsed_file_id)?; + } + } + + Ok(()) + } + + /// Create folder: just create a directory on the filesystem. + /// No DB changes since we don't store directories in DB. + pub fn create_folder(path: ShinkaiPath) -> Result<(), ShinkaiFsError> { + fs::create_dir_all(path.as_path())?; + Ok(()) + } + + /// Remove folder: remove a directory and all its contents from the filesystem. + /// This does not directly affect the DB, but any files in that folder + /// should have been removed first. If not, scanning the DB for files + /// might be necessary. + pub fn remove_folder(path: ShinkaiPath, sqlite_manager: &SqliteManager) -> Result<(), ShinkaiFsError> { + if !path.exists() { + return Err(ShinkaiFsError::FolderNotFoundOnFilesystem); + } + + // Iterate over each file or directory in the directory + for entry in fs::read_dir(path.as_path())? { + let entry = entry?; + let file_path = ShinkaiPath::from_str(entry.path().to_str().unwrap()); + + if file_path.is_file() { + // Remove the file and its embeddings + Self::remove_file(file_path, sqlite_manager)?; + } else if file_path.as_path().is_dir() { + // Recursively remove subdirectories + Self::remove_folder(file_path, sqlite_manager)?; + } + } + + // Remove the directory itself + fs::remove_dir(path.as_path())?; + Ok(()) + } + + /// Rename file: rename a file in the filesystem and update `ParsedFile.relative_path` in DB. + pub fn rename_file( + old_path: ShinkaiPath, + new_path: ShinkaiPath, + sqlite_manager: &SqliteManager, + ) -> Result<(), ShinkaiFsError> { + // Debugging: Check if the old file exists + if !old_path.exists() { + println!("Old file does not exist: {:?}", old_path); + return Err(ShinkaiFsError::FileNotFoundOnFilesystem); + } + + let new_rel_path = new_path.relative_path(); + + // Check if the parent directory of the new path exists + let parent_dir = new_path.as_path().parent().unwrap(); + if !parent_dir.exists() { + fs::create_dir_all(parent_dir)?; + } + + fs::rename(old_path.as_path(), &new_path.as_path())?; + + // Update DB + let old_rel_path = old_path.relative_path(); + if let Some(mut parsed_file) = sqlite_manager.get_parsed_file_by_rel_path(&old_rel_path)? { + parsed_file.relative_path = new_path.relative_path().to_string(); + sqlite_manager.update_parsed_file(&parsed_file)?; + } else { + // File not found in DB is not necessarily an error, it just means that it doesn't have embeddings. + eprintln!( + "Rename File not found in DB: {:?} (it just doesn't have embeddings)", + old_path + ); + } + + Ok(()) + } + + /// Move file: effectively the same as renaming a file to a new directory. + pub fn move_file( + old_path: ShinkaiPath, + new_path: ShinkaiPath, + sqlite_manager: &SqliteManager, + ) -> Result<(), ShinkaiFsError> { + Self::rename_file(old_path, new_path, sqlite_manager) + } + + /// Move folder: like rename_folder, but the new folder can be somewhere else entirely in the directory tree. + pub fn move_folder( + old_path: ShinkaiPath, + new_path: ShinkaiPath, + sqlite_manager: &SqliteManager, + ) -> Result<(), ShinkaiFsError> { + // Check if the old folder exists + if !old_path.exists() { + println!("Old folder does not exist: {:?}", old_path); + return Err(ShinkaiFsError::FolderNotFoundOnFilesystem); + } + + let new_rel_path = new_path.relative_path(); + + // Check if the parent directory of the new path exists + let parent_dir = new_path.as_path().parent().unwrap(); + if !parent_dir.exists() { + fs::create_dir_all(parent_dir)?; + } + + fs::rename(old_path.as_path(), &new_path.as_path())?; + + // Update DB for all parsed_files under old_path + let old_rel_path = old_path.relative_path(); + let all_files = sqlite_manager.get_parsed_files_by_prefix(&old_rel_path)?; + for mut pf in all_files { + let remainder = &pf.relative_path[old_rel_path.len()..]; + pf.relative_path = format!("{}{}", new_rel_path, remainder); + sqlite_manager.update_parsed_file(&pf)?; + } + + Ok(()) + } + + /// Check if file is supported for embedding (placeholder). + pub fn is_supported_for_embedding(parsed_file: &ParsedFile) -> bool { + match parsed_file.original_extension.as_deref() { + Some("txt") | Some("pdf") | Some("doc") => true, + _ => false, + } + } + + /// Returns the current UNIX timestamp (in seconds). + pub fn current_timestamp() -> i64 { + use std::time::{SystemTime, UNIX_EPOCH}; + let start = SystemTime::now(); + let since_epoch = start.duration_since(UNIX_EPOCH).unwrap(); + since_epoch.as_secs() as i64 + } + + /// Splits text into chunks of approximately `chunk_size` characters. + pub fn chunk_text(text: &str, chunk_size: usize) -> Vec { + text.chars() + .collect::>() + .chunks(chunk_size) + .map(|c| c.iter().collect()) + .collect() + } + + /// Copy file: copies a file from `input_path` to `destination_path`. + /// `destination_path` is the directory where the file should be copied. + pub fn copy_file(input_path: ShinkaiPath, destination_path: ShinkaiPath) -> Result<(), ShinkaiFsError> { + // Ensure the parent directory of the destination path exists + fs::create_dir_all(destination_path.as_path())?; + + // Derive the file name from the input path + let file_name = input_path.as_path().file_name().unwrap(); + + // Construct the full destination path + let full_destination_path = destination_path.as_path().join(file_name); + + // Copy the file + fs::copy(input_path.as_path(), full_destination_path)?; + + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use crate::shinkai_file_manager::FileProcessingMode; + + use super::*; + use serial_test::serial; + use shinkai_embedding::mock_generator::MockGenerator; + use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; + use shinkai_message_primitives::schemas::shinkai_fs::ShinkaiFileChunk; + use std::fs::{self, File}; + use std::io::Read; + use std::path::PathBuf; + use tempfile::{tempdir, NamedTempFile}; + + fn setup_test_db() -> SqliteManager { + let temp_file = NamedTempFile::new().unwrap(); + let db_path = PathBuf::from(temp_file.path()); + let api_url = String::new(); + let model_type = + EmbeddingModelType::OllamaTextEmbeddingsInference(OllamaTextEmbeddingsInference::SnowflakeArcticEmbed_M); + + SqliteManager::new(db_path, api_url, model_type).unwrap() + } + + fn create_test_parsed_file(id: i64, relative_path: &str) -> ParsedFile { + ParsedFile { + id: Some(id), + relative_path: relative_path.to_string(), + original_extension: None, + description: None, + source: None, + embedding_model_used: None, + keywords: None, + distribution_info: None, + created_time: None, + tags: None, + total_tokens: None, + total_characters: None, + } + } + + #[test] + #[serial] + fn test_remove_empty_folder() { + let dir = tempdir().unwrap(); + let path = ShinkaiPath::from_string(dir.path().to_string_lossy().to_string()); + + // Create an empty folder + fs::create_dir_all(path.as_path()).unwrap(); + + // Setup the test database + let sqlite_manager = setup_test_db(); + + // Attempt to remove the empty folder + assert!(ShinkaiFileManager::remove_folder(path.clone(), &sqlite_manager).is_ok()); + + // Ensure the folder is removed + assert!(!path.exists()); + } + + #[test] + #[serial] + fn test_remove_non_empty_folder() { + let dir = tempdir().unwrap(); + + // Set the environment variable to the temporary directory path + std::env::set_var("NODE_STORAGE_PATH", dir.path().to_string_lossy().to_string()); + + let folder_path = ShinkaiPath::new("test_folder"); + fs::create_dir_all(folder_path.as_path()).unwrap(); + + let file_path = ShinkaiPath::new("test_folder/test_file.txt"); + File::create(file_path.as_path()).unwrap(); + + // let base_path = ShinkaiPath::from_base_path(); + // eprintln!("base_path: {:?}", base_path); + + // Setup the test database + let sqlite_manager = setup_test_db(); + + // Add a parsed file and chunks to the database + let parsed_file = create_test_parsed_file(1, "test_folder/test_file.txt"); + sqlite_manager.add_parsed_file(&parsed_file).unwrap(); + + let chunk = ShinkaiFileChunk { + chunk_id: None, + parsed_file_id: parsed_file.id.unwrap(), + position: 1, + content: "This is a test chunk.".to_string(), + }; + sqlite_manager.create_chunk_with_embedding(&chunk, None).unwrap(); + + // Attempt to remove the non-empty folder + assert!(ShinkaiFileManager::remove_folder(folder_path.clone(), &sqlite_manager).is_ok()); + + // Ensure the folder is removed + assert!(!folder_path.exists()); + + // Verify the file and its chunks are removed from the database + let chunks = sqlite_manager.get_chunks_for_parsed_file(parsed_file.id.unwrap()); + + assert!( + chunks.unwrap().is_empty(), + "Chunks should be removed from the database." + ); + } + + #[test] + #[serial] + fn test_add_file() { + let dir = tempdir().unwrap(); + let path = ShinkaiPath::from_string(dir.path().join("test_file.txt").to_string_lossy().to_string()); + let data = b"Hello, Shinkai!".to_vec(); + + // Add the file + assert!(ShinkaiFileManager::write_file_to_fs(path.clone(), data.clone()).is_ok()); + + // Verify the file exists and contains the correct data + let mut file = File::open(path.as_path()).unwrap(); + let mut contents = Vec::new(); + file.read_to_end(&mut contents).unwrap(); + assert_eq!(contents, data); + } + + #[test] + #[serial] + fn test_rename_file_without_embeddings() { + let dir = tempdir().unwrap(); + + // Set the environment variable to the temporary directory path + std::env::set_var("NODE_STORAGE_PATH", dir.path().to_string_lossy().to_string()); + + let old_path = ShinkaiPath::from_string("old_file.txt".to_string()); + let new_path = ShinkaiPath::from_string("new_file.txt".to_string()); + + let data = b"Hello, Shinkai!".to_vec(); + + // Create the original file + ShinkaiFileManager::write_file_to_fs(old_path.clone(), data.clone()).unwrap(); + + // Setup the test database + let sqlite_manager = setup_test_db(); + + // List directory contents + let contents = + ShinkaiFileManager::list_directory_contents(ShinkaiPath::from_base_path(), &sqlite_manager).unwrap(); + eprintln!("contents: {:?}", contents); + + // Verify the file is listed + let mut found_file = false; + for entry in contents { + if entry.path == "old_file.txt" && !entry.is_directory { + found_file = true; + assert!(!entry.has_embeddings, "File 'old_file.txt' should not have embeddings."); + } + } + + assert!(found_file, "File 'old_file.txt' should be found in the directory."); + + // Rename the file + let rename_result = ShinkaiFileManager::rename_file(old_path.clone(), new_path.clone(), &sqlite_manager); + assert!( + rename_result.is_ok(), + "Renaming the file should succeed: {:?}", + rename_result + ); + + // Verify the old file does not exist and the new file does + assert!(!old_path.exists(), "The old file should not exist after renaming."); + assert!(new_path.exists(), "The new file should exist after renaming."); + } + + #[tokio::test] + #[serial] + async fn test_rename_file_with_embeddings() { + let dir = tempdir().unwrap(); + + // Set the environment variable to the temporary directory path + std::env::set_var("NODE_STORAGE_PATH", dir.path().to_string_lossy().to_string()); + + let old_path = ShinkaiPath::from_string("old_file.txt".to_string()); + let new_path = ShinkaiPath::from_string("new_file.txt".to_string()); + + let data = b"Hello, Shinkai!".to_vec(); + + // Create the original file + ShinkaiFileManager::write_file_to_fs(old_path.clone(), data.clone()).unwrap(); + + // Setup the test database + let sqlite_manager = setup_test_db(); + + // List directory contents + let contents = + ShinkaiFileManager::list_directory_contents(ShinkaiPath::from_base_path(), &sqlite_manager).unwrap(); + eprintln!("contents: {:?}", contents); + + // Verify the file is listed + let mut found_file = false; + for entry in contents { + if entry.path == "old_file.txt" && !entry.is_directory { + found_file = true; + assert!(!entry.has_embeddings, "File 'old_file.txt' should not have embeddings."); + } + } + + assert!(found_file, "File 'old_file.txt' should be found in the directory."); + + let mock_generator = MockGenerator::new( + EmbeddingModelType::OllamaTextEmbeddingsInference(OllamaTextEmbeddingsInference::SnowflakeArcticEmbed_M), + 10, + ); + + // Add embeddings to the file + let _ = ShinkaiFileManager::process_embeddings_for_file( + old_path.clone(), + &sqlite_manager, + FileProcessingMode::Auto, + &mock_generator, + ) + .await; + + // Rename the file + let rename_result = ShinkaiFileManager::rename_file(old_path.clone(), new_path.clone(), &sqlite_manager); + assert!( + rename_result.is_ok(), + "Renaming the file should succeed: {:?}", + rename_result + ); + + // Verify the old file does not exist and the new file does + assert!(!old_path.exists(), "The old file should not exist after renaming."); + assert!(new_path.exists(), "The new file should exist after renaming."); + + let results = sqlite_manager.debug_get_all_parsed_files(); + eprintln!("results: {:?}", results); + + // Check that the file path with the embeddings were updated in the db + if let Some(parsed_file) = sqlite_manager + .get_parsed_file_by_rel_path(&new_path.relative_path()) + .unwrap() + { + assert_eq!( + parsed_file.relative_path, + new_path.relative_path(), + "The relative path in the database should be updated to the new path." + ); + } else { + panic!("The file should be found in the database with the updated path."); + } + } + + #[test] + #[serial] + fn test_copy_file() { + let dir = tempdir().unwrap(); + + // Set the environment variable to the temporary directory path + std::env::set_var("NODE_STORAGE_PATH", dir.path().to_string_lossy().to_string()); + + let input_path = ShinkaiPath::from_string("input_file.txt".to_string()); + let destination_dir = ShinkaiPath::from_string("destination_dir".to_string()); + let data = b"Hello, Shinkai!".to_vec(); + + // Add the input file + assert!(ShinkaiFileManager::write_file_to_fs(input_path.clone(), data.clone()).is_ok()); + + // Create the destination directory + assert!(ShinkaiFileManager::create_folder(destination_dir.clone()).is_ok()); + + // Copy the file + assert!(ShinkaiFileManager::copy_file(input_path.clone(), destination_dir.clone()).is_ok()); + + // Verify the destination file exists and contains the correct data + let destination_file_path = destination_dir.as_path().join("input_file.txt"); + let mut file = File::open(destination_file_path).unwrap(); + let mut contents = Vec::new(); + file.read_to_end(&mut contents).unwrap(); + assert_eq!(contents, data); + } + + #[test] + #[serial] + fn test_remove_file_and_folder() { + let dir = tempdir().unwrap(); + + // Set the environment variable to the temporary directory path + std::env::set_var("NODE_STORAGE_PATH", dir.path().to_string_lossy().to_string()); + + let file_path = ShinkaiPath::from_string("test_file.txt".to_string()); + let folder_path = ShinkaiPath::from_string("test_folder".to_string()); + let data = b"Hello, Shinkai!".to_vec(); + + // Setup the test database + let sqlite_manager = setup_test_db(); + + // Add the file + assert!(ShinkaiFileManager::write_file_to_fs(file_path.clone(), data.clone()).is_ok()); + + // Add a parsed file and chunks to the database + let parsed_file = create_test_parsed_file(1, "test_file.txt"); + sqlite_manager.add_parsed_file(&parsed_file).unwrap(); + + let chunk = ShinkaiFileChunk { + chunk_id: None, + parsed_file_id: parsed_file.id.unwrap(), + position: 1, + content: "This is a test chunk.".to_string(), + }; + sqlite_manager.create_chunk_with_embedding(&chunk, None).unwrap(); + + let chunks = sqlite_manager.get_chunks_for_parsed_file(parsed_file.id.unwrap()); + eprintln!("chunks before delete: {:?}", chunks); + + // Remove the file + assert!(ShinkaiFileManager::remove_file(file_path.clone(), &sqlite_manager).is_ok()); + + // Verify the file and its chunks are removed + assert!(!file_path.exists(), "The file should not exist after removal."); + let chunks = sqlite_manager.get_chunks_for_parsed_file(parsed_file.id.unwrap()); + eprintln!("chunks after delete: {:?}", chunks); + assert!( + chunks.unwrap().is_empty(), + "Chunks should be removed from the database." + ); + + // Create a folder + assert!(ShinkaiFileManager::create_folder(folder_path.clone()).is_ok()); + + // Remove the folder + assert!(ShinkaiFileManager::remove_folder(folder_path.clone(), &sqlite_manager).is_ok()); + + // Verify the folder is removed + assert!(!folder_path.exists(), "The folder should not exist after removal."); + } + + #[test] + #[serial] + fn test_move_folder() { + let dir = tempdir().unwrap(); + let base_dir = dir.path(); + + // Set the environment variable to the temporary directory path + std::env::set_var("NODE_STORAGE_PATH", base_dir.to_string_lossy().to_string()); + + let folder_path = ShinkaiPath::from_string("test_folder".to_string()); + let new_folder_path = ShinkaiPath::from_string("new_test_folder".to_string()); + + let file1_path = ShinkaiPath::from_string("test_folder/file1.txt".to_string()); + let file2_path = ShinkaiPath::from_string("test_folder/file2.txt".to_string()); + + let data1 = b"File 1 content".to_vec(); + let data2 = b"File 2 content".to_vec(); + + // Setup the test database + let sqlite_manager = setup_test_db(); + + // Create the folder and add files + assert!(ShinkaiFileManager::create_folder(folder_path.clone()).is_ok()); + assert!(ShinkaiFileManager::write_file_to_fs(file1_path.clone(), data1.clone()).is_ok()); + assert!(ShinkaiFileManager::write_file_to_fs(file2_path.clone(), data2.clone()).is_ok()); + + // Add parsed files to the database + let parsed_file1 = create_test_parsed_file(1, "test_folder/file1.txt"); + let parsed_file2 = create_test_parsed_file(2, "test_folder/file2.txt"); + sqlite_manager.add_parsed_file(&parsed_file1).unwrap(); + sqlite_manager.add_parsed_file(&parsed_file2).unwrap(); + + // Move the folder + assert!(ShinkaiFileManager::move_folder(folder_path.clone(), new_folder_path.clone(), &sqlite_manager).is_ok()); + + // Verify the files have been moved in the filesystem + let new_file1_path = ShinkaiPath::from_string("new_test_folder/file1.txt".to_string()); + let new_file2_path = ShinkaiPath::from_string("new_test_folder/file2.txt".to_string()); + + assert!(new_file1_path.exists(), "File 1 should exist in the new location."); + assert!(new_file2_path.exists(), "File 2 should exist in the new location."); + + // Verify the files have been moved in the database + let updated_file1 = sqlite_manager + .get_parsed_file_by_rel_path("new_test_folder/file1.txt") + .unwrap(); + let updated_file2 = sqlite_manager + .get_parsed_file_by_rel_path("new_test_folder/file2.txt") + .unwrap(); + + assert!(updated_file1.is_some(), "File 1 should be updated in the database."); + assert!(updated_file2.is_some(), "File 2 should be updated in the database."); + } + + #[test] + #[serial] + fn test_remove_folder_with_subfolder_and_embeddings() { + let dir = tempdir().unwrap(); + let base_dir = dir.path(); + + // Set the environment variable to the temporary directory path + std::env::set_var("NODE_STORAGE_PATH", base_dir.to_string_lossy().to_string()); + + let main_folder_path = ShinkaiPath::from_string("main_folder".to_string()); + let subfolder_path = ShinkaiPath::from_string("main_folder/subfolder".to_string()); + + let file1_path = ShinkaiPath::from_string("main_folder/file1.txt".to_string()); + let file2_path = ShinkaiPath::from_string("main_folder/subfolder/file2.txt".to_string()); + + let data1 = b"File 1 content".to_vec(); + let data2 = b"File 2 content".to_vec(); + + // Setup the test database + let sqlite_manager = setup_test_db(); + + // Create the main folder, subfolder, and add files + assert!(ShinkaiFileManager::create_folder(main_folder_path.clone()).is_ok()); + assert!(ShinkaiFileManager::create_folder(subfolder_path.clone()).is_ok()); + assert!(ShinkaiFileManager::write_file_to_fs(file1_path.clone(), data1.clone()).is_ok()); + assert!(ShinkaiFileManager::write_file_to_fs(file2_path.clone(), data2.clone()).is_ok()); + + // Add parsed files and chunks to the database + let parsed_file1 = create_test_parsed_file(1, "main_folder/file1.txt"); + let parsed_file2 = create_test_parsed_file(2, "main_folder/subfolder/file2.txt"); + sqlite_manager.add_parsed_file(&parsed_file1).unwrap(); + sqlite_manager.add_parsed_file(&parsed_file2).unwrap(); + + let chunk1 = ShinkaiFileChunk { + chunk_id: None, + parsed_file_id: parsed_file1.id.unwrap(), + position: 1, + content: "This is a test chunk for file 1.".to_string(), + }; + sqlite_manager.create_chunk_with_embedding(&chunk1, None).unwrap(); + + let chunk2 = ShinkaiFileChunk { + chunk_id: None, + parsed_file_id: parsed_file2.id.unwrap(), + position: 1, + content: "This is a test chunk for file 2.".to_string(), + }; + sqlite_manager.create_chunk_with_embedding(&chunk2, None).unwrap(); + + // Remove the main folder + assert!(ShinkaiFileManager::remove_folder(main_folder_path.clone(), &sqlite_manager).is_ok()); + + // Verify the main folder and subfolder are removed + assert!(!main_folder_path.exists(), "The main folder should not exist after removal."); + assert!(!subfolder_path.exists(), "The subfolder should not exist after removal."); + + // Verify the files and their chunks are removed from the database + let chunks1 = sqlite_manager.get_chunks_for_parsed_file(parsed_file1.id.unwrap()); + assert!( + chunks1.unwrap().is_empty(), + "Chunks for file 1 should be removed from the database." + ); + + let chunks2 = sqlite_manager.get_chunks_for_parsed_file(parsed_file2.id.unwrap()); + assert!( + chunks2.unwrap().is_empty(), + "Chunks for file 2 should be removed from the database." + ); + } +} diff --git a/shinkai-libs/shinkai-fs/src/shinkai_fs_error.rs b/shinkai-libs/shinkai-fs/src/shinkai_fs_error.rs new file mode 100644 index 000000000..5300a5d8c --- /dev/null +++ b/shinkai-libs/shinkai-fs/src/shinkai_fs_error.rs @@ -0,0 +1,132 @@ +use regex::Error as RegexError; +use serde_json::Error as SerdeError; +use shinkai_embedding::shinkai_embedding_errors::ShinkaiEmbeddingError; +use shinkai_sqlite::errors::SqliteManagerError; +use std::io; +use thiserror::Error; + +#[derive(Error, Debug)] +pub enum ShinkaiFsError { + #[error("Failed to read file: {0}")] + FailedIO(String), + #[error("File not found")] + FileNotFound, + #[error("File not found: {0}")] + FileNotFoundWithPath(String), + #[error("Invalid model architecture")] + InvalidModelArchitecture, + #[error("Unimplemented model dimensions: {0}")] + UnimplementedModelDimensions(String), + #[error("Request failed: {0}")] + RequestFailed(String), + #[error("Failed to generate embeddings: {0}")] + FailedEmbeddingGeneration(String), + #[error("IO error occurred: {0}")] + Io(#[from] io::Error), + #[error("Database error: {0}")] + Database(#[from] SqliteManagerError), + #[error("File not found in database")] + FileNotFoundInDatabase, + #[error("File not found on filesystem")] + FileNotFoundOnFilesystem, + #[error("Folder not found on filesystem")] + FolderNotFoundOnFilesystem, + #[error("Cannot move folder into itself")] + InvalidFolderMove, + #[error("Invalid node id: {0}")] + InvalidNodeId(String), + #[error("VectorResource is empty")] + VectorResourceEmpty, + #[error("No matching node found")] + NoNodeFound, + #[error("Failed JSON parsing")] + FailedJSONParsing, + #[error("Failed CSV parsing")] + FailedCSVParsing, + #[error("Failed DOCX parsing")] + FailedDOCXParsing, + #[error("Failed PDF parsing")] + FailedPDFParsing, + #[error("Failed MD parsing")] + FailedMDParsing, + #[error("Failed TXT parsing")] + FailedTXTParsing, + #[error("Failed XLSX parsing")] + FailedXLSXParsing, + #[error("No embedding provided")] + NoEmbeddingProvided, + #[error("The resource type does not match any of the VRBaseTypes")] + InvalidVRBaseType, + #[error("Regex error: {0}")] + RegexError(#[from] RegexError), + #[error("Content inside of the Node is of a different type than requested")] + ContentIsNonMatchingType, + #[error("Failed to parse Unstructed API response json: {0}")] + FailedParsingUnstructedAPIJSON(String), + #[error("File type not supported: {0}")] + FileTypeNotSupported(String), + #[error("Vector Resource reference string is invalid: {0}")] + InvalidReferenceString(String), + #[error("Provided datetime string does not match RFC3339: {0}")] + InvalidDateTimeString(String), + #[error("Failed to acquire lock for: {0}")] + LockAcquisitionFailed(String), + #[error("Missing key not found in hashmap: {0}")] + MissingKey(String), + #[error("String is not formatted as a proper path string: {0}")] + InvalidPathString(String), + #[error( + "Attempted to perform ordered operations on a resource that does not implement OrderedVectorResource: {0}" + )] + ResourceDoesNotSupportOrderedOperations(String), + #[error("Unexpected/unsupported NodeContent type for Node with id: {0}")] + InvalidNodeType(String), + #[error("The provided merkle hash String is not a validly encoded Blake3 hash: {0}")] + InvalidMerkleHashString(String), + #[error("The Vector Resource does not contain a merkle root: {0}")] + MerkleRootNotFound(String), + #[error("The Node does not contain a merkle root: {0}")] + MerkleHashNotFoundInNode(String), + #[error("The Vector Resource is not merkelized, and thus cannot perform merkel-related functionality: {0}")] + VectorResourceIsNotMerkelized(String), + #[error("Failed to parse contents into VRKai struct: {0}")] + VRKaiParsingError(String), + #[error("Failed to parse contents into VRPack struct: {0}")] + VRPackParsingError(String), + #[error("Unsupported VRKai version: {0}")] + UnsupportedVRKaiVersion(String), + #[error("Unsupported VRPack version: {0}")] + UnsupportedVRPackVersion(String), + #[error("Failed to convert SimplifiedFSEntry at path: {0}")] + InvalidSimplifiedFSEntryType(String), + #[error("Embedding Model Error: {0}")] + VRPackEmbeddingModelError(String), + #[error("Unsupported file type: {0}")] + UnsupportedFileType(String), + #[error("Failed to retrieve parsed file ID")] + FailedToRetrieveParsedFileID, + #[error("Failed to add parsed file to database")] + FailedToAddParsedFileToDatabase, + #[error("Failed to add chunks to database")] + FailedToAddChunksToDatabase, + #[error("Failed to read file: {0}")] + FailedToReadFile(String), +} + +impl From for ShinkaiFsError { + fn from(_error: SerdeError) -> Self { + ShinkaiFsError::FailedJSONParsing + } +} + +impl From for ShinkaiFsError { + fn from(error: reqwest::Error) -> Self { + ShinkaiFsError::RequestFailed(error.to_string()) + } +} + +impl From for ShinkaiFsError { + fn from(error: ShinkaiEmbeddingError) -> Self { + ShinkaiFsError::FailedEmbeddingGeneration(error.to_string()) + } +} diff --git a/shinkai-libs/shinkai-fs/src/simple_parser/file_parser_grouping.rs b/shinkai-libs/shinkai-fs/src/simple_parser/file_parser_grouping.rs new file mode 100644 index 000000000..5bad13472 --- /dev/null +++ b/shinkai-libs/shinkai-fs/src/simple_parser/file_parser_grouping.rs @@ -0,0 +1,224 @@ +use keyphrases::KeyPhraseExtractor; +use regex::Regex; +use shinkai_embedding::embedding_generator::EmbeddingGenerator; + +use std::{future::Future, pin::Pin}; + +use crate::shinkai_fs_error::ShinkaiFsError; + +use super::file_parser_helper::ShinkaiFileParser; +use super::text_group::TextGroup; + +impl ShinkaiFileParser { + /// Collect all texts from the TextGroups in a single dimension (no subgroups). + /// Returns a tuple of: + /// - `Vec` for all text + /// - `Vec<(Vec, usize)>` for the “paths” (here just `[i]`) and text index + pub fn collect_texts_and_indices( + text_groups: &[TextGroup], + max_node_text_size: u64, + path: Vec, + ) -> (Vec, Vec<(Vec, usize)>) { + let mut texts = Vec::new(); + let mut indices = Vec::new(); + + for (i, text_group) in text_groups.iter().enumerate() { + // Format text with your metadata or keyword logic + let formatted_text = text_group.format_text_for_embedding(max_node_text_size); + texts.push(formatted_text); + + // Build a “path” that refers to just the top-level group (no subgroups). + let mut current_path = path.clone(); + current_path.push(i); + // The last text we pushed is at index `texts.len() - 1` + indices.push((current_path, texts.len() - 1)); + } + + (texts, indices) + } + + /// Assign generated embeddings back into the TextGroups (single dimension). + fn assign_embeddings( + text_groups: &mut [TextGroup], + embeddings: &mut Vec>, + indices: &[(Vec, usize)], + ) { + for (path, text_idx) in indices { + // We expect path = [i], but if you store deeper paths, you can interpret them differently. + let i = path[0]; + if let Some(embedding) = embeddings.get(*text_idx) { + text_groups[i].embedding = Some(embedding.clone()); + } + } + } + + /// Batch-generate embeddings for all the TextGroups (no subgroups). + pub fn generate_text_group_embeddings( + text_groups: Vec, + generator: Box, + mut max_batch_size: u64, + max_node_text_size: u64, + collect_texts_and_indices: fn(&[TextGroup], u64, Vec) -> (Vec, Vec<(Vec, usize)>), + ) -> Pin, ShinkaiFsError>> + Send>> { + Box::pin(async move { + // Make a mutable copy of the incoming text groups + let mut text_groups = text_groups; + + // Collect all texts (flattened) from the text groups + let (texts, indices) = collect_texts_and_indices(&text_groups, max_node_text_size, vec![]); + + // Prepare to generate embeddings in batches + let mut embeddings = Vec::new(); + let mut all_futures = Vec::new(); + let mut current_batch_futures = Vec::new(); + + // Break texts into chunks of size `max_batch_size` + for (index, batch) in texts.chunks(max_batch_size as usize).enumerate() { + let batch_texts = batch.to_vec(); + let generator_clone = generator.box_clone(); // clone for an async block below + + let future = async move { + generator_clone.generate_embeddings(&batch_texts).await + }; + current_batch_futures.push(future); + + // If we have 10 futures queued or we're at the last batch, we gather them + if current_batch_futures.len() == 10 || + index == texts.chunks(max_batch_size as usize).count() - 1 + { + all_futures.push(current_batch_futures); + current_batch_futures = Vec::new(); + } + } + + // Run each group of futures in sequence + for futures_group in all_futures { + // Wait for them all to complete + let results = futures::future::join_all(futures_group).await; + for result in results { + match result { + Ok(batch_embeddings) => embeddings.extend(batch_embeddings), + Err(e) => { + // Attempt to reduce batch size and retry + if max_batch_size > 5 { + max_batch_size -= 5; + return Self::generate_text_group_embeddings( + text_groups, + generator, + max_batch_size, + max_node_text_size, + collect_texts_and_indices, + ) + .await; + } else { + return Err(ShinkaiFsError::FailedEmbeddingGeneration(e.to_string())); + } + } + } + } + } + + // Assign embeddings back to the flattened text_groups + Self::assign_embeddings(&mut text_groups, &mut embeddings, &indices); + Ok(text_groups) + }) + } + + /// Splits a string into chunks at the nearest whitespace to a given size + pub fn split_into_chunks(text: &str, chunk_size: usize) -> Vec { + let mut chunks = Vec::new(); + let mut start = 0; + while start < text.len() { + let end = { + let mut candidate_end = start + chunk_size; + if candidate_end >= text.len() { + text.len() + } else { + // walk backward until whitespace (or until we reach start) + while candidate_end > start && !text.as_bytes()[candidate_end].is_ascii_whitespace() { + candidate_end -= 1; + } + if candidate_end == start { + start + chunk_size.min(text.len() - start) + } else { + candidate_end + } + } + }; + let chunk = &text[start..end]; + chunks.push(chunk.to_string()); + start = end; + } + chunks + } + + /// Splits a string into chunks at the nearest whitespace to a given size, avoiding splitting metadata. + pub fn split_into_chunks_with_metadata(text: &str, chunk_size: usize) -> Vec { + // The regex matches both pure and replaceable metadata. + let re = Regex::new(Self::METADATA_REGEX).unwrap(); + let matched_positions: Vec<(usize, usize)> = re.find_iter(text).map(|m| (m.start(), m.end())).collect(); + + let mut chunks = Vec::new(); + let mut start = 0; + while start < text.len() { + let end = { + let mut candidate_end = start + chunk_size; + if candidate_end >= text.len() { + text.len() + } else { + // walk backward until whitespace or until we exit a metadata block + while candidate_end > start && + ( + !text.as_bytes()[candidate_end].is_ascii_whitespace() || + matched_positions.iter().any(|&(s, e)| candidate_end >= s && candidate_end < e) + ) + { + candidate_end -= 1; + } + if candidate_end == start { + start + chunk_size.min(text.len() - start) + } else { + candidate_end + } + } + }; + + let chunk = &text[start..end]; + chunks.push(chunk.to_string()); + start = end; + } + chunks + } + + /// Extracts the most important keywords from all TextGroups using the RAKE algorithm. + pub fn extract_keywords(groups: &Vec, num: u64) -> Vec { + // Flatten the text from all groups into one string + let text = groups + .iter() + .map(|element| element.text.clone()) + .collect::>() + .join(" "); + + // Create a KeyPhraseExtractor with a maximum of `num` keywords + let extractor = KeyPhraseExtractor::new(&text, num as usize); + + // Return keywords only, discarding scores + extractor.get_keywords() + .into_iter() + .map(|(_score, keyword)| keyword) + .collect() + } + + /// Concatenate text from multiple groups up to a maximum size. + pub fn concatenate_groups_up_to_max_size(elements: &Vec, max_size: usize) -> String { + let mut desc = String::new(); + for e in elements { + if desc.len() + e.text.len() + 1 > max_size { + break; + } + desc.push_str(&e.text); + desc.push('\n'); + } + desc.trim_end().to_string() + } +} diff --git a/shinkai-libs/shinkai-vector-resources/src/file_parser/file_parser_helper.rs b/shinkai-libs/shinkai-fs/src/simple_parser/file_parser_helper.rs similarity index 53% rename from shinkai-libs/shinkai-vector-resources/src/file_parser/file_parser_helper.rs rename to shinkai-libs/shinkai-fs/src/simple_parser/file_parser_helper.rs index 5f4e2c6b8..a30f3d21d 100644 --- a/shinkai-libs/shinkai-vector-resources/src/file_parser/file_parser_helper.rs +++ b/shinkai-libs/shinkai-fs/src/simple_parser/file_parser_helper.rs @@ -4,9 +4,9 @@ use regex::{Captures, Regex}; use reqwest::Url; use std::collections::HashMap; -use super::file_parser::ShinkaiFileParser; -use super::file_parser_types::TextGroup; -use crate::vector_resource::SourceFileType; +use super::text_group::TextGroup; + +pub struct ShinkaiFileParser; impl ShinkaiFileParser { pub const PURE_METADATA_REGEX: &'static str = r"!\{\{\{([^:}]+):((?:[^}]*\}{0,2}[^}]+))\}\}\}!"; @@ -28,69 +28,74 @@ impl ShinkaiFileParser { "timestamp".to_string() } - // Key of likes metadata - pub fn likes_metadata_key() -> String { - "likes".to_string() - } - - // Key of reposts metadata - pub fn reposts_metadata_key() -> String { - "reposts".to_string() - } - - // Key of replies metadata - pub fn replies_metadata_key() -> String { - "replies".to_string() - } - - /// Clean's the file name of auxiliary data (file extension, url in front of file name, etc.) - pub fn clean_name(name: &str) -> String { - // Decode URL-encoded characters to simplify processing. - let decoded_name = urlencoding::decode(name).unwrap_or_else(|_| name.into()); - - // Check if the name ends with ".htm" or ".html" and calculate the position to avoid deletion. - let avoid_deletion_position = if decoded_name.ends_with(".htm") || decoded_name.ends_with(".html") { - decoded_name.len().saturating_sub(4) // Position before ".htm" - } else if decoded_name.ends_with(".html") { - decoded_name.len().saturating_sub(5) // Position before ".html" - } else if decoded_name.ends_with(".mhtml") { - decoded_name.len().saturating_sub(6) // Position before ".mhtml" - } else { - decoded_name.len() // Use the full length if not ending with ".htm" or ".html" - }; - - // Find the last occurrence of "/" or "%2F" that is not too close to the ".htm" extension. - let last_relevant_slash_position = decoded_name.rmatch_indices(&['/', '%']).find_map(|(index, _)| { - if index + 3 < avoid_deletion_position && decoded_name[index..].starts_with("%2F") { - Some(index) - } else if index + 1 < avoid_deletion_position && decoded_name[index..].starts_with("/") { - Some(index) - } else { - None - } - }); - // If a relevant slash is found, slice the string from the character immediately following this slash. - let http_cleaned = match last_relevant_slash_position { - Some(index) => decoded_name - .get((index + if decoded_name[index..].starts_with("%2F") { 3 } else { 1 })..) - .unwrap_or(&decoded_name), - None => &decoded_name, - }; - - let http_cleaned = if http_cleaned.is_empty() || http_cleaned == ".html" || http_cleaned == ".htm" { - decoded_name.to_string() - } else { - http_cleaned.to_string() - }; - - // Remove extension - let cleaned_name = SourceFileType::clean_string_of_extension(&http_cleaned); - - cleaned_name + // // Key of likes metadata + // pub fn likes_metadata_key() -> String { + // "likes".to_string() + // } + + // // Key of reposts metadata + // pub fn reposts_metadata_key() -> String { + // "reposts".to_string() + // } + + // // Key of replies metadata + // pub fn replies_metadata_key() -> String { + // "replies".to_string() + // } + + // /// Clean's the file name of auxiliary data (file extension, url in front of file name, etc.) + // pub fn clean_name(name: &str) -> String { + // // Decode URL-encoded characters to simplify processing. + // let decoded_name = urlencoding::decode(name).unwrap_or_else(|_| name.into()); + + // // Check if the name ends with ".htm" or ".html" and calculate the position to avoid deletion. + // let avoid_deletion_position = if decoded_name.ends_with(".htm") || decoded_name.ends_with(".html") { + // decoded_name.len().saturating_sub(4) // Position before ".htm" + // } else if decoded_name.ends_with(".html") { + // decoded_name.len().saturating_sub(5) // Position before ".html" + // } else if decoded_name.ends_with(".mhtml") { + // decoded_name.len().saturating_sub(6) // Position before ".mhtml" + // } else { + // decoded_name.len() // Use the full length if not ending with ".htm" or ".html" + // }; + + // // Find the last occurrence of "/" or "%2F" that is not too close to the ".htm" extension. + // let last_relevant_slash_position = decoded_name.rmatch_indices(&['/', '%']).find_map(|(index, _)| { + // if index + 3 < avoid_deletion_position && decoded_name[index..].starts_with("%2F") { + // Some(index) + // } else if index + 1 < avoid_deletion_position && decoded_name[index..].starts_with("/") { + // Some(index) + // } else { + // None + // } + // }); + // // If a relevant slash is found, slice the string from the character immediately following this slash. + // let http_cleaned = match last_relevant_slash_position { + // Some(index) => decoded_name + // .get((index + if decoded_name[index..].starts_with("%2F") { 3 } else { 1 })..) + // .unwrap_or(&decoded_name), + // None => &decoded_name, + // }; + + // let http_cleaned = if http_cleaned.is_empty() || http_cleaned == ".html" || http_cleaned == ".htm" { + // decoded_name.to_string() + // } else { + // http_cleaned.to_string() + // }; + + // // Remove extension + // let cleaned_name = SourceFileType::clean_string_of_extension(&http_cleaned); + + // cleaned_name + // } + + pub async fn initialize_local_file_parser() -> Result<(), Box> { + use shinkai_ocr::image_parser::ImageParser; + ImageParser::check_and_download_dependencies().await } /// Helper function that processes groups into a list of descriptions. - /// Only takes the top level Group text, does not traverse deeper. + /// Only takes the top-level group text, does not recurse into subgroups. pub fn process_groups_into_descriptions_list( groups: &Vec, max_size: usize, @@ -121,7 +126,7 @@ impl ShinkaiFileParser { } /// Processes groups into a single description string. - /// Only takes the top level Group text, does not traverse deeper. + /// Only takes the top-level `TextGroup` text, not subgroups. pub fn process_groups_into_description( groups: &Vec, max_size: usize, @@ -131,7 +136,7 @@ impl ShinkaiFileParser { descriptions.join(" ") } - /// Helper method for setting a description if none provided for process_new_doc_resource + /// Helper method for setting a description if none is provided. pub fn _setup_resource_description( desc: Option, text_groups: &Vec, @@ -151,7 +156,7 @@ impl ShinkaiFileParser { } } - /// Generates a Blake3 hash of the data in the buffer + /// Generates a Blake3 hash of the data in the buffer. pub fn generate_data_hash(buffer: &[u8]) -> String { let mut hasher = Hasher::new(); hasher.update(buffer); @@ -159,8 +164,8 @@ impl ShinkaiFileParser { result.to_hex().to_string() } - // Parse and extract metadata in a text - // Returns the parsed text and a hashmap of metadata + /// Parse and extract metadata from `input_text`. + /// Returns `(parsed_text, metadata, parsed_any_metadata)`. pub fn parse_and_extract_metadata(input_text: &str) -> (String, HashMap, bool) { let mut metadata = HashMap::new(); let mut parsed_any_metadata = false; @@ -178,20 +183,18 @@ impl ShinkaiFileParser { (parsed_result.to_string(), metadata, parsed_any_metadata) } - // Helper function to extract metadata from a capture - // is_pure is used to determine if the metadata should be removed from the text + /// Helper function to extract metadata from a capture. + /// If `is_pure == true`, the captured text is removed from the final string. fn extract_metadata_from_capture( metadata: &mut HashMap, parsed_any_metadata: &mut bool, caps: &Captures, is_pure: bool, ) -> String { - // In case extracting the capture groups fails, return the original text which is guaranteed to be valid let key = match caps.get(1) { Some(key) => key.as_str(), None => return caps.get(0).unwrap().as_str().to_string(), }; - let value = match caps.get(2) { Some(value) => value.as_str(), None => return caps.get(0).unwrap().as_str().to_string(), @@ -199,131 +202,76 @@ impl ShinkaiFileParser { *parsed_any_metadata = true; - // 1. Verify supported key value constraints and ignore invalid ones - // 2. Replace any matched metadata or remove if it's pure match key { - // timestamp or datetime: RFC3339 formatted date string + // timestamp or datetime: RFC3339 format _ if key == ShinkaiFileParser::datetime_metadata_key() || key == ShinkaiFileParser::timestamp_metadata_key() => { let datetime = chrono::DateTime::parse_from_rfc3339(value); - match datetime { Ok(_) => { metadata.insert(ShinkaiFileParser::datetime_metadata_key(), value.to_string()); - - if is_pure { - "".to_string() - } else { - value.to_string() - } + if is_pure { "".to_string() } else { value.to_string() } } Err(_) => { - // Attempt to parse timestamp in a less strict format + // Attempt a less strict format let datetime = chrono::NaiveDateTime::parse_from_str(value, "%Y-%m-%dT%H:%M:%S%.3fZ"); - match datetime { Ok(parsed_datetime) => { let formatted_datetime = Utc.from_utc_datetime(&parsed_datetime).to_rfc3339(); metadata.insert(key.to_string(), formatted_datetime.clone()); - - if is_pure { - "".to_string() - } else { - formatted_datetime - } + if is_pure { "".to_string() } else { formatted_datetime } } Err(_) => value.to_string(), } } } } - // pg_nums: Array of integers + // pg_nums: array of integers _ if key == ShinkaiFileParser::page_numbers_metadata_key() => { let page_numbers: Result, _> = value .trim_matches(|c| c == '[' || c == ']') - .split(",") + .split(',') .map(|n| n.trim().parse::()) .collect(); match page_numbers { Ok(_) => { metadata.insert(key.to_string(), value.to_string()); - - if is_pure { - "".to_string() - } else { - value.to_string() - } - } - Err(_) => value.to_string(), - } - } - // likes, reposts, replies: Integer - _ if key == ShinkaiFileParser::likes_metadata_key() - || key == ShinkaiFileParser::reposts_metadata_key() - || key == ShinkaiFileParser::replies_metadata_key() => - { - let number = value.parse::(); - - match number { - Ok(_) => { - metadata.insert(key.to_string(), value.to_string()); - - if is_pure { - "".to_string() - } else { - value.to_string() - } + if is_pure { "".to_string() } else { value.to_string() } } Err(_) => value.to_string(), } } + // Fallback _ => { metadata.insert(key.to_string(), value.to_string()); - - if is_pure { - "".to_string() - } else { - value.to_string() - } + if is_pure { "".to_string() } else { value.to_string() } } } } + /// Parse and extract Markdown URLs like `[text](url)` or `![text](url)`. pub fn parse_and_extract_md_metadata(input_text: &str) -> (String, HashMap) { let mut metadata = HashMap::new(); let md_url_re = Regex::new(Self::MD_URL_REGEX).unwrap(); let parsed_result = md_url_re.replace_all(input_text, |caps: &Captures| { - let prefix = match caps.get(1) { - Some(prefix) => prefix.as_str(), - None => return caps.get(0).unwrap().as_str().to_string(), - }; - - let text = match caps.get(2) { - Some(text) => text.as_str(), - None => return caps.get(0).unwrap().as_str().to_string(), - }; - - let url = match caps.get(3) { - Some(url) => url.as_str(), - None => return caps.get(0).unwrap().as_str().to_string(), - }; + let prefix = caps.get(1).map_or("", |m| m.as_str()); + let text = caps.get(2).map_or("", |m| m.as_str()); + let url = caps.get(3).map_or("", |m| m.as_str()); let mut shortened_url = Url::parse(url) .ok() .map(|u| { let mut scheme = u.scheme().to_string(); let host = u.host_str().unwrap_or("").to_string(); - if !scheme.is_empty() { scheme = format!("{}://", scheme); } - format!("{}{}", scheme, host) }) - .unwrap_or("".to_string()); + .unwrap_or_else(|| "".to_string()); if shortened_url.is_empty() { shortened_url = url.chars().take(100).collect(); @@ -351,83 +299,73 @@ impl ShinkaiFileParser { (parsed_result.to_string(), serialized_metadata) } + /// Splits `text` into as many `TextGroup`s as needed, ignoring sub-groups. pub fn parse_and_split_into_text_groups( text: String, max_node_text_size: u64, page_number: Option, ) -> Vec { let mut text_groups = Vec::new(); - let (parsed_text, metadata, parsed_any_metadata) = ShinkaiFileParser::parse_and_extract_metadata(&text); - let (parsed_md_text, md_metadata) = ShinkaiFileParser::parse_and_extract_md_metadata(&parsed_text); + let (parsed_text, metadata, parsed_any_metadata) = + ShinkaiFileParser::parse_and_extract_metadata(&text); + let (parsed_md_text, md_metadata) = + ShinkaiFileParser::parse_and_extract_md_metadata(&parsed_text); + + // Merge the two sets of metadata + let all_metadata = metadata.into_iter().chain(md_metadata).collect::>(); if parsed_md_text.len() as u64 > max_node_text_size { + // If the text is too large, split it let chunks = if parsed_any_metadata { ShinkaiFileParser::split_into_chunks_with_metadata(&text, max_node_text_size as usize) } else { - ShinkaiFileParser::split_into_chunks(&text, max_node_text_size as usize) + Self::split_into_chunks(&text, max_node_text_size as usize) }; for chunk in chunks { - let (parsed_chunk, metadata, _) = ShinkaiFileParser::parse_and_extract_metadata(&chunk); - let (parsed_md_chunk, md_metadata) = ShinkaiFileParser::parse_and_extract_md_metadata(&parsed_chunk); - let metadata = metadata.into_iter().chain(md_metadata).collect(); - let mut text_group = TextGroup::new(parsed_md_chunk, metadata, vec![], None); + let (parsed_chunk, chunk_metadata, _) = Self::parse_and_extract_metadata(&chunk); + let (parsed_md_chunk, md_metadata_chunk) = Self::parse_and_extract_md_metadata(&parsed_chunk); + + let merged_metadata = chunk_metadata + .into_iter() + .chain(md_metadata_chunk) + .collect::>(); + let mut text_group = TextGroup::new(parsed_md_chunk, merged_metadata, None); if let Some(page_number) = page_number { text_group.push_page_number(page_number); } - text_groups.push(text_group); } } else { - let metadata = metadata.into_iter().chain(md_metadata).collect(); - let mut text_group = TextGroup::new(parsed_md_text, metadata, vec![], None); - + // Single chunk + let mut text_group = TextGroup::new(parsed_md_text, all_metadata, None); if let Some(page_number) = page_number { text_group.push_page_number(page_number); } - text_groups.push(text_group); } text_groups } - // Creates a new text group and nests it under the last group at the given depth. - // It splits text groups into chunks if needed and parses metadata in the text. + /// Previously, this method would nest groups at `depth`. + /// Now, we flatten everything and simply append the created groups. pub fn push_text_group_by_depth( text_groups: &mut Vec, - depth: usize, + _depth: usize, // ignore depth text: String, max_node_text_size: u64, page_number: Option, ) { if !text.is_empty() { - let created_text_groups = - ShinkaiFileParser::parse_and_split_into_text_groups(text, max_node_text_size, page_number); - - if depth > 0 { - let mut parent_group = text_groups.last_mut(); - for _ in 1..depth { - if let Some(last_group) = parent_group { - parent_group = last_group.sub_groups.last_mut(); - } - } - - if let Some(last_group) = parent_group { - for text_group in created_text_groups { - last_group.push_sub_group(text_group); - } - } else { - for text_group in created_text_groups { - text_groups.push(text_group); - } - } - } else { - for text_group in created_text_groups { - text_groups.push(text_group); - } - } + let created_text_groups = Self::parse_and_split_into_text_groups( + text, + max_node_text_size, + page_number + ); + // Just extend the top-level list, ignoring `_depth`. + text_groups.extend(created_text_groups); } } } diff --git a/shinkai-libs/shinkai-fs/src/simple_parser/local_parsing/csv_parsing.rs b/shinkai-libs/shinkai-fs/src/simple_parser/local_parsing/csv_parsing.rs new file mode 100644 index 000000000..b6b1502ff --- /dev/null +++ b/shinkai-libs/shinkai-fs/src/simple_parser/local_parsing/csv_parsing.rs @@ -0,0 +1,169 @@ +use crate::{ + shinkai_fs_error::ShinkaiFsError, + simple_parser::{file_parser_helper::ShinkaiFileParser, text_group::TextGroup}, +}; + +use csv::ReaderBuilder; +use std::{collections::HashMap, io::Cursor}; + +use super::LocalFileParser; + +impl LocalFileParser { + /// Attempts to process the provided csv file into a list of TextGroups. + pub fn process_csv_file(file_buffer: Vec, max_node_text_size: u64) -> Result, ShinkaiFsError> { + let csv_lines = Self::parse_csv_auto(&file_buffer).map_err(|_| ShinkaiFsError::FailedCSVParsing)?; + Self::process_table_rows(csv_lines, max_node_text_size) + } + + // /// Parse CSV data from a buffer and attempt to automatically detect + // /// headers. + pub fn parse_csv_auto(buffer: &[u8]) -> Result, ShinkaiFsError> { + let mut reader = ReaderBuilder::new().flexible(true).from_reader(Cursor::new(buffer)); + let headers = reader + .headers() + .map_err(|_| ShinkaiFsError::FailedCSVParsing)? + .iter() + .map(String::from) + .collect::>(); + + let likely_header = headers.iter().all(|s| { + let is_alphabetic = s.chars().all(|c| c.is_alphabetic() || c.is_whitespace() || c == '_'); + let no_duplicates = headers.iter().filter(|&item| item == s).count() == 1; + let no_prohibited_chars = !s.contains(&['@', '#', '$', '%', '^', '&', '*']); + + is_alphabetic && no_duplicates && no_prohibited_chars + }); + + Self::parse_csv(&buffer, likely_header) + } + + // /// Parse CSV data from a buffer. + // /// * `header` - A boolean indicating whether to prepend column headers to + // /// values. + pub fn parse_csv(buffer: &[u8], header: bool) -> Result, ShinkaiFsError> { + let mut reader = ReaderBuilder::new() + .flexible(true) + .has_headers(header) + .from_reader(Cursor::new(buffer)); + let headers = if header { + reader + .headers() + .map_err(|_| ShinkaiFsError::FailedCSVParsing)? + .iter() + .map(String::from) + .collect::>() + } else { + Vec::new() + }; + + let mut result = Vec::new(); + for record in reader.records() { + let record = record.map_err(|_| ShinkaiFsError::FailedCSVParsing)?; + let row: Vec = if header { + record + .iter() + .enumerate() + .map(|(i, e)| format!("{}: {}", headers[i], e)) + .collect() + } else { + record.iter().map(String::from).collect() + }; + let row_string = row.join("|"); + result.push(row_string); + } + + Ok(result) + } + + pub fn process_table_rows( + table_rows: Vec, + max_node_text_size: u64, + ) -> Result, ShinkaiFsError> { + let mut table_rows_split = Vec::new(); + let mut current_group = Vec::new(); + let mut current_length = 0; + + for row in table_rows { + let line_length = row.len() as u64; + if current_length + line_length > max_node_text_size { + if !current_group.is_empty() { + table_rows_split.push(current_group); + } + current_group = Vec::new(); + current_length = 0; + } + current_group.push(row); + current_length += line_length; + } + + if !current_group.is_empty() { + table_rows_split.push(current_group); + } + + let joined_lines = table_rows_split + .into_iter() + .map(|group| group.join("\n")) + .collect::>(); + + let mut text_groups = Vec::new(); + for line in joined_lines { + let (parsed_line, metadata, parsed_any_metadata) = ShinkaiFileParser::parse_and_extract_metadata(&line); + + if parsed_line.len() as u64 > max_node_text_size { + // Instead of sub-groups, just create multiple TextGroups: + let chunks = if parsed_any_metadata { + ShinkaiFileParser::split_into_chunks_with_metadata(&line, max_node_text_size as usize) + } else { + ShinkaiFileParser::split_into_chunks(&line, max_node_text_size as usize) + }; + + for chunk in chunks { + let (parsed_chunk, chunk_metadata, _) = if parsed_any_metadata { + ShinkaiFileParser::parse_and_extract_metadata(&chunk) + } else { + (chunk.to_owned(), HashMap::new(), false) + }; + text_groups.push(TextGroup::new(parsed_chunk, chunk_metadata, None)); + } + } else if !parsed_line.is_empty() { + text_groups.push(TextGroup::new(parsed_line, metadata, None)); + } + } + + Ok(text_groups) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_process_csv_file() { + // Sample CSV data + let csv_data = b"header1,header2\nvalue1,value2\nvalue3,value4"; + let max_node_text_size = 10; + + // Call the function + let result = LocalFileParser::process_csv_file(csv_data.to_vec(), max_node_text_size); + eprintln!("result: {:?}", result); + + // Check the result + assert!(result.is_ok()); + let text_groups = result.unwrap(); + + // Verify the output + assert_eq!(text_groups.len(), 6); // Expecting 6 TextGroups due to max_node_text_size + let expected_texts = vec![ + "header1|he", + "ader2", + "value1|val", + "ue2", + "value3|val", + "ue4", + ]; + for (i, text_group) in text_groups.iter().enumerate() { + assert_eq!(text_group.text, expected_texts[i]); + } + } +} diff --git a/shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/html_parsing.rs b/shinkai-libs/shinkai-fs/src/simple_parser/local_parsing/html_parsing.rs similarity index 98% rename from shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/html_parsing.rs rename to shinkai-libs/shinkai-fs/src/simple_parser/local_parsing/html_parsing.rs index f4c5aadc1..2c363dcee 100644 --- a/shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/html_parsing.rs +++ b/shinkai-libs/shinkai-fs/src/simple_parser/local_parsing/html_parsing.rs @@ -1,10 +1,7 @@ use regex::Regex; use scraper::{ElementRef, Html, Selector}; -use crate::{ - file_parser::{file_parser::ShinkaiFileParser, file_parser_types::TextGroup}, - resource_errors::VRError, -}; +use crate::{shinkai_fs_error::ShinkaiFsError, simple_parser::{file_parser_helper::ShinkaiFileParser, text_group::TextGroup}}; use super::LocalFileParser; @@ -71,7 +68,7 @@ impl LocalFileParser { file_buffer: Vec, file_name: &str, max_node_text_size: u64, - ) -> Result, VRError> { + ) -> Result, ShinkaiFsError> { let extracted_buffer = extract_core_content(file_buffer, file_name); let document = Html::parse_fragment(&String::from_utf8_lossy(&extracted_buffer)); diff --git a/shinkai-libs/shinkai-fs/src/simple_parser/local_parsing/json_parsing.rs b/shinkai-libs/shinkai-fs/src/simple_parser/local_parsing/json_parsing.rs new file mode 100644 index 000000000..70cba4f68 --- /dev/null +++ b/shinkai-libs/shinkai-fs/src/simple_parser/local_parsing/json_parsing.rs @@ -0,0 +1,87 @@ +use std::collections::HashMap; + +use super::LocalFileParser; +use crate::{shinkai_fs_error::ShinkaiFsError, simple_parser::{file_parser_helper::ShinkaiFileParser, text_group::TextGroup}}; +use serde_json::Value as JsonValue; + +impl LocalFileParser { + /// Attempts to process the provided json file into a list of TextGroups. + pub fn process_json_file( + file_buffer: Vec, + max_node_text_size: u64, + ) -> Result, ShinkaiFsError> { + let json_string = + String::from_utf8(file_buffer).map_err(|_| ShinkaiFsError::FailedJSONParsing)?; + let json: JsonValue = serde_json::from_str(&json_string)?; + + let text_groups = Self::process_container_json_value(&json, max_node_text_size); + Ok(text_groups) + } + + /// Recursively processes a JSON value into a *flat* list of TextGroups. + pub fn process_container_json_value(json: &JsonValue, max_node_text_size: u64) -> Vec { + // Helper to merge small TextGroups + let fn_merge_groups = |mut acc: Vec, current_group: TextGroup| { + if let Some(prev_group) = acc.last_mut() { + if prev_group.text.len() + current_group.text.len() < max_node_text_size as usize { + prev_group + .text + .push_str(format!("\n{}", current_group.text).as_str()); + return acc; + } + } + acc.push(current_group); + acc + }; + + match json { + JsonValue::Object(map) => { + // For each (key, value), produce a TextGroup for `key`, plus sub-groups from `value`. + let mut result = Vec::new(); + for (key, value) in map { + // Optionally create a TextGroup for the key itself + result.push(TextGroup::new(key.clone(), HashMap::new(), None)); + // Then flatten out whatever the value contains + let sub_result = Self::process_container_json_value(value, max_node_text_size); + result.extend(sub_result); + } + result.into_iter().fold(Vec::new(), fn_merge_groups) + } + JsonValue::Array(arr) => { + // Flatten all elements + let mut result = Vec::new(); + for value in arr { + let sub_result = Self::process_container_json_value(value, max_node_text_size); + result.extend(sub_result); + } + result.into_iter().fold(Vec::new(), fn_merge_groups) + } + // Base case: it’s a primitive (string, number, bool, null) + _ => Self::process_content_json_value(None, json, max_node_text_size), + } + } + + /// Processes a single JSON value (primitive) into one or more TextGroups. + fn process_content_json_value( + key: Option<&str>, + value: &JsonValue, + max_node_text_size: u64, + ) -> Vec { + let mut text_groups = Vec::new(); + let text = match key { + Some(k) => format!("{}: {}", k, value.to_string()), + None => value.to_string(), + }; + + if text.len() as u64 > max_node_text_size { + let chunks = ShinkaiFileParser::split_into_chunks(&text, max_node_text_size as usize); + for chunk in chunks { + text_groups.push(TextGroup::new(chunk, HashMap::new(), None)); + } + } else { + text_groups.push(TextGroup::new(text, HashMap::new(), None)); + } + + text_groups + } +} diff --git a/shinkai-libs/shinkai-fs/src/simple_parser/local_parsing/local_parsing.rs b/shinkai-libs/shinkai-fs/src/simple_parser/local_parsing/local_parsing.rs new file mode 100644 index 000000000..c887b9187 --- /dev/null +++ b/shinkai-libs/shinkai-fs/src/simple_parser/local_parsing/local_parsing.rs @@ -0,0 +1,54 @@ +// use crate::file_parser::file_parser_types::TextGroup; +// use crate::shinkai_fs_error::ShinkaiFsError; + +// pub struct LocalFileParser {} + +// impl LocalFileParser { +// /// Attempts to process a file into a list of TextGroups using local processing logic +// /// implemented in Rust directly without relying on external services. +// /// If local processing is not available for the provided source, then returns Err. +// pub fn process_file_into_grouped_text( +// file_buffer: Vec, +// file_name: String, +// max_node_text_size: u64, +// source: VRSourceReference, +// ) -> Result, ShinkaiFsError> { +// let source_base = source; + +// match &source_base { +// VRSourceReference::None => Err(ShinkaiFsError::UnsupportedFileType(file_name.to_string())), +// VRSourceReference::Standard(source) => match source { +// SourceReference::Other(_) => Err(ShinkaiFsError::UnsupportedFileType(file_name.to_string())), +// SourceReference::FileRef(file_source) => match file_source.clone().file_type { +// SourceFileType::Image(_) +// | SourceFileType::Code(_) +// | SourceFileType::ConfigFileType(_) +// | SourceFileType::Video(_) +// | SourceFileType::Audio(_) +// | SourceFileType::Shinkai(_) => Err(ShinkaiFsError::UnsupportedFileType(file_name.to_string())), +// SourceFileType::Document(doc) => match doc { +// DocumentFileType::Txt => LocalFileParser::process_txt_file(file_buffer, max_node_text_size), +// DocumentFileType::Json => LocalFileParser::process_json_file(file_buffer, max_node_text_size), +// DocumentFileType::Csv => LocalFileParser::process_csv_file(file_buffer, max_node_text_size), +// // DocumentFileType::Docx => LocalFileParser::process_docx_file(file_buffer, max_node_text_size), +// DocumentFileType::Html => { +// LocalFileParser::process_html_file(file_buffer, &file_name, max_node_text_size) +// } + +// DocumentFileType::Md => LocalFileParser::process_md_file(file_buffer, max_node_text_size), + +// DocumentFileType::Pdf => LocalFileParser::process_pdf_file(file_buffer, max_node_text_size), + +// DocumentFileType::Xlsx | DocumentFileType::Xls => { +// LocalFileParser::process_xlsx_file(file_buffer, max_node_text_size) +// } + +// _ => Err(ShinkaiFsError::UnsupportedFileType(file_name.to_string())), +// }, +// }, +// SourceReference::ExternalURI(_) => Err(ShinkaiFsError::UnsupportedFileType(file_name.to_string())), +// }, +// VRSourceReference::Notarized(_) => Err(ShinkaiFsError::UnsupportedFileType(file_name.to_string())), +// } +// } +// } diff --git a/shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/md_parsing.rs b/shinkai-libs/shinkai-fs/src/simple_parser/local_parsing/md_parsing.rs similarity index 96% rename from shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/md_parsing.rs rename to shinkai-libs/shinkai-fs/src/simple_parser/local_parsing/md_parsing.rs index f5960eb88..ed59f0c3f 100644 --- a/shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/md_parsing.rs +++ b/shinkai-libs/shinkai-fs/src/simple_parser/local_parsing/md_parsing.rs @@ -1,20 +1,15 @@ -#[cfg(feature = "desktop-only")] use comrak::{ nodes::{AstNode, ListDelimType, ListType, NodeValue}, parse_document, Arena, Options, }; -use crate::{ - file_parser::{file_parser::ShinkaiFileParser, file_parser_types::TextGroup}, - resource_errors::VRError, -}; +use crate::{shinkai_fs_error::ShinkaiFsError, simple_parser::{file_parser_helper::ShinkaiFileParser, text_group::TextGroup}}; use super::LocalFileParser; impl LocalFileParser { - #[cfg(feature = "desktop-only")] - pub fn process_md_file(file_buffer: Vec, max_node_text_size: u64) -> Result, VRError> { - let md_string = String::from_utf8(file_buffer).map_err(|_| VRError::FailedMDParsing)?; + pub fn process_md_file(file_buffer: Vec, max_node_text_size: u64) -> Result, ShinkaiFsError> { + let md_string = String::from_utf8(file_buffer).map_err(|_| ShinkaiFsError::FailedMDParsing)?; let arena = Arena::new(); let root = parse_document(&arena, &md_string, &Options::default()); diff --git a/shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/mod.rs b/shinkai-libs/shinkai-fs/src/simple_parser/local_parsing/mod.rs similarity index 57% rename from shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/mod.rs rename to shinkai-libs/shinkai-fs/src/simple_parser/local_parsing/mod.rs index 028f45045..ad6412e97 100644 --- a/shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/mod.rs +++ b/shinkai-libs/shinkai-fs/src/simple_parser/local_parsing/mod.rs @@ -1,11 +1,9 @@ pub mod csv_parsing; -pub mod docx_parsing; pub mod html_parsing; pub mod json_parsing; -pub mod local_parsing; pub mod md_parsing; pub mod pdf_parsing; pub mod txt_parsing; -pub mod xlsx_parsing; -pub use local_parsing::*; + +pub struct LocalFileParser {} \ No newline at end of file diff --git a/shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/pdf_parsing.rs b/shinkai-libs/shinkai-fs/src/simple_parser/local_parsing/pdf_parsing.rs similarity index 63% rename from shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/pdf_parsing.rs rename to shinkai-libs/shinkai-fs/src/simple_parser/local_parsing/pdf_parsing.rs index da7070320..2d8359b98 100644 --- a/shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/pdf_parsing.rs +++ b/shinkai-libs/shinkai-fs/src/simple_parser/local_parsing/pdf_parsing.rs @@ -1,20 +1,18 @@ -#[cfg(feature = "desktop-only")] -use crate::{ - file_parser::{file_parser::ShinkaiFileParser, file_parser_types::TextGroup}, - resource_errors::VRError, -}; +use crate::{shinkai_fs_error::ShinkaiFsError, simple_parser::{file_parser_helper::ShinkaiFileParser, text_group::TextGroup}}; use super::LocalFileParser; impl LocalFileParser { - #[cfg(feature = "desktop-only")] - pub fn process_pdf_file(file_buffer: Vec, max_node_text_size: u64) -> Result, VRError> { + pub fn process_pdf_file(file_buffer: Vec, max_node_text_size: u64) -> Result, ShinkaiFsError> { use shinkai_ocr::pdf_parser::PDFParser; - let pdf_parser = PDFParser::new().map_err(|_| VRError::FailedPDFParsing)?; + let pdf_parser = PDFParser::new().map_err(|_| ShinkaiFsError::FailedPDFParsing)?; let parsed_pages = pdf_parser .process_pdf_file(file_buffer) - .map_err(|_| VRError::FailedPDFParsing)?; + .map_err(|e| { + println!("Error processing PDF file: {:?}", e); + ShinkaiFsError::FailedPDFParsing + })?; let mut text_groups = Vec::new(); diff --git a/shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/txt_parsing.rs b/shinkai-libs/shinkai-fs/src/simple_parser/local_parsing/txt_parsing.rs similarity index 58% rename from shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/txt_parsing.rs rename to shinkai-libs/shinkai-fs/src/simple_parser/local_parsing/txt_parsing.rs index c48ef8dcb..fb7e8b52c 100644 --- a/shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/txt_parsing.rs +++ b/shinkai-libs/shinkai-fs/src/simple_parser/local_parsing/txt_parsing.rs @@ -3,14 +3,12 @@ use std::collections::HashMap; use regex::Regex; use super::LocalFileParser; -use crate::file_parser::file_parser::ShinkaiFileParser; -use crate::file_parser::file_parser_types::TextGroup; -use crate::resource_errors::VRError; +use crate::{shinkai_fs_error::ShinkaiFsError, simple_parser::{file_parser_helper::ShinkaiFileParser, text_group::TextGroup}}; impl LocalFileParser { /// Attempts to process the provided json file into a list of TextGroups. - pub fn process_txt_file(file_buffer: Vec, max_node_text_size: u64) -> Result, VRError> { - let txt_string = String::from_utf8(file_buffer).map_err(|_| VRError::FailedTXTParsing)?; + pub fn process_txt_file(file_buffer: Vec, max_node_text_size: u64) -> Result, ShinkaiFsError> { + let txt_string = String::from_utf8(file_buffer).map_err(|_| ShinkaiFsError::FailedTXTParsing)?; let sentences = LocalFileParser::process_into_sentences(txt_string); let text_groups = LocalFileParser::process_into_text_groups(sentences, max_node_text_size); // for sentence in &sentences { @@ -32,34 +30,32 @@ impl LocalFileParser { for line in text_lines { let (parsed_line, metadata, parsed_any_metadata) = ShinkaiFileParser::parse_and_extract_metadata(&line); - if parsed_line.len() as u64 + current_text.len() as u64 > max_node_text_size { + if (parsed_line.len() as u64 + current_text.len() as u64) > max_node_text_size { if !current_text.is_empty() { - text_groups.push(TextGroup::new( - current_text.clone(), - current_metadata.clone(), - vec![], - None, - )); + text_groups.push( + TextGroup::new(current_text.clone(), current_metadata.clone(), None) + ); current_text.clear(); current_metadata.clear(); } if parsed_line.len() as u64 > max_node_text_size { - // If the line itself exceeds max_node_text_size, split it into chunks - // Split the unparsed line into chunks and parse metadata in each chunk + // If the line itself exceeds max_node_text_size, split it into chunks. let chunks = if parsed_any_metadata { - ShinkaiFileParser::split_into_chunks_with_metadata(&line, max_node_text_size as usize) + ShinkaiFileParser::split_into_chunks_with_metadata( + &line, + max_node_text_size as usize + ) } else { ShinkaiFileParser::split_into_chunks(&line, max_node_text_size as usize) }; for chunk in chunks { - let (parsed_chunk, metadata, _) = if parsed_any_metadata { + let (parsed_chunk, chunk_metadata, _) = if parsed_any_metadata { ShinkaiFileParser::parse_and_extract_metadata(&chunk) } else { (chunk, HashMap::new(), false) }; - - text_groups.push(TextGroup::new(parsed_chunk, metadata, vec![], None)); + text_groups.push(TextGroup::new(parsed_chunk, chunk_metadata, None)); } } else { current_text = parsed_line; @@ -67,16 +63,16 @@ impl LocalFileParser { } } else { if !current_text.is_empty() { - current_text.push(' '); // Add space between sentences + current_text.push(' '); // space between sentences } current_text.push_str(&parsed_line); current_metadata.extend(metadata); } } - // Don't forget to add the last accumulated text as a TextGroup if it's not empty + // Push the last segment if !current_text.is_empty() { - text_groups.push(TextGroup::new(current_text, current_metadata.clone(), vec![], None)); + text_groups.push(TextGroup::new(current_text, current_metadata.clone(), None)); } text_groups @@ -85,9 +81,11 @@ impl LocalFileParser { /// Given a piece of text, split it into a list of sentences, doing its best to respect punctuation /// and taking into account English-based exceptions. pub fn process_into_sentences(text: String) -> Vec { - let punctuation_marks = [',', '.', ';', '-', '&', '(', '{', '<', '"', '\'', '`']; - text.split("\n") - .filter(|line| !line.trim().is_empty() && line.trim().len() > 1) // Filter out empty or nearly empty lines + let punctuation_marks = [ + ',', '.', ';', '-', '&', '(', '{', '<', '"', '\'', '`' + ]; + text.split('\n') + .filter(|line| !line.trim().is_empty() && line.trim().len() > 1) .flat_map(|line| { let trimmed_line = line.trim(); @@ -98,13 +96,16 @@ impl LocalFileParser { .map(|m| m.start() == 0 && m.end() == trimmed_line.len()) .unwrap_or(false); - // Ensure each line ends with a punctuation mark, defaulting to '.' - let line_with_ending = - if is_pure_metadata || punctuation_marks.iter().any(|&mark| trimmed_line.ends_with(mark)) { - trimmed_line.to_string() - } else { - format!("{}\n", trimmed_line) - }; + // Ensure each line ends with punctuation, or default to a newline + let line_with_ending = if is_pure_metadata + || punctuation_marks + .iter() + .any(|&mark| trimmed_line.ends_with(mark)) + { + trimmed_line.to_string() + } else { + format!("{}\n", trimmed_line) + }; Self::split_line_into_sentences(&line_with_ending) }) @@ -116,33 +117,31 @@ impl LocalFileParser { let mut sentences = Vec::new(); let mut start = 0; - // Expanded list of exceptions in lowercase + // Common abbreviations in lowercase let exceptions = [ - " mr.", " mrs.", " ms.", " dr.", " prof.", " gen.", " rep.", " sen.", " jr.", " sr.", " ave.", " blvd.", - " st.", " rd.", " ln.", " ter.", " ct.", " pl.", " p.o.", " a.m.", " p.m.", " cm.", " kg.", " lb.", " oz.", - " ft.", " in.", " mi.", " b.a.", " m.a.", " ph.d.", " m.d.", " b.sc.", " m.sc.", " inc.", " ltd.", " co.", - " corp.", " llc.", " plc.", " et al.", " e.g.", " i.e.", " vs.", " viz.", " approx.", " dept.", " div.", + " mr.", " mrs.", " ms.", " dr.", " prof.", " gen.", " rep.", " sen.", " jr.", " sr.", + " ave.", " blvd.", " st.", " rd.", " ln.", " ter.", " ct.", " pl.", " p.o.", " a.m.", + " p.m.", " cm.", " kg.", " lb.", " oz.", " ft.", " in.", " mi.", " b.a.", " m.a.", + " ph.d.", " m.d.", " b.sc.", " m.sc.", " inc.", " ltd.", " co.", " corp.", " llc.", + " plc.", " et al.", " e.g.", " i.e.", " vs.", " viz.", " approx.", " dept.", " div.", " est.", ]; for (index, _) in line.match_indices(". ") { - let potential_end = index + 1; // Position after the period - let sentence = &line[start..potential_end]; // Extract sentence up to and including the period - - // Convert the end of the sentence to lowercase for case-insensitive comparison + let potential_end = index + 1; + let sentence = &line[start..potential_end]; let sentence_end_lc = sentence.to_lowercase(); - // Check if the sentence ends with an exception and not actually the end of a sentence + // Skip splitting if it matches an abbreviation if exceptions.iter().any(|&exc| sentence_end_lc.ends_with(exc)) { - continue; // Skip splitting here, it's an exception + continue; } - // If it's a valid end of a sentence, push it to the sentences vector sentences.push(sentence.trim().to_string()); - start = potential_end + 1; // Move start to after the space following the period + start = potential_end + 1; } - // Add any remaining part of the line as the last sentence + // Final leftover if start < line.len() { sentences.push(line[start..].trim().to_string()); } @@ -150,3 +149,28 @@ impl LocalFileParser { sentences } } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_process_txt_file_multiple_text_groups() { + let input_text = "This is a test sentence. This is another test sentence."; + let file_buffer = input_text.as_bytes().to_vec(); + let max_node_text_size = 10; // Low max node text size to force multiple text groups + + let result = LocalFileParser::process_txt_file(file_buffer, max_node_text_size); + + assert!(result.is_ok()); + let text_groups = result.unwrap(); + + // We expect more than one text group due to the low max_node_text_size + assert!(text_groups.len() > 1); + + // Optionally, check the content of the text groups + for text_group in text_groups { + println!("TextGroup: {}", text_group.text); + } + } +} diff --git a/shinkai-libs/shinkai-fs/src/simple_parser/mod.rs b/shinkai-libs/shinkai-fs/src/simple_parser/mod.rs new file mode 100644 index 000000000..595c80a8a --- /dev/null +++ b/shinkai-libs/shinkai-fs/src/simple_parser/mod.rs @@ -0,0 +1,5 @@ +pub mod simple_parser; +pub mod local_parsing; +pub mod file_parser_helper; +pub mod text_group; +pub mod file_parser_grouping; \ No newline at end of file diff --git a/shinkai-libs/shinkai-fs/src/simple_parser/simple_parser.rs b/shinkai-libs/shinkai-fs/src/simple_parser/simple_parser.rs new file mode 100644 index 000000000..9109d022d --- /dev/null +++ b/shinkai-libs/shinkai-fs/src/simple_parser/simple_parser.rs @@ -0,0 +1,167 @@ +/* + +- takes a file (filepath) +- checks if it exists +- reads the filetype and redirects to the appropriate parser depending on the filetype +- it gets a vec of chunks (or another structure) +- it returns that + +Use generator: &dyn EmbeddingGenerator for converting chunks to embeddings +also use the generator to know how big the chunks could be +*/ + +use shinkai_message_primitives::shinkai_utils::shinkai_path::ShinkaiPath; + +use crate::shinkai_fs_error::ShinkaiFsError; + +use std::{fmt, fs}; + +use super::{local_parsing::LocalFileParser, text_group::TextGroup}; + +pub struct SimpleParser; + +#[derive(Debug, PartialEq, Eq)] +enum SupportedFileType { + Txt, + Json, + Csv, + Html, + Md, + Pdf, + Xlsx, + Xls, +} + +impl SupportedFileType { + fn from_extension(extension: &str) -> Option { + match extension { + "txt" => Some(SupportedFileType::Txt), + "json" => Some(SupportedFileType::Json), + "csv" => Some(SupportedFileType::Csv), + "html" => Some(SupportedFileType::Html), + "md" => Some(SupportedFileType::Md), + "pdf" => Some(SupportedFileType::Pdf), + "xlsx" => Some(SupportedFileType::Xlsx), + "xls" => Some(SupportedFileType::Xls), + _ => None, + } + } +} + +impl fmt::Display for SupportedFileType { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let file_type_str = match self { + SupportedFileType::Txt => "txt", + SupportedFileType::Json => "json", + SupportedFileType::Csv => "csv", + SupportedFileType::Html => "html", + SupportedFileType::Md => "md", + SupportedFileType::Pdf => "pdf", + SupportedFileType::Xlsx => "xlsx", + SupportedFileType::Xls => "xls", + }; + write!(f, "{}", file_type_str) + } +} + +impl SimpleParser { + pub fn parse_file(filepath: ShinkaiPath, max_node_text_size: u64) -> Result, ShinkaiFsError> { + // check if file exists + if !filepath.exists() { + return Err(ShinkaiFsError::FileNotFoundWithPath(filepath.to_string())); + } + + // extract file extension + let extension = filepath.extension(); + + if extension.is_none() { + return Err(ShinkaiFsError::UnsupportedFileType(filepath.to_string())); + } + + // check if the file extension is supported + let file_type = SupportedFileType::from_extension(extension.unwrap()) + .ok_or_else(|| ShinkaiFsError::UnsupportedFileType(filepath.to_string()))?; + + // read file into memory + let file_buffer = fs::read(&filepath.as_path()).map_err(|e| ShinkaiFsError::FailedIO(e.to_string()))?; + + // call the new function based on the file extension + let text_groups = SimpleParser::process_file_by_extension(file_buffer, file_type, max_node_text_size)?; + + Ok(text_groups) + } + + fn process_file_by_extension( + file_buffer: Vec, + file_type: SupportedFileType, + max_node_text_size: u64, + ) -> Result, ShinkaiFsError> { + match file_type { + SupportedFileType::Txt => LocalFileParser::process_txt_file(file_buffer, max_node_text_size), + SupportedFileType::Json => LocalFileParser::process_json_file(file_buffer, max_node_text_size), + SupportedFileType::Csv => LocalFileParser::process_csv_file(file_buffer, max_node_text_size), + SupportedFileType::Html => LocalFileParser::process_html_file(file_buffer, "filename", max_node_text_size), + SupportedFileType::Md => LocalFileParser::process_md_file(file_buffer, max_node_text_size), + SupportedFileType::Pdf => LocalFileParser::process_pdf_file(file_buffer, max_node_text_size), + _ => Err(ShinkaiFsError::UnsupportedFileType(file_type.to_string())), + // SupportedFileType::Xlsx | SupportedFileType::Xls => LocalFileParser::process_xlsx_file(file_buffer, max_node_text_size), + } + } +} + +#[cfg(test)] +mod tests { + use crate::test_utils::testing_create_tempdir_and_set_env_var; + + use super::*; + use std::fs; + use std::io::Write; + + #[test] + fn test_parse_csv_file() { + let _dir = testing_create_tempdir_and_set_env_var(); + + let shinkai_path = ShinkaiPath::from_string("test.csv".to_string()); + + // Write a simple CSV content to the file + let mut file = fs::File::create(&shinkai_path.as_path()).unwrap(); + writeln!(file, "header1,header2").unwrap(); + writeln!(file, "value1,value2").unwrap(); + + // Call the parse_file function + let result = SimpleParser::parse_file(shinkai_path, 1024); + + // Assert the result is Ok and contains expected data + assert!(result.is_ok()); + let text_groups = result.unwrap(); + assert!(!text_groups.is_empty()); + } + + #[test] + fn test_parse_large_csv_file() { + let _dir = testing_create_tempdir_and_set_env_var(); + + // Create a ShinkaiPath directly + let shinkai_path = ShinkaiPath::from_string("large_test.csv".to_string()); + + // Write a larger CSV content to the file + let mut file = fs::File::create(&shinkai_path.as_path()).unwrap(); + writeln!(file, "header1,header2,header3").unwrap(); + for i in 0..100 { + writeln!(file, "value1_{},value2_{},value3_{}", i, i, i).unwrap(); + } + + // Call the parse_file function with a smaller max_node_text_size + let result = SimpleParser::parse_file(shinkai_path, 20); + + // Assert the result is Ok and contains expected data + assert!(result.is_ok()); + let text_groups = result.unwrap(); + + eprintln!("length: {:?}", text_groups.len()); + + assert!(!text_groups.is_empty()); + + // No need to manually close _dir as it will be automatically cleaned up + } +} diff --git a/shinkai-libs/shinkai-vector-resources/src/file_parser/file_parser_types.rs b/shinkai-libs/shinkai-fs/src/simple_parser/text_group.rs similarity index 89% rename from shinkai-libs/shinkai-vector-resources/src/file_parser/file_parser_types.rs rename to shinkai-libs/shinkai-fs/src/simple_parser/text_group.rs index 843f632d8..04fba8da1 100644 --- a/shinkai-libs/shinkai-vector-resources/src/file_parser/file_parser_types.rs +++ b/shinkai-libs/shinkai-fs/src/simple_parser/text_group.rs @@ -1,15 +1,14 @@ use serde::{Deserialize, Serialize}; use std::collections::{HashMap, HashSet}; -use crate::{embeddings::Embedding, file_parser::file_parser::ShinkaiFileParser}; +use crate::simple_parser::file_parser_helper::ShinkaiFileParser; /// An intermediary type for processing content into Node's held in VectorResources #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] pub struct TextGroup { pub text: String, pub metadata: HashMap, - pub sub_groups: Vec, - pub embedding: Option, + pub embedding: Option>, } impl TextGroup { @@ -17,13 +16,11 @@ impl TextGroup { pub fn new( text: String, metadata: HashMap, - sub_groups: Vec, - embedding: Option, + embedding: Option>, ) -> Self { TextGroup { text, metadata, - sub_groups, embedding, } } @@ -33,7 +30,6 @@ impl TextGroup { TextGroup { text: String::new(), metadata: HashMap::new(), - sub_groups: Vec::new(), embedding: None, } } @@ -114,9 +110,4 @@ impl TextGroup { ), ); } - - /// Pushes a sub-group into this TextGroup - pub fn push_sub_group(&mut self, sub_group: TextGroup) { - self.sub_groups.push(sub_group); - } } diff --git a/shinkai-libs/shinkai-fs/src/test_utils.rs b/shinkai-libs/shinkai-fs/src/test_utils.rs new file mode 100644 index 000000000..fdef751fe --- /dev/null +++ b/shinkai-libs/shinkai-fs/src/test_utils.rs @@ -0,0 +1,27 @@ +// Duplicated code. Find a way to share it. + +#[cfg(test)] + +/// Create a temporary directory and set the NODE_STORAGE_PATH environment variable +/// Return the TempDir object (required so it doesn't get deleted when the function returns) +pub fn testing_create_tempdir_and_set_env_var() -> tempfile::TempDir { + use shinkai_message_primitives::shinkai_utils::shinkai_path::ShinkaiPath; + use std::env; + use std::fs; + use tempfile::tempdir; + + let dir = tempdir().unwrap(); + env::set_var("NODE_STORAGE_PATH", dir.path().to_string_lossy().to_string()); + + let shinkai_path = ShinkaiPath::from_base_path(); + + // Check if the directory exists, and create it if it doesn't + if !shinkai_path.as_path().exists() { + let _ = fs::create_dir_all(&shinkai_path.as_path()).map_err(|e| { + eprintln!("Failed to create directory {}: {}", shinkai_path.as_path().display(), e); + panic!("Failed to create directory {}: {}", shinkai_path.as_path().display(), e); + }); + } + + dir // Return the TempDir object +} diff --git a/shinkai-libs/shinkai-fs/src/vrkai.rs b/shinkai-libs/shinkai-fs/src/vrkai.rs new file mode 100644 index 000000000..e69de29bb diff --git a/shinkai-libs/shinkai-vector-resources/tests/pdf_parsing_tests.rs b/shinkai-libs/shinkai-fs/tests/pdf_parsing_tests.rs similarity index 100% rename from shinkai-libs/shinkai-vector-resources/tests/pdf_parsing_tests.rs rename to shinkai-libs/shinkai-fs/tests/pdf_parsing_tests.rs diff --git a/shinkai-libs/shinkai-fs/tests/vector_resource_tests.rs b/shinkai-libs/shinkai-fs/tests/vector_resource_tests.rs new file mode 100644 index 000000000..a0772831b --- /dev/null +++ b/shinkai-libs/shinkai-fs/tests/vector_resource_tests.rs @@ -0,0 +1,1377 @@ +// use shinkai_vector_resources::data_tags::DataTag; +// use shinkai_vector_resources::embedding_generator::{EmbeddingGenerator, RemoteEmbeddingGenerator}; +// use shinkai_vector_resources::file_parser::file_parser::ShinkaiFileParser; +// use shinkai_vector_resources::source::{DistributionInfo, VRSourceReference}; +// use shinkai_vector_resources::vector_resource::document_resource::DocumentVectorResource; +// use shinkai_vector_resources::vector_resource::map_resource::MapVectorResource; +// use shinkai_vector_resources::vector_resource::vrkai::VRKai; +// use shinkai_vector_resources::vector_resource::vrpack::VRPack; +// use shinkai_vector_resources::vector_resource::BaseVectorResource; +// use shinkai_vector_resources::vector_resource::{ +// FilterMode, NodeContent, ResultsMode, ScoringMode, TraversalMethod, TraversalOption, VectorResourceCore, +// VectorResourceSearch, +// }; +// use shinkai_vector_resources::vector_resource::{RetrievedNode, VRPath}; +// use std::collections::HashMap; + +// pub fn default_vector_resource_doc() -> DocumentVectorResource { +// let generator = RemoteEmbeddingGenerator::new_default(); +// let mut doc = DocumentVectorResource::new_empty( +// "3 Animal Facts", +// Some("A bunch of facts about animals and wildlife"), +// VRSourceReference::new_uri_ref("animalwildlife.com"), +// true, +// ); + +// doc.set_embedding_model_used(generator.model_type()); // Not required, but good practice +// doc.update_resource_embedding_blocking(&generator, Some(vec!["animal".to_string(), "wild life".to_string()])) +// .unwrap(); + +// // Prepare embeddings + data, then add it to the doc +// let fact1 = "Dogs are creatures with 4 legs that bark."; +// let fact1_embedding = generator.generate_embedding_default_blocking(fact1).unwrap(); +// let fact2 = "Camels are slow animals with large humps."; +// let fact2_embedding = generator.generate_embedding_default_blocking(fact2).unwrap(); +// let fact3 = "Seals swim in the ocean."; +// let fact3_embedding = generator.generate_embedding_default_blocking(fact3).unwrap(); +// let _ = doc +// .append_text_node(fact1, None, fact1_embedding.clone(), &vec![]) +// .unwrap(); +// let _ = doc +// .append_text_node(fact2, None, fact2_embedding.clone(), &vec![]) +// .unwrap(); +// let _ = doc +// .append_text_node(fact3, None, fact3_embedding.clone(), &vec![]) +// .unwrap(); +// return doc; +// } + +// fn default_vr_kai() -> VRKai { +// let resource = BaseVectorResource::Document(default_vector_resource_doc()); +// VRKai::new(resource, None) +// } + +// fn default_vr_pack() -> VRPack { +// let vrkai = default_vr_kai(); +// let mut vrpack = VRPack::new_empty(""); +// let _ = vrpack.insert_vrkai(&vrkai, VRPath::root(), true); +// vrpack +// } + +// #[test] +// fn test_vr_kai_prepare_and_parse_methods() { +// let vr_kai = default_vr_kai(); + +// // Test encode_as_base64 and from_base64 +// let base64_encoded = vr_kai.encode_as_base64().expect("Failed to prepare as base64"); +// let parsed_from_base64 = VRKai::from_base64(&base64_encoded).expect("Failed to parse from base64"); +// assert_eq!( +// serde_json::to_string(&vr_kai).unwrap(), +// serde_json::to_string(&parsed_from_base64).unwrap() +// ); + +// // Test encode_as_bytes and from_bytes +// let bytes_encoded = vr_kai.encode_as_bytes().expect("Failed to prepare as bytes"); +// let parsed_from_bytes = VRKai::from_bytes(&bytes_encoded).expect("Failed to parse from bytes"); +// assert_eq!( +// serde_json::to_string(&vr_kai).unwrap(), +// serde_json::to_string(&parsed_from_bytes).unwrap() +// ); + +// // Test to_json and from_json for completeness +// let json_str = vr_kai.to_json().expect("Failed to convert to JSON"); +// let parsed_from_json = VRKai::from_json(&json_str).expect("Failed to parse from JSON"); +// assert_eq!( +// serde_json::to_string(&vr_kai).unwrap(), +// serde_json::to_string(&parsed_from_json).unwrap() +// ); +// } + +// #[test] +// fn test_vr_pack_prepare_and_parse_methods() { +// let vr_pack = default_vr_pack(); + +// // Test encode_as_base64 and from_base64 +// let base64_encoded = vr_pack.encode_as_base64().expect("Failed to prepare as base64"); +// let parsed_from_base64 = VRPack::from_base64(&base64_encoded).expect("Failed to parse from base64"); +// assert_eq!( +// serde_json::to_string(&vr_pack).unwrap(), +// serde_json::to_string(&parsed_from_base64).unwrap() +// ); + +// // Test encode_as_bytes and from_bytes +// let bytes_encoded = vr_pack.encode_as_bytes().expect("Failed to prepare as bytes"); +// let parsed_from_bytes = VRPack::from_bytes(&bytes_encoded).expect("Failed to parse from bytes"); +// assert_eq!( +// serde_json::to_string(&vr_pack).unwrap(), +// serde_json::to_string(&parsed_from_bytes).unwrap() +// ); + +// // Test to_json and from_json for completeness +// let json_str = vr_pack.to_json().expect("Failed to convert to JSON"); +// let parsed_from_json = VRPack::from_json(&json_str).expect("Failed to parse from JSON"); +// assert_eq!( +// serde_json::to_string(&vr_pack).unwrap(), +// serde_json::to_string(&parsed_from_json).unwrap() +// ); +// } + +// #[test] +// fn test_remote_embedding_generation() { +// let generator = RemoteEmbeddingGenerator::new_default(); + +// let dog_embedding = generator.generate_embedding_default_blocking("dog").unwrap(); +// let cat_embedding = generator.generate_embedding_default_blocking("cat").unwrap(); + +// assert_eq!(dog_embedding, dog_embedding); +// assert_eq!(cat_embedding, cat_embedding); +// assert_ne!(dog_embedding, cat_embedding); +// } + +// #[tokio::test] +// async fn test_remote_embedding_generation_async_batched() { +// let generator = RemoteEmbeddingGenerator::new_default(); + +// let inputs = vec![ +// "dog", "cat", "lion", "tiger", "elephant", "giraffe", "zebra", "bear", "wolf", "fox", +// ] +// .into_iter() +// .map(|s| s.to_string()) +// .collect::>(); +// let ids = vec!["".to_string(); inputs.len()]; +// let embeddings = generator.generate_embeddings(&inputs, &ids).await.unwrap(); + +// for (animal, embedding) in inputs.iter().zip(embeddings.iter()) { +// println!("Embedding for {}: {:?}", animal, embedding); +// } + +// assert_ne!(embeddings[0], embeddings[1]); +// assert_ne!(embeddings[0], embeddings[2]); +// assert_ne!(embeddings[0], embeddings[3]); +// assert_ne!(embeddings[0], embeddings[4]); +// assert_ne!(embeddings[0], embeddings[5]); +// assert_ne!(embeddings[0], embeddings[6]); +// assert_ne!(embeddings[0], embeddings[7]); +// assert_ne!(embeddings[0], embeddings[8]); +// assert_ne!(embeddings[0], embeddings[9]); +// } + +// #[test] +// fn test_manual_resource_vector_search() { +// let generator = RemoteEmbeddingGenerator::new_default(); + +// // +// // Create a first resource +// // +// let fact1 = "Dogs are creatures with 4 legs that bark."; +// let _fact1_embedding = generator.generate_embedding_default_blocking(fact1).unwrap(); +// let fact2 = "Camels are slow animals with large humps."; +// let _fact2_embedding = generator.generate_embedding_default_blocking(fact2).unwrap(); +// let fact3 = "Seals swim in the ocean."; +// let _fact3_embedding = generator.generate_embedding_default_blocking(fact3).unwrap(); + +// let doc = default_vector_resource_doc(); + +// // Testing JSON serialization/deserialization +// let json = doc.to_json().unwrap(); +// let deserialized_doc: DocumentVectorResource = DocumentVectorResource::from_json(&json).unwrap(); +// assert_eq!(doc, deserialized_doc); + +// // Testing basic vector search works +// let query_string = "What animal barks?"; +// let query_embedding1 = generator.generate_embedding_default_blocking(query_string).unwrap(); +// let res = doc.vector_search(query_embedding1.clone(), 1); +// assert_eq!(fact1, res[0].node.get_text_content().unwrap().to_string()); + +// let query_string2 = "What animal is slow?"; +// let query_embedding2 = generator.generate_embedding_default_blocking(query_string2).unwrap(); +// let res2 = doc.vector_search(query_embedding2.clone(), 3); +// assert_eq!(fact2, res2[0].node.get_text_content().unwrap().to_string()); + +// let query_string3 = "What animal swims in the ocean?"; +// let query_embedding3 = generator.generate_embedding_default_blocking(query_string3).unwrap(); +// let res3 = doc.vector_search(query_embedding3, 2); +// assert_eq!(fact3, res3[0].node.get_text_content().unwrap().to_string()); + +// // +// // Create a 2nd resource, a MapVectorResource +// // +// let mut map_resource = MapVectorResource::new_empty( +// "Tech Facts", +// Some("A collection of facts about technology"), +// VRSourceReference::new_uri_ref("veryrealtechfacts.com"), +// true, +// ); + +// map_resource.set_embedding_model_used(generator.model_type()); // Not required, but good practice +// map_resource +// .update_resource_embedding_blocking(&generator, Some(vec!["technology".to_string(), "phones".to_string()])) +// .unwrap(); + +// // Prepare embeddings + data, then add it to the map resource +// let fact4 = "Phones provide the power of the internet in your pocket."; +// let fact4_embedding = generator.generate_embedding_default_blocking(fact4).unwrap(); +// let _ = map_resource.insert_text_node( +// "some_key".to_string(), +// fact4.to_string(), +// None, +// fact4_embedding.clone(), +// &vec![], +// ); + +// // Insert the document resource into the map resource +// // To allow for this composability we need to convert the doc into a BaseVectorResource +// let doc_resource = BaseVectorResource::from(doc); +// let _ = map_resource.insert_vector_resource_node_auto("doc_key", doc_resource, None); + +// // +// // Create a third resource, a DocumentVectorResource about fruits +// // +// let mut fruit_doc = DocumentVectorResource::new_empty( +// "Fruit Facts", +// Some("A collection of facts about fruits"), +// VRSourceReference::new_uri_ref("ostensiblyrealfruitfacts.com"), +// true, +// ); +// fruit_doc.set_embedding_model_used(generator.model_type()); // Not required, but good practice + +// // Prepare embeddings + data, then add it to the fruit doc +// let fact5 = "Apples are sweet and crunchy."; +// let fact5_embedding = generator.generate_embedding_default_blocking(fact5).unwrap(); +// let fact6 = "Bananas are tasty and come in their own natural packaging."; +// let fact6_embedding = generator.generate_embedding_default_blocking(fact6).unwrap(); +// let _ = fruit_doc.append_text_node(fact5, None, fact5_embedding.clone(), &vec![]); +// let _ = fruit_doc.append_text_node(fact6, None, fact6_embedding.clone(), &vec![]); + +// // Insert the map resource into the fruit doc +// let map_resource = BaseVectorResource::from(map_resource); +// let mut new_map_resource = map_resource.as_map_resource_cloned().unwrap(); +// let _ = fruit_doc.append_vector_resource_node_auto(map_resource, None); + +// // +// // Perform Vector Search Tests Through All Levels/Resources +// // + +// // Perform a vector search for data 2 levels lower in the fruit doc to ensure +// // that vector searches propagate inwards through all resources +// let res = fruit_doc.vector_search(query_embedding1.clone(), 5); +// assert_eq!(fact1, res[0].node.get_text_content().unwrap().to_string()); +// // Perform a VRPath test to validate depth & path formatting +// assert_eq!("/3/doc_key/1", res[0].format_path_to_string()); +// assert_eq!(2, res[0].retrieval_path.depth()); + +// // Perform a vector search for data 1 level lower in the tech map resource +// let query_string = "What can I use to access the internet?"; +// let query_embedding = generator.generate_embedding_default_blocking(query_string).unwrap(); +// let res = fruit_doc.vector_search(query_embedding, 5); +// assert_eq!(fact4, res[0].node.get_text_content().unwrap().to_string()); +// // Perform a VRPath test to validate depth & path formatting +// assert_eq!("/3/some_key", res[0].format_path_to_string()); +// assert_eq!(1, res[0].retrieval_path.depth()); + +// // Perform a vector search on the fruit doc +// // for data on the base level +// let query_string = "What fruit has its own packaging?"; +// let query_embedding = generator.generate_embedding_default_blocking(query_string).unwrap(); +// let res = fruit_doc.vector_search(query_embedding.clone(), 10); +// assert_eq!(fact6, res[0].node.get_text_content().unwrap().to_string()); +// // Perform a VRPath test to validate depth & path formatting +// assert_eq!("/2", res[0].format_path_to_string()); +// assert_eq!(0, res[0].retrieval_path.depth()); + +// // +// // Traversal Tests +// // +// // Perform UntilDepth(0) traversal to ensure it is working properly, assert the dog fact1 cant be found +// let res = fruit_doc.vector_search_customized( +// query_embedding1.clone(), +// 5, +// TraversalMethod::Efficient, +// &vec![TraversalOption::UntilDepth(0)], +// None, +// vec![], +// ); +// assert_ne!(fact1, res[0].node.get_text_content().unwrap().to_string()); +// assert_eq!(0, res[0].retrieval_path.depth()); +// // Perform UntilDepth(1) traversal to ensure it is working properly, assert the BaseVectorResource for animals is found (not fact1) +// let res = fruit_doc.vector_search_customized( +// query_embedding1.clone(), +// 5, +// TraversalMethod::Exhaustive, +// &vec![TraversalOption::UntilDepth(1)], +// None, +// vec![], +// ); +// assert_eq!( +// "3 Animal Facts", +// res[0] +// .node +// .get_vector_resource_content() +// .unwrap() +// .as_trait_object() +// .name() +// ); +// // Perform UntilDepth(2) traversal to ensure it is working properly, assert dog fact1 is found at the correct depth +// let res = fruit_doc.vector_search_customized( +// query_embedding1.clone(), +// 5, +// TraversalMethod::Exhaustive, +// &vec![TraversalOption::UntilDepth(2)], +// None, +// vec![], +// ); +// assert_eq!(NodeContent::Text(fact1.to_string()), res[0].node.content); +// // Perform MinimumScore option with impossible score to ensure it is working properly +// let res = fruit_doc.vector_search_customized( +// query_embedding1.clone(), +// 5, +// TraversalMethod::Exhaustive, +// &vec![TraversalOption::MinimumScore(0.99)], +// None, +// vec![], +// ); +// assert_eq!(res.len(), 0); + +// // Perform MinimumScore option with low score to ensure it is working properly +// let res = fruit_doc.vector_search_customized( +// query_embedding1.clone(), +// 5, +// TraversalMethod::Exhaustive, +// &vec![TraversalOption::MinimumScore(0.01)], +// None, +// vec![], +// ); +// assert!(!res.is_empty()); + +// // Perform a VRPath test to validate depth & path formatting +// assert_eq!("/3/doc_key/1", res[0].format_path_to_string()); +// assert_eq!(2, res[0].retrieval_path.depth()); + +// // Perform Exhaustive traversal to ensure it is working properly, assert dog fact1 is found at the correct depth +// // By requesting only 1 result, Efficient traversal does not go deeper, while Exhaustive makes it all the way to the bottom +// let res = fruit_doc.vector_search_customized( +// query_embedding1.clone(), +// 1, +// TraversalMethod::Exhaustive, +// &vec![TraversalOption::SetScoringMode(ScoringMode::HierarchicalAverageScoring)], +// None, +// vec![], +// ); +// assert_eq!(NodeContent::Text(fact1.to_string()), res[0].node.content); +// let res = fruit_doc.vector_search_customized( +// query_embedding1.clone(), +// 1, +// TraversalMethod::Efficient, +// &vec![TraversalOption::SetScoringMode(ScoringMode::HierarchicalAverageScoring)], +// None, +// vec![], +// ); +// assert_ne!(NodeContent::Text(fact1.to_string()), res[0].node.content); + +// // +// // Path Tests +// // +// let res = fruit_doc.vector_search_customized( +// query_embedding1.clone(), +// 100, +// TraversalMethod::Exhaustive, +// &vec![TraversalOption::SetScoringMode(ScoringMode::HierarchicalAverageScoring)], +// None, +// vec![], +// ); +// assert_eq!(res.len(), 6); +// let path = ShinkaiPath::from_string("/3/").unwrap(); +// let res = fruit_doc.vector_search_customized( +// query_embedding1.clone(), +// 100, +// TraversalMethod::Exhaustive, +// &vec![TraversalOption::SetScoringMode(ScoringMode::HierarchicalAverageScoring)], +// Some(path), +// vec![], +// ); +// assert_eq!(res.len(), 4); +// let path = ShinkaiPath::from_string("/3/doc_key/").unwrap(); +// let res = fruit_doc.vector_search_customized( +// query_embedding1.clone(), +// 100, +// TraversalMethod::Exhaustive, +// &vec![TraversalOption::SetScoringMode(ScoringMode::HierarchicalAverageScoring)], +// Some(path), +// vec![], +// ); +// assert_eq!(res.len(), 3); + +// // Metadata Filter Tests +// let res = fruit_doc.vector_search_customized( +// query_embedding1.clone(), +// 100, +// TraversalMethod::Exhaustive, +// &vec![TraversalOption::SetFilterMode( +// FilterMode::ContainsAnyMetadataKeyValues(vec![ +// ("key".to_string(), Some("value".to_string())), +// ("other_key".to_string(), None), +// ]), +// )], +// None, +// vec![], +// ); +// assert_eq!(res.len(), 0); + +// let res = fruit_doc.vector_search_customized( +// query_embedding1.clone(), +// 100, +// TraversalMethod::Exhaustive, +// &vec![TraversalOption::SetFilterMode( +// FilterMode::ContainsAllMetadataKeyValues(vec![ +// ("key".to_string(), Some("value".to_string())), +// ("other_key".to_string(), None), +// ]), +// )], +// None, +// vec![], +// ); +// assert_eq!(res.len(), 0); + +// // Creating fake metadata to test with +// let mut hm1 = HashMap::new(); +// hm1.insert("common_key".to_string(), "common_value".to_string()); +// hm1.insert("unique_key1".to_string(), "unique_value1".to_string()); + +// let mut hm2 = HashMap::new(); +// hm2.insert("common_key".to_string(), "common_value".to_string()); +// hm2.insert("unique_key2".to_string(), "unique_value2".to_string()); + +// let _ = fruit_doc.append_text_node(fact5, Some(hm1), fact5_embedding.clone(), &vec![]); +// let _ = fruit_doc.append_text_node(fact6, Some(hm2), fact6_embedding.clone(), &vec![]); + +// // Check any filtering, with the common key/value +// let res = fruit_doc.vector_search_customized( +// query_embedding1.clone(), +// 100, +// TraversalMethod::Exhaustive, +// &vec![TraversalOption::SetFilterMode( +// FilterMode::ContainsAnyMetadataKeyValues(vec![ +// ("uniq".to_string(), Some("e".to_string())), +// ("common_key".to_string(), Some("common_value".to_string())), +// ]), +// )], +// None, +// vec![], +// ); +// assert_eq!(res.len(), 2); + +// // Check all filtering, including with None value skipping +// let res = fruit_doc.vector_search_customized( +// query_embedding1.clone(), +// 100, +// TraversalMethod::Exhaustive, +// &vec![TraversalOption::SetFilterMode( +// FilterMode::ContainsAllMetadataKeyValues(vec![ +// ("common_key".to_string(), None), +// ("unique_key2".to_string(), Some("unique_value2".to_string())), +// ]), +// )], +// None, +// vec![], +// ); +// assert_eq!(res.len(), 1); + +// // Check Proximity search results mode +// let res = fruit_doc.vector_search_customized( +// query_embedding1.clone(), +// 100, +// TraversalMethod::Exhaustive, +// &vec![TraversalOption::SetResultsMode(ResultsMode::ProximitySearch(1, 1))], +// None, +// vec![], +// ); +// new_map_resource.print_all_nodes_exhaustive(None, true, false); +// assert_eq!(res.len(), 2); +// let res = fruit_doc.vector_search_customized( +// query_embedding2.clone(), +// 100, +// TraversalMethod::Exhaustive, +// &vec![TraversalOption::SetResultsMode(ResultsMode::ProximitySearch(1, 1))], +// None, +// vec![], +// ); +// new_map_resource.print_all_nodes_exhaustive(None, true, false); +// assert_eq!(res.len(), 3); + +// // The nodes are already included in the first top results proximity, so this checks that there's no more. +// let res = fruit_doc.vector_search_customized( +// query_embedding2.clone(), +// 100, +// TraversalMethod::Exhaustive, +// &vec![TraversalOption::SetResultsMode(ResultsMode::ProximitySearch(2, 1))], +// None, +// vec![], +// ); +// assert_eq!(res.len(), 3); + +// let _ = fruit_doc.append_text_node(fact6, None, fact6_embedding.clone(), &vec![]); +// let _ = fruit_doc.append_text_node(fact6, None, fact6_embedding.clone(), &vec![]); + +// println!("\n\nFruit doc:"); +// fruit_doc.print_all_nodes_exhaustive(None, true, false); + +// // Check that proximity window works +// let query_string = "Whats an apple?"; +// let query_embedding_fruit = generator.generate_embedding_default_blocking(query_string).unwrap(); + +// let res = fruit_doc.vector_search_customized( +// query_embedding_fruit.clone(), +// 100, +// TraversalMethod::Exhaustive, +// &vec![TraversalOption::SetResultsMode(ResultsMode::ProximitySearch(1, 2))], +// None, +// vec![], +// ); +// assert_eq!(res.len(), 5); + +// let res = fruit_doc.vector_search_customized( +// query_embedding_fruit.clone(), +// 100, +// TraversalMethod::Exhaustive, +// &vec![TraversalOption::SetResultsMode(ResultsMode::ProximitySearch(2, 2))], +// None, +// vec![], +// ); + +// assert_eq!(res.len(), 6); + +// // Verify proximity grouping is working +// let res = fruit_doc.vector_search_customized( +// query_embedding_fruit.clone(), +// 100, +// TraversalMethod::Exhaustive, +// &vec![TraversalOption::SetResultsMode(ResultsMode::ProximitySearch(1, 2))], +// None, +// vec![], +// ); + +// let grouped_results = RetrievedNode::group_proximity_results(&res).unwrap(); + +// for (index, group) in grouped_results.iter().enumerate() { +// println!("Group {}:", index); +// for result in group { +// println!("Result: {:?}", result.retrieval_path); +// } +// } +// assert_eq!(grouped_results.len(), 2); +// assert_eq!(grouped_results[0].len(), 3); +// assert_eq!(grouped_results[1].len(), 2); + +// // Check the metadata_index +// println!("Metdata index: {:?}", fruit_doc.metadata_index()); +// assert_eq!(fruit_doc.metadata_index().get_all_metadata_keys().len(), 3); + +// // At path method tests + +// // Insert/retrieve tests +// let path = ShinkaiPath::from_string("/doc_key/").unwrap(); +// new_map_resource +// .insert_vector_resource_node_at_path( +// path, +// "4", +// BaseVectorResource::Map(new_map_resource.clone()), +// None, +// new_map_resource.resource_embedding().clone(), +// ) +// .unwrap(); +// let test_path = ShinkaiPath::from_string("/doc_key/4/doc_key/3").unwrap(); +// let res = new_map_resource.retrieve_node_at_path(test_path.clone(), None).unwrap(); +// assert_eq!(res.node.id, "3"); +// assert_eq!(res.retrieval_path.to_string(), test_path.to_string()); + +// // Validate embedding retrieval works by regenerating the embedding from the text +// let embedding = new_map_resource.retrieve_embedding_at_path(test_path.clone()).unwrap(); +// match res.node.content { +// NodeContent::Text(text) => { +// let regenerated_embedding = generator.generate_embedding_blocking(&text, "3").unwrap(); +// assert_eq!(embedding, regenerated_embedding); +// } +// _ => panic!("Node content is not text"), +// } +// // Proximity retrieval test +// let test_path = ShinkaiPath::from_string("/doc_key/4/doc_key/3").unwrap(); +// new_map_resource.print_all_nodes_exhaustive(None, true, false); +// let res = new_map_resource +// .proximity_retrieve_nodes_at_path(test_path.clone(), 1, None) +// .unwrap(); +// assert_eq!(res.len(), 2); +// let test_path = ShinkaiPath::from_string("/doc_key/4/doc_key/2").unwrap(); +// let res = new_map_resource +// .proximity_retrieve_nodes_at_path(test_path.clone(), 1, None) +// .unwrap(); +// assert_eq!(res.len(), 3); +// let test_path = ShinkaiPath::from_string("/doc_key/4/doc_key/1").unwrap(); +// let res = new_map_resource +// .proximity_retrieve_nodes_at_path(test_path.clone(), 1, None) +// .unwrap(); +// assert_eq!(res.len(), 2); +// let res = new_map_resource +// .proximity_retrieve_nodes_at_path(test_path.clone(), 5000, None) +// .unwrap(); +// assert_eq!(res.len(), 3); + +// // Check that no node is retrieved after removing it by path +// let test_path = ShinkaiPath::from_string("/doc_key/4/doc_key/3").unwrap(); +// let _ = new_map_resource.remove_node_at_path(test_path.clone(), true); +// let res = new_map_resource.retrieve_node_at_path(test_path.clone(), None); +// assert!(!res.is_ok()); + +// // Replace an existing node in a Map Resource and validate it's been changed +// let test_path = ShinkaiPath::from_string("/doc_key/4/some_key").unwrap(); +// let initial_node = new_map_resource.retrieve_node_at_path(test_path.clone(), None).unwrap(); +// new_map_resource +// .replace_with_text_node_at_path( +// test_path.clone(), +// "----My new node value----".to_string(), +// None, +// fact6_embedding.clone(), +// vec![], +// ) +// .unwrap(); +// let new_node = new_map_resource.retrieve_node_at_path(test_path.clone(), None).unwrap(); +// assert_ne!(initial_node, new_node); +// assert_eq!( +// NodeContent::Text("----My new node value----".to_string()), +// new_node.node.content +// ); + +// // Replace an existing node in a Doc Resource and validate it's been changed +// let test_path = ShinkaiPath::from_string("/doc_key/4/doc_key/2").unwrap(); +// let initial_node = new_map_resource.retrieve_node_at_path(test_path.clone(), None).unwrap(); +// new_map_resource +// .replace_with_text_node_at_path( +// test_path.clone(), +// "----My new node value 2----".to_string(), +// None, +// fact6_embedding.clone(), +// vec![], +// ) +// .unwrap(); +// let new_node = new_map_resource.retrieve_node_at_path(test_path.clone(), None).unwrap(); +// assert_ne!(initial_node, new_node); +// assert_eq!( +// NodeContent::Text("----My new node value 2----".to_string()), +// new_node.node.content +// ); + +// // Append a node into a Doc Resource and validate it's been added +// let mut fruit_doc = fruit_doc.clone(); +// let path = ShinkaiPath::from_string("/3/doc_key/").unwrap(); +// fruit_doc +// .append_text_node_at_path( +// path, +// "--- appended text node ---", +// None, +// new_map_resource.resource_embedding().clone(), +// &vec![], +// ) +// .unwrap(); +// let test_path = ShinkaiPath::from_string("/3/doc_key/4").unwrap(); +// let res = fruit_doc.retrieve_node_at_path(test_path.clone(), None).unwrap(); +// assert_eq!(res.node.id, "4"); +// assert_eq!(res.retrieval_path.to_string(), test_path.to_string()); + +// // Pop the previously appended node +// let path = ShinkaiPath::from_string("/3/doc_key/").unwrap(); +// fruit_doc.pop_node_at_path(path, true).unwrap(); +// let test_path = ShinkaiPath::from_string("/3/doc_key/4").unwrap(); +// let res = fruit_doc.retrieve_node_at_path(test_path.clone(), None); +// assert_eq!(res.is_ok(), false); + +// // +// // Merkelization Tests +// // +// let path = ShinkaiPath::from_string("/3/doc_key/2").unwrap(); +// let res = fruit_doc.retrieve_node_at_path(path.clone(), None).unwrap(); +// let regened_merkle_hash = res.node._generate_merkle_hash().unwrap(); +// assert_eq!(regened_merkle_hash, res.node.get_merkle_hash().unwrap()); + +// // Store the original Merkle hash +// let original_merkle_hash = fruit_doc.get_merkle_root().unwrap(); + +// // Append a node into a Doc Resource +// let path = ShinkaiPath::from_string("/3/doc_key/").unwrap(); +// fruit_doc +// .append_text_node_at_path( +// path.clone(), +// "--- appended text node ---", +// None, +// new_map_resource.resource_embedding().clone(), +// &vec![], +// ) +// .unwrap(); + +// // Retrieve and store the new Merkle hash +// let new_merkle_hash = fruit_doc.get_merkle_root().unwrap(); +// assert_ne!( +// original_merkle_hash, new_merkle_hash, +// "Merkle hash should be different after append" +// ); + +// // Pop the previously appended node +// fruit_doc.pop_node_at_path(path, true).unwrap(); + +// // Retrieve the Merkle hash again and assert it's the same as the original +// let reverted_merkle_hash = fruit_doc.get_merkle_root().unwrap(); +// assert_eq!( +// original_merkle_hash, reverted_merkle_hash, +// "Merkle hash should be the same as original after pop" +// ); +// } + +// #[test] +// fn test_manual_syntactic_vector_search() { +// let generator = RemoteEmbeddingGenerator::new_default(); + +// // +// // Create a first resource +// // +// let mut doc = DocumentVectorResource::new_empty( +// "CV Data From Resume", +// Some("A bunch of data theoretically parsed out of a CV"), +// VRSourceReference::None, +// true, +// ); +// doc.set_embedding_model_used(generator.model_type()); // Not required, but good practice +// doc.update_resource_embedding_blocking(&generator, Some(vec!["cv".to_string(), "email".to_string()])) +// .unwrap(); + +// // Manually create a few test tags +// let regex1 = r#"[€$¥£][0-9]{1,3}(,[0-9]{3})*(\.[0-9]{2})?\b|\b€[0-9]{1,3}(\.[0-9]{3})*,(0-9{2})?"#; +// let price_tag = DataTag::new("Price", "A price in a major currency", regex1).unwrap(); + +// let regex2 = r#"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"#; +// let email_tag = DataTag::new("Email", "An email address", regex2).unwrap(); + +// let regex3 = r#"(19|20)\d\d[- /.](0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])|(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19|20)\d\d|(0[1-9]|[12][0-9]|3[01])[- /.](0[1-9]|1[012])[- /.](19|20)\d\d"#; +// let date_tag = DataTag::new( +// "Date", +// "Captures dates in three common formats - YYYY-MM-DD, MM/DD/YYYY, and DD/MM/YYYY.", +// regex3, +// ) +// .unwrap(); + +// let regex4 = r#"[0-9]+x"#; +// let multiplier_tag = DataTag::new("Multiplier", "Strings like `100x` which denote a multiplier.", regex4).unwrap(); + +// let data_tags = vec![ +// price_tag.clone(), +// email_tag.clone(), +// date_tag.clone(), +// multiplier_tag.clone(), +// ]; + +// // Prepare embeddings + data, then add it to the doc +// let fact1 = "Name: Joe Smith - Email: joesmith@gmail.com"; +// let fact1_embedding = generator.generate_embedding_default_blocking(fact1).unwrap(); +// let fact2 = "Birthday: 23/03/1980"; +// let fact2_embedding = generator.generate_embedding_default_blocking(fact2).unwrap(); +// let fact3 = "Previous Accomplishments: Drove $1,500,000 in sales at my previous company, which translate to a 4x improvement compared to when I joined."; +// let fact3_embedding = generator.generate_embedding_default_blocking(fact3).unwrap(); +// let _ = doc.append_text_node(fact1, None, fact1_embedding.clone(), &data_tags); +// let _ = doc.append_text_node(fact2, None, fact2_embedding.clone(), &data_tags); +// let _ = doc.append_text_node(fact3, None, fact3_embedding.clone(), &data_tags); + +// // println!("Doc data tag index: {:?}", doc.data_tag_index()); + +// // Email syntactic vector search +// // In Shinkai the LLM Agent would do a Tag Vector Search in node DB to find the email_tag based on user's prompt +// // And then calls syntactic_vector_search to guarantee the data retrieved is of the correct structure/"type" +// let query = generator +// .generate_embedding_default_blocking("What is the applicant's email?") +// .unwrap(); +// let fetched_data = doc.syntactic_vector_search(query, 1, &[email_tag.name.clone()]); +// let fetched_node = fetched_data.first().unwrap(); +// assert_eq!(NodeContent::Text(fact1.to_string()), fetched_node.node.content); + +// // Date syntactic vector search +// let query = generator +// .generate_embedding_default_blocking("What is the applicant's birthday?") +// .unwrap(); +// let fetched_data = doc.syntactic_vector_search(query, 10, &[date_tag.name.clone()]); +// let fetched_node = fetched_data.first().unwrap(); +// assert_eq!(NodeContent::Text(fact2.to_string()), fetched_node.node.content); + +// // Price syntactic vector search +// let query = generator +// .generate_embedding_default_blocking("Any notable accomplishments in previous positions?") +// .unwrap(); +// let fetched_data = doc.syntactic_vector_search(query, 2, &[price_tag.name.clone()]); +// let fetched_node = fetched_data.first().unwrap(); +// assert_eq!(NodeContent::Text(fact3.to_string()), fetched_node.node.content); + +// // Multiplier syntactic vector search +// let query = generator +// .generate_embedding_default_blocking("Any notable accomplishments in previous positions?") +// .unwrap(); +// let fetched_data = doc.syntactic_vector_search(query, 5, &[multiplier_tag.name.clone()]); +// let fetched_node = fetched_data.first().unwrap(); +// assert_eq!(NodeContent::Text(fact3.to_string()), fetched_node.node.content); +// } + +// // #[test] +// fn test_checking_embedding_similarity() { +// let generator = RemoteEmbeddingGenerator::new_default(); + +// // +// // Create a first resource +// // +// let mut doc = DocumentVectorResource::new_empty( +// "3 Animal Facts", +// Some("A bunch of facts about animals and wildlife"), +// VRSourceReference::new_uri_ref("animalwildlife.com"), +// true, +// ); + +// doc.set_embedding_model_used(generator.model_type()); // Not required, but good practice +// doc.update_resource_embedding_blocking(&generator, Some(vec!["animal".to_string(), "wild life".to_string()])) +// .unwrap(); + +// // Prepare embeddings + data, then add it to the doc +// let fact1 = "Dogs are creatures with 4 legs that bark."; +// let fact1_embedding = generator.generate_embedding_default_blocking(fact1).unwrap(); +// let fact2 = "Camels are slow animals with large humps."; +// let fact2_embedding = generator.generate_embedding_default_blocking(fact2).unwrap(); +// let fact3 = "Seals swim in the ocean."; +// let fact3_embedding = generator.generate_embedding_default_blocking(fact3).unwrap(); +// doc.append_text_node(fact1, None, fact1_embedding.clone(), &vec![]) +// .unwrap(); +// doc.append_text_node(fact2, None, fact2_embedding.clone(), &vec![]) +// .unwrap(); +// doc.append_text_node(fact3, None, fact3_embedding.clone(), &vec![]) +// .unwrap(); + +// // Testing small alternations to the input text still retain a high similarity score +// let res = doc.vector_search(fact1_embedding.clone(), 1); +// assert_eq!(fact1, res[0].node.get_text_content().unwrap().to_string()); +// assert!(res[0].score > 0.98); + +// let fact1_embedding_2 = generator.generate_embedding_default_blocking(fact1).unwrap(); +// let res = doc.vector_search(fact1_embedding_2.clone(), 1); +// assert!(res[0].score > 0.98); + +// let similar_to_fact_1 = "Dogs are creatures with 4 legs that bark ."; +// let similar_fact1_embedding = generator +// .generate_embedding_default_blocking(similar_to_fact_1) +// .unwrap(); +// let res = doc.vector_search(similar_fact1_embedding.clone(), 1); +// println!("{} : {}", res[0].score, similar_to_fact_1); +// assert!(res[0].score > 0.98); + +// let similar_to_fact_1 = "Dogs are creatures with 4 legs that bark"; +// let similar_fact1_embedding = generator +// .generate_embedding_default_blocking(similar_to_fact_1) +// .unwrap(); +// let res = doc.vector_search(similar_fact1_embedding.clone(), 1); +// println!("{} : {}", res[0].score, similar_to_fact_1); +// assert!(res[0].score > 0.98); + +// let similar_to_fact_1 = "Dogs are creatures with 4 legs that bark"; +// let similar_fact1_embedding = generator +// .generate_embedding_default_blocking(similar_to_fact_1) +// .unwrap(); +// let res = doc.vector_search(similar_fact1_embedding.clone(), 1); +// println!("{} : {}", res[0].score, similar_to_fact_1); +// assert!(res[0].score > 0.98); + +// let similar_to_fact_1 = "Dogs -- are || creatures ~ with 4 legs, that bark"; +// let similar_fact1_embedding = generator +// .generate_embedding_default_blocking(similar_to_fact_1) +// .unwrap(); +// let res = doc.vector_search(similar_fact1_embedding.clone(), 1); +// println!("{} : {}", res[0].score, similar_to_fact_1); +// assert!(res[0].score < 0.98); +// } + +// #[tokio::test] +// async fn test_embeddings_coherence() { +// let generator = RemoteEmbeddingGenerator::new_default(); + +// let mut doc = DocumentVectorResource::new_empty( +// "3 Animal Facts", +// Some("A bunch of facts about animals and wildlife"), +// VRSourceReference::new_uri_ref("animalwildlife.com"), +// true, +// ); + +// doc.set_embedding_model_used(generator.model_type()); // Not required, but good practice +// doc.update_resource_embedding(&generator, Some(vec!["animal".to_string(), "wild life".to_string()])) +// .await +// .unwrap(); + +// // Prepare embeddings + data, then add it to the doc +// let fact1 = "Dogs are creatures with 4 legs that bark."; +// let fact1_embedding = generator.generate_embedding_default(fact1).await.unwrap(); +// let fact2 = "Camels are slow animals with large humps."; +// let fact2_embedding = generator.generate_embedding_default(fact2).await.unwrap(); +// let fact3 = "Seals swim in the ocean."; +// let fact3_embedding = generator.generate_embedding_default(fact3).await.unwrap(); +// doc.append_text_node(fact1, None, fact1_embedding.clone(), &vec![]) +// .unwrap(); +// doc.append_text_node(fact2, None, fact2_embedding.clone(), &vec![]) +// .unwrap(); +// doc.append_text_node(fact3, None, fact3_embedding.clone(), &vec![]) +// .unwrap(); + +// let cloned_doc = BaseVectorResource::Document(doc.clone()); +// let _ = doc.append_vector_resource_node_auto(cloned_doc, None); + +// assert!(doc.verify_internal_embeddings_coherence(&generator, 0.5).await.is_ok()); +// assert!(doc.verify_internal_embeddings_coherence(&generator, 0.0).await.is_ok()); +// assert!(doc.verify_internal_embeddings_coherence(&generator, 23.4).await.is_ok()); +// } + +// #[tokio::test] +// async fn local_txt_parsing_test() { +// let generator = RemoteEmbeddingGenerator::new_default(); +// let source_file_name = "canada.txt"; +// let buffer = std::fs::read(format!("../../files/{}", source_file_name)).unwrap(); +// let resource = ShinkaiFileParser::process_file_into_resource( +// buffer, +// &generator, +// source_file_name.to_string(), +// None, +// &vec![], +// generator.model_type().max_input_token_count() as u64, +// DistributionInfo::new_empty(), +// ) +// .await +// .unwrap(); + +// // Perform vector search +// let query_string = "Who's donnacona?".to_string(); +// let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); +// let results = resource.as_trait_object().vector_search(query_embedding, 3); + +// assert!(results[0].score > 0.3); +// assert!(results[0].node.get_text_content().unwrap().contains("Donnacona")); +// for result in results { +// // println!("{}:{}", result.score, result.node.get_text_content().unwrap()); +// assert!(result.node.get_text_content().unwrap().len() > 200); +// } +// } + +// #[tokio::test] +// async fn local_csv_parsing_test() { +// let generator = RemoteEmbeddingGenerator::new_default(); +// let source_file_name = "cars.csv"; +// let buffer = std::fs::read(format!("../../files/{}", source_file_name)).unwrap(); +// let resource = ShinkaiFileParser::process_file_into_resource( +// buffer, +// &generator, +// source_file_name.to_string(), +// None, +// &vec![], +// generator.model_type().max_input_token_count() as u64, +// DistributionInfo::new_empty(), +// ) +// .await +// .unwrap(); + +// // Perform vector search +// let query_string = "Which car has 495 horsepower?".to_string(); +// let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); +// let results = resource.as_trait_object().vector_search(query_embedding, 3); + +// assert!(results[0].score > 0.5); +// assert!(results[0].node.get_text_content().unwrap().contains("Corvette")); +// } + +// #[tokio::test] +// async fn local_malformed_csv_parsing_test() { +// let malformed_csv = "\ +// Year,Make,Model,Description,Price +// 1997,Ford,E350,\"ac, abs, moon\",3000 +// 1999,Chevy,\"Venture \"\"Extended Edition\"\"\",\"\""; + +// let generator = RemoteEmbeddingGenerator::new_default(); +// let source_file_name = "cars.csv"; +// let buffer = malformed_csv.as_bytes().to_vec(); +// let resource = ShinkaiFileParser::process_file_into_resource( +// buffer, +// &generator, +// source_file_name.to_string(), +// None, +// &vec![], +// generator.model_type().max_input_token_count() as u64, +// DistributionInfo::new_empty(), +// ) +// .await +// .unwrap(); + +// // Perform vector search +// let query_string = "What is the price of E350?".to_string(); +// let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); +// let results = resource.as_trait_object().vector_search(query_embedding, 3); + +// assert!(results[0].score > 0.5); +// assert!(results[0].node.get_text_content().unwrap().contains("3000")); +// } + +// #[tokio::test] +// async fn local_txt_metadata_parsing_test() { +// let input_text = "\ +// This is a test content with metadata +// timestamp: {{{timestamp:2024-04-17T23:41:30Z}}} +// Username: {{{username:myCoolUsername}}} + +// Main content should remain unaffected. + +// Custom {{{metadata-key:metadata-value}}} should be parsed correctly. + +// Likes: {{{likes:999}}} +// Reposts: {{{reposts:99}}} +// Replies: {{{replies:9}}} + +// Invalid metadata values should be ignored. {{{timestamp:br0K3n}}} + +// Pure metadata should be removed. +// !{{{pg_nums:[19, 20]}}}! + +// Make this long enough to exceed max node text size and add more metadata. +// Datetime {{{datetime:2000-01-2T02:17:59Z}}} should be parsed too."; + +// let generator = RemoteEmbeddingGenerator::new_default(); +// let source_file_name = "test_input.txt"; +// let buffer = input_text.as_bytes().to_vec(); +// let resource = ShinkaiFileParser::process_file_into_resource( +// buffer, +// &generator, +// source_file_name.to_string(), +// None, +// &vec![], +// generator.model_type().max_input_token_count() as u64, +// DistributionInfo::new_empty(), +// ) +// .await +// .unwrap(); + +// // Perform vector search +// let query_string = "What is my username?".to_string(); +// let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); +// let results = resource.as_trait_object().vector_search(query_embedding, 3); + +// assert!(results[0].node.get_text_content().unwrap().contains("myCoolUsername")); +// assert!(!results[0] +// .node +// .get_text_content() +// .unwrap() +// .contains("{{{timestamp:2024-04-17T23:41:30Z}}}")); +// assert!(results[0] +// .node +// .get_text_content() +// .unwrap() +// .contains("2024-04-17T23:41:30Z")); +// assert!(results[0].node.metadata.as_ref().unwrap().contains_key("likes")); +// assert!(!results[0].node.get_text_content().unwrap().contains("pg_nums")); +// assert!(results[0].node.metadata.as_ref().unwrap().contains_key("pg_nums")); +// assert_ne!( +// results[0].node.metadata.as_ref().unwrap().get("datetime").unwrap(), +// "br0K3n" +// ); + +// // Perform another vector search +// let query_string2 = "What is the parsed datetime?".to_string(); +// let query_embedding2 = generator.generate_embedding_default(&query_string2).await.unwrap(); +// let results2 = resource.as_trait_object().vector_search(query_embedding2, 3); + +// assert!(results2[0].node.get_text_content().unwrap().contains("2000")); +// assert!(results2[0].node.metadata.as_ref().unwrap().contains_key("datetime")); +// } + +// #[tokio::test] +// async fn local_csv_metadata_parsing_test() { +// let csv_data = "\ +// Country,City,Airline,Price +// USA,New York,Delta Airlines,500 +// USA,Los Angeles,United Airlines,450 +// UK,London,British Airways,{{{price:600}}} +// France,Paris,Air France,550 +// Germany,Berlin,Lufthansa,400 +// Australia,Sydney,Qantas Airways !{{{carry_pets:true}}}!,700"; + +// let generator = RemoteEmbeddingGenerator::new_default(); +// let source_file_name = "input.csv"; +// let buffer = csv_data.as_bytes().to_vec(); +// let resource = ShinkaiFileParser::process_file_into_resource( +// buffer, +// &generator, +// source_file_name.to_string(), +// None, +// &vec![], +// generator.model_type().max_input_token_count() as u64, +// DistributionInfo::new_empty(), +// ) +// .await +// .unwrap(); + +// // Perform vector search +// let query_string = "What is the price of a London ticket?".to_string(); +// let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); +// let results = resource.as_trait_object().vector_search(query_embedding, 3); + +// assert!(results[0].score > 0.4); +// assert!(results[0].node.get_text_content().unwrap().contains("600")); +// assert!(!results[0].node.get_text_content().unwrap().contains("{{{price:600}}}")); +// assert_eq!(results[0].node.metadata.as_ref().unwrap().get("price").unwrap(), "600"); + +// // Perform another vector search +// let query_string2 = "Which airline goes to Sydney?".to_string(); +// let query_embedding2 = generator.generate_embedding_default(&query_string2).await.unwrap(); +// let results2 = resource.as_trait_object().vector_search(query_embedding2, 3); + +// assert!(results2[0].score > 0.4); +// assert!(results2[0].node.get_text_content().unwrap().contains("Qantas")); +// assert!(!results2[0] +// .node +// .get_text_content() +// .unwrap() +// .contains("!{{{carry_pets:true}}}!")); +// assert_eq!( +// results2[0].node.metadata.as_ref().unwrap().get("carry_pets").unwrap(), +// "true" +// ); +// } + +// // #[tokio::test] +// async fn local_md_parsing_test() { +// let generator = RemoteEmbeddingGenerator::new_default(); +// let source_file_name = "parsed_channels.md"; +// let buffer = std::fs::read(format!("../../files/{}", source_file_name)).unwrap(); +// let resource = ShinkaiFileParser::process_file_into_resource( +// buffer, +// &generator, +// source_file_name.to_string(), +// None, +// &vec![], +// generator.model_type().max_input_token_count() as u64, +// DistributionInfo::new_empty(), +// ) +// .await +// .unwrap(); + +// resource +// .as_trait_object() +// .print_all_nodes_exhaustive(None, false, false); + +// // Perform vector search +// let query_string = "What is happening on OpenSea?".to_string(); +// let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); +// let results = resource.as_trait_object().vector_search(query_embedding, 3); + +// assert!(results[0].score > 0.7); +// assert!(results[0] +// .node +// .get_text_content() +// .unwrap() +// .contains("KoL Token has successfully launched")); +// assert_eq!(results[0].node.metadata.as_ref().unwrap().len(), 9); +// assert_eq!(results[0].node.metadata.as_ref().unwrap().get("recasts").unwrap(), "0"); +// assert_eq!( +// results[0].node.metadata.as_ref().unwrap().get("hash").unwrap(), +// "0x43b9a4bc24246855e3d5f4459a7a3d79e50505e6" +// ); + +// // Get Farcaster Posts +// let query_string = "Get Farcaster Posts".to_string(); +// let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); +// let results = resource.as_trait_object().vector_search(query_embedding, 3); + +// assert!(results.iter().all(|node| node.score > 0.6)); +// assert!(results +// .iter() +// .any(|node| node.node.get_text_content().unwrap().contains("Pepe Runner 2049"))); +// assert!(results +// .iter() +// .any(|node| node.node.get_text_content().unwrap().contains("i never remember"))); +// assert!(results +// .iter() +// .any(|node| node.node.get_text_content().unwrap().contains("wowow.shibuya.xyz"))); + +// // Shinkai Vector Resources +// let query_string = "Explain Shinkai Vector Resources".to_string(); +// let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); +// let results = resource.as_trait_object().vector_search(query_embedding, 3); + +// assert!(results[0].score > 0.6); +// assert!(results[0] +// .node +// .get_text_content() +// .unwrap() +// .contains("A powerful native Rust")); + +// // Test URL metadata parsing +// let query_string = "How to import into project?".to_string(); +// let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); +// let results = resource.as_trait_object().vector_search(query_embedding, 3); + +// assert_eq!( +// results[0].node.metadata.as_ref().unwrap().get("link-urls").unwrap(), +// &serde_json::to_string(&vec!["[desktop-only](https://www.shinkai.com/)"]).unwrap() +// ); +// assert!(results[0] +// .node +// .metadata +// .as_ref() +// .unwrap() +// .get("image-urls") +// .unwrap() +// .contains("WebAssembly_Logo.svg")); +// assert!(!results[0] +// .node +// .get_text_content() +// .unwrap() +// .contains("WebAssembly_Logo.svg")); +// } + +// // #[tokio::test] +// async fn local_html_parsing_test() { +// let generator = RemoteEmbeddingGenerator::new_default(); +// let source_file_name = "sample.html"; +// let buffer = std::fs::read(format!("../../files/{}", source_file_name)).unwrap(); +// let resource = ShinkaiFileParser::process_file_into_resource( +// buffer, +// &generator, +// source_file_name.to_string(), +// None, +// &vec![], +// generator.model_type().max_input_token_count() as u64, +// DistributionInfo::new_empty(), +// ) +// .await +// .unwrap(); + +// // Perform vector search +// let query_string = "Explain Benefits of AI in Video Processing".to_string(); +// let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); +// let results = resource.as_trait_object().vector_search(query_embedding, 3); + +// assert!(results[0].score > 0.8); +// assert!(results[0] +// .node +// .get_text_content() +// .unwrap() +// .contains("Improved video analysis")); + +// // Test URL metadata parsing +// let query_string = "Video Processing Solutions with AI".to_string(); +// let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); +// let results = resource.as_trait_object().vector_search(query_embedding, 3); + +// assert!(results[0].score > 0.7); +// assert!(results.iter().any(|node| node +// .node +// .metadata +// .as_ref() +// .unwrap_or(&HashMap::new()) +// .get("image-urls") +// .unwrap_or(&String::new()) +// .contains("Video Processing"))); +// assert!(results.iter().any(|node| node +// .node +// .metadata +// .as_ref() +// .unwrap_or(&HashMap::new()) +// .get("link-urls") +// .unwrap_or(&String::new()) +// .contains("AI Video"))); +// } + +// #[tokio::test] +// async fn local_docx_parsing_test() { +// let generator = RemoteEmbeddingGenerator::new_default(); +// let source_file_name = "decision_log.docx"; +// let buffer = std::fs::read(format!("../../files/{}", source_file_name)).unwrap(); +// let resource = ShinkaiFileParser::process_file_into_resource( +// buffer, +// &generator, +// source_file_name.to_string(), +// None, +// &vec![], +// generator.model_type().max_input_token_count() as u64, +// DistributionInfo::new_empty(), +// ) +// .await +// .unwrap(); + +// resource +// .as_trait_object() +// .print_all_nodes_exhaustive(None, false, false); + +// // Perform vector search +// let query_string = "What does this document track?".to_string(); +// let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); +// let results = resource.as_trait_object().vector_search(query_embedding, 3); + +// assert!(results[0].score > 0.5); +// assert!(results[0] +// .node +// .get_text_content() +// .unwrap() +// .contains("open and finalized decisions")); +// } + +// #[tokio::test] +// async fn local_json_parsing_test() { +// let generator = RemoteEmbeddingGenerator::new_default(); +// let source_file_name = "echo_definition.json"; +// let buffer = std::fs::read(format!("../../files/{}", source_file_name)).unwrap(); +// let resource = ShinkaiFileParser::process_file_into_resource( +// buffer, +// &generator, +// source_file_name.to_string(), +// None, +// &vec![], +// generator.model_type().max_input_token_count() as u64, +// DistributionInfo::new_empty(), +// ) +// .await +// .unwrap(); + +// resource +// .as_trait_object() +// .print_all_nodes_exhaustive(None, false, false); + +// // Perform vector search +// let query_string = "Shinkai echo description".to_string(); +// let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); +// let results = resource.as_trait_object().vector_search(query_embedding, 3); + +// assert!(results.iter().all(|node| node.score > 0.6)); +// assert!(results.iter().any(|node| node +// .node +// .get_text_content() +// .unwrap() +// .contains("Echoes the input message"))); +// } + +// #[tokio::test] +// async fn local_xlsx_parsing_test() { +// let generator = RemoteEmbeddingGenerator::new_default(); +// let source_file_name = "cars.xlsx"; +// let buffer = std::fs::read(format!("../../files/{}", source_file_name)).unwrap(); +// let resource = ShinkaiFileParser::process_file_into_resource( +// buffer, +// &generator, +// source_file_name.to_string(), +// None, +// &vec![], +// generator.model_type().max_input_token_count() as u64, +// DistributionInfo::new_empty(), +// ) +// .await +// .unwrap(); + +// // Perform vector search +// let query_string = "Which car has 495 horsepower?".to_string(); +// let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); +// let results = resource.as_trait_object().vector_search(query_embedding, 3); + +// assert!(results[0].score > 0.5); +// assert!(results[0].node.get_text_content().unwrap().contains("Corvette")); +// } diff --git a/shinkai-libs/shinkai-http-api/src/api_v1/api_v1_handlers.rs b/shinkai-libs/shinkai-http-api/src/api_v1/api_v1_handlers.rs index 866b32929..0db22282b 100644 --- a/shinkai-libs/shinkai-http-api/src/api_v1/api_v1_handlers.rs +++ b/shinkai-libs/shinkai-http-api/src/api_v1/api_v1_handlers.rs @@ -838,65 +838,6 @@ pub async fn get_last_messages_from_inbox_with_branches_handler( .await } -pub async fn handle_file_upload( - node_commands_sender: Sender, - public_key: String, - encrypted_nonce: String, - form: warp::multipart::FormData, -) -> Result, warp::Rejection> { - let mut stream = Box::pin(form.filter_map(|part_result| async move { - if let Ok(part) = part_result { - shinkai_log( - ShinkaiLogOption::Identity, - ShinkaiLogLevel::Debug, - format!("Received file: {:?}", part).as_str(), - ); - if let Some(filename) = part.filename() { - let filename = filename.to_string(); - let stream = part - .stream() - .map(|res| res.map(|mut buf| buf.copy_to_bytes(buf.remaining()).to_vec())); - return Some((filename, stream)); - } - } - None - })); - - if let Some((filename, mut file_stream)) = stream.next().await { - let mut file_data = Vec::new(); - while let Some(Ok(node)) = file_stream.next().await { - file_data.extend(node); - } - - let (res_sender, res_receiver) = async_channel::bounded(1); - node_commands_sender - .clone() - .send(NodeCommand::APIAddFileToInboxWithSymmetricKey { - filename, - file: file_data, - public_key, - encrypted_nonce, - res: res_sender, - }) - .map_err(|_| warp::reject::reject()) - .await?; - let result = res_receiver.recv().await.map_err(|_| warp::reject::reject())?; - - match result { - Ok(message) => Ok(Box::new(warp::reply::with_status( - warp::reply::json(&message), - StatusCode::OK, - ))), - Err(error) => Ok(Box::new(warp::reply::with_status( - warp::reply::json(&error), - StatusCode::from_u16(error.code).unwrap(), - ))), - } - } else { - Err(warp::reject::reject()) - } -} - pub async fn get_public_key_handler( node_commands_sender: Sender, ) -> Result { @@ -1093,19 +1034,6 @@ pub async fn job_message_handler( } } -pub async fn get_filenames_message_handler( - node_commands_sender: Sender, - message: ShinkaiMessage, -) -> Result { - handle_node_command(node_commands_sender, message, |_, message, res_sender| { - NodeCommand::APIGetFilenamesInInbox { - msg: message, - res: res_sender, - } - }) - .await -} - pub async fn mark_as_read_up_to_handler( node_commands_sender: Sender, message: ShinkaiMessage, @@ -1119,19 +1047,6 @@ pub async fn mark_as_read_up_to_handler( .await } -pub async fn create_files_inbox_with_symmetric_key_handler( - node_commands_sender: Sender, - message: ShinkaiMessage, -) -> Result { - handle_node_command(node_commands_sender, message, |_, message, res_sender| { - NodeCommand::APICreateFilesInboxWithSymmetricKey { - msg: message, - res: res_sender, - } - }) - .await -} - pub async fn create_registration_code_handler( node_commands_sender: Sender, message: ShinkaiMessage, diff --git a/shinkai-libs/shinkai-http-api/src/api_v1/api_v1_router.rs b/shinkai-libs/shinkai-http-api/src/api_v1/api_v1_router.rs index fb0736b99..178492925 100644 --- a/shinkai-libs/shinkai-http-api/src/api_v1/api_v1_router.rs +++ b/shinkai-libs/shinkai-http-api/src/api_v1/api_v1_router.rs @@ -34,7 +34,6 @@ use super::api_v1_handlers::api_vec_fs_search_item_handler; use super::api_v1_handlers::available_llm_providers_handler; use super::api_v1_handlers::change_job_agent_handler; use super::api_v1_handlers::change_nodes_name_handler; -use super::api_v1_handlers::create_files_inbox_with_symmetric_key_handler; use super::api_v1_handlers::create_job_handler; use super::api_v1_handlers::create_registration_code_handler; use super::api_v1_handlers::create_sheet_handler; @@ -43,7 +42,6 @@ use super::api_v1_handlers::export_sheet_handler; use super::api_v1_handlers::get_all_inboxes_for_profile_handler; use super::api_v1_handlers::get_all_smart_inboxes_for_profile_handler; use super::api_v1_handlers::get_all_subidentities_handler; -use super::api_v1_handlers::get_filenames_message_handler; use super::api_v1_handlers::get_last_messages_from_inbox_handler; use super::api_v1_handlers::get_last_messages_from_inbox_with_branches_handler; use super::api_v1_handlers::get_last_notifications_handler; @@ -55,7 +53,6 @@ use super::api_v1_handlers::get_sheet_handler; use super::api_v1_handlers::get_shinkai_tool_handler; use super::api_v1_handlers::get_subscription_links_handler; use super::api_v1_handlers::get_workflow_info_handler; -use super::api_v1_handlers::handle_file_upload; use super::api_v1_handlers::identity_name_to_external_profile_data_handler; use super::api_v1_handlers::import_sheet_handler; use super::api_v1_handlers::job_message_handler; @@ -370,16 +367,6 @@ pub fn v1_routes( .and_then(move |message: ShinkaiMessage| job_message_handler(node_commands_sender.clone(), message)) }; - let get_filenames = { - let node_commands_sender = node_commands_sender.clone(); - warp::path!("get_filenames_for_file_inbox") - .and(warp::post()) - .and(warp::body::json::()) - .and_then(move |message: ShinkaiMessage| { - get_filenames_message_handler(node_commands_sender.clone(), message) - }) - }; - let mark_as_read_up_to = { let node_commands_sender = node_commands_sender.clone(); warp::path!("mark_as_read_up_to") @@ -433,29 +420,6 @@ pub fn v1_routes( }) }; - let create_files_inbox_with_symmetric_key = { - let node_commands_sender = node_commands_sender.clone(); - warp::path!("create_files_inbox_with_symmetric_key") - .and(warp::post()) - .and(warp::body::json::()) - .and_then(move |message: ShinkaiMessage| { - create_files_inbox_with_symmetric_key_handler(node_commands_sender.clone(), message) - }) - }; - - let add_file_to_inbox_with_symmetric_key = { - let node_commands_sender = node_commands_sender.clone(); - warp::path!("add_file_to_inbox_with_symmetric_key" / String / String) - .and(warp::post()) - .and(warp::body::content_length_limit(1024 * 1024 * 200)) // 200MB - .and(warp::multipart::form().max_length(1024 * 1024 * 200)) - .and_then( - move |string1: String, string2: String, form: warp::multipart::FormData| { - handle_file_upload(node_commands_sender.clone(), string1, string2, form) - }, - ) - }; - let update_job_to_finished = { let node_commands_sender = node_commands_sender.clone(); warp::path!("update_job_to_finished") @@ -844,15 +808,12 @@ pub fn v1_routes( .or(update_smart_inbox_name) .or(create_job) .or(job_message) - .or(get_filenames) .or(mark_as_read_up_to) .or(create_registration_code) .or(use_registration_code) .or(change_nodes_name) .or(get_all_subidentities) .or(get_last_messages_from_inbox_with_branches) - .or(create_files_inbox_with_symmetric_key) - .or(add_file_to_inbox_with_symmetric_key) .or(update_job_to_finished) .or(api_available_shared_items) .or(api_available_shared_items_open) diff --git a/shinkai-libs/shinkai-http-api/src/api_v2/api_v2_handlers_general.rs b/shinkai-libs/shinkai-http-api/src/api_v2/api_v2_handlers_general.rs index d15655225..fa1a0ced9 100644 --- a/shinkai-libs/shinkai-http-api/src/api_v2/api_v2_handlers_general.rs +++ b/shinkai-libs/shinkai-http-api/src/api_v2/api_v2_handlers_general.rs @@ -122,21 +122,6 @@ pub fn general_routes( .and(warp::body::json()) .and_then(add_ollama_models_handler); - let download_file_from_inbox_route = warp::path("download_file_from_inbox") - .and(warp::get()) - .and(with_sender(node_commands_sender.clone())) - .and(warp::header::("authorization")) - .and(warp::path::param::()) - .and(warp::path::param::()) - .and_then(download_file_from_inbox_handler); - - let list_files_in_inbox_route = warp::path("list_files_in_inbox") - .and(warp::get()) - .and(with_sender(node_commands_sender.clone())) - .and(warp::header::("authorization")) - .and(warp::path::param::()) - .and_then(list_files_in_inbox_handler); - let stop_llm_route = warp::path("stop_llm") .and(warp::post()) .and(with_sender(node_commands_sender.clone())) @@ -213,8 +198,8 @@ pub fn general_routes( .or(is_pristine_route) .or(scan_ollama_models_route) .or(add_ollama_models_route) - .or(download_file_from_inbox_route) - .or(list_files_in_inbox_route) + // .or(download_file_from_inbox_route) + // .or(list_files_in_inbox_route) .or(stop_llm_route) .or(add_agent_route) .or(remove_agent_route) @@ -232,76 +217,6 @@ pub struct InitialRegistrationRequest { pub profile_identity_pk: String, } -#[utoipa::path( - get, - path = "/v2/download_file_from_inbox/{inbox_name}/{filename}", - responses( - (status = 200, description = "Successfully downloaded file", body = Vec), - (status = 500, description = "Internal server error", body = APIError) - ) -)] -pub async fn download_file_from_inbox_handler( - sender: Sender, - authorization: String, - inbox_name: String, - filename: String, -) -> Result { - let bearer = authorization.strip_prefix("Bearer ").unwrap_or("").to_string(); - let (res_sender, res_receiver) = async_channel::bounded(1); - sender - .send(NodeCommand::V2ApiDownloadFileFromInbox { - bearer, - inbox_name, - filename, - res: res_sender, - }) - .await - .map_err(|_| warp::reject::reject())?; - - let result = res_receiver.recv().await.map_err(|_| warp::reject::reject())?; - - match result { - Ok(file_data) => Ok(warp::reply::with_header( - file_data, - "Content-Type", - "application/octet-stream", - )), - Err(error) => Err(warp::reject::custom(error)), - } -} - -#[utoipa::path( - get, - path = "/v2/list_files_in_inbox/{inbox_name}", - responses( - (status = 200, description = "Successfully listed files in inbox", body = Vec), - (status = 500, description = "Internal server error", body = APIError) - ) -)] -pub async fn list_files_in_inbox_handler( - sender: Sender, - authorization: String, - inbox_name: String, -) -> Result { - let bearer = authorization.strip_prefix("Bearer ").unwrap_or("").to_string(); - let (res_sender, res_receiver) = async_channel::bounded(1); - sender - .send(NodeCommand::V2ApiListFilesInInbox { - bearer, - inbox_name, - res: res_sender, - }) - .await - .map_err(|_| warp::reject::reject())?; - - let result = res_receiver.recv().await.map_err(|_| warp::reject::reject())?; - - match result { - Ok(file_list) => Ok(warp::reply::json(&file_list)), - Err(error) => Err(warp::reject::custom(error)), - } -} - #[utoipa::path( get, path = "/v2/public_keys", @@ -1084,8 +999,8 @@ pub async fn test_llm_provider_handler( #[derive(OpenApi)] #[openapi( paths( - download_file_from_inbox_handler, - list_files_in_inbox_handler, + // download_file_from_inbox_handler, + // list_files_in_inbox_handler, get_public_keys, health_check, initial_registration_handler, diff --git a/shinkai-libs/shinkai-http-api/src/api_v2/api_v2_handlers_jobs.rs b/shinkai-libs/shinkai-http-api/src/api_v2/api_v2_handlers_jobs.rs index 027bc3312..b5afa366f 100644 --- a/shinkai-libs/shinkai-http-api/src/api_v2/api_v2_handlers_jobs.rs +++ b/shinkai-libs/shinkai-http-api/src/api_v2/api_v2_handlers_jobs.rs @@ -20,9 +20,7 @@ use shinkai_message_primitives::{ JobMessage, SheetJobAction, SheetManagerAction, V2ChatMessage, }, }, - shinkai_utils::job_scope::{ - JobScope, LocalScopeVRKaiEntry, LocalScopeVRPackEntry, VectorFSFolderScopeEntry, VectorFSItemScopeEntry, - }, + shinkai_utils::job_scope::MinimalJobScope, }; use utoipa::{OpenApi, ToSchema}; use warp::multipart::FormData; @@ -223,8 +221,15 @@ pub struct UpdateSmartInboxNameRequest { } #[derive(Deserialize, ToSchema)] -pub struct AddFileToInboxRequest { - pub file_inbox_name: String, +pub struct AddFileToFolder { + pub path: String, + pub filename: String, + pub file: Vec, +} + +#[derive(Deserialize, ToSchema)] +pub struct AddFileToJob { + pub job_id: String, pub filename: String, pub file: Vec, } @@ -894,7 +899,7 @@ pub async fn get_job_config_handler( #[derive(Deserialize, ToSchema)] pub struct UpdateJobScopeRequest { pub job_id: String, - pub job_scope: JobScope, + pub job_scope: MinimalJobScope, } #[utoipa::path( @@ -1213,11 +1218,10 @@ pub async fn add_messages_god_mode_handler( remove_job_handler, ), components( - schemas(AddFileToInboxRequest, V2SmartInbox, APIChangeJobAgentRequest, CreateJobRequest, JobConfig, + schemas(AddFileToFolder, V2SmartInbox, APIChangeJobAgentRequest, CreateJobRequest, JobConfig, JobMessageRequest, GetLastMessagesRequest, V2ChatMessage, GetLastMessagesWithBranchesRequest, UpdateJobConfigRequest, UpdateSmartInboxNameRequest, SerializedLLMProvider, JobCreationInfo, - JobMessage, NodeApiData, LLMProviderSubset, AssociatedUI, JobScope, LocalScopeVRKaiEntry, LocalScopeVRPackEntry, - VectorFSItemScopeEntry, VectorFSFolderScopeEntry, CallbackAction, ShinkaiName, + JobMessage, NodeApiData, LLMProviderSubset, AssociatedUI, MinimalJobScope, CallbackAction, ShinkaiName, LLMProviderInterface, RetryMessageRequest, UpdateJobScopeRequest, ExportInboxMessagesFormat, ExportInboxMessagesRequest, ShinkaiSubidentityType, OpenAI, Ollama, LocalLLM, Groq, Gemini, Exo, ShinkaiBackend, SheetManagerAction, SheetJobAction, SendResponseBody, SendResponseBodyData, APIError, GetToolingLogsRequest, ForkJobMessagesRequest, RemoveJobRequest) diff --git a/shinkai-libs/shinkai-http-api/src/api_v2/api_v2_handlers_vecfs.rs b/shinkai-libs/shinkai-http-api/src/api_v2/api_v2_handlers_vecfs.rs index cb1db219f..9d462909b 100644 --- a/shinkai-libs/shinkai-http-api/src/api_v2/api_v2_handlers_vecfs.rs +++ b/shinkai-libs/shinkai-http-api/src/api_v2/api_v2_handlers_vecfs.rs @@ -2,18 +2,20 @@ use async_channel::Sender; use chrono::{DateTime, Utc}; use reqwest::StatusCode; use shinkai_message_primitives::shinkai_message::shinkai_message_schemas::{ - APIConvertFilesAndSaveToFolder, APIVecFsCopyFolder, APIVecFsCopyItem, APIVecFsCreateFolder, APIVecFsDeleteFolder, + APIVecFsCopyFolder, APIVecFsCopyItem, APIVecFsCreateFolder, APIVecFsDeleteFolder, APIVecFsDeleteItem, APIVecFsMoveFolder, APIVecFsMoveItem, APIVecFsRetrievePathSimplifiedJson, APIVecFsRetrieveSourceFile, APIVecFsSearchItems, }; +use crate::api_v2::api_v2_handlers_jobs::AddFileToJob; use crate::node_commands::NodeCommand; -use crate::{api_v2::api_v2_handlers_jobs::AddFileToInboxRequest, node_api_router::APIError}; +use crate::{api_v2::api_v2_handlers_jobs::AddFileToFolder, node_api_router::APIError}; use bytes::Buf; use futures::StreamExt; use utoipa::OpenApi; use warp::multipart::FormData; use warp::Filter; +use std::collections::HashMap; use super::api_v2_router::{create_success_response, with_sender}; @@ -35,13 +37,6 @@ pub fn vecfs_routes( .and(warp::query::()) .and_then(retrieve_vector_resource_handler); - let convert_files_and_save_route = warp::path("convert_files_and_save") - .and(warp::post()) - .and(with_sender(node_commands_sender.clone())) - .and(warp::header::("authorization")) - .and(warp::body::json()) - .and_then(convert_files_and_save_handler); - let create_folder_route = warp::path("create_folder") .and(warp::post()) .and(with_sender(node_commands_sender.clone())) @@ -105,13 +100,34 @@ pub fn vecfs_routes( .and(warp::multipart::form()) .and_then(upload_file_to_folder_handler); - let retrieve_source_file_route = warp::path("retrieve_source_file") + let retrieve_source_file_route = warp::path("download_file") .and(warp::get()) .and(with_sender(node_commands_sender.clone())) .and(warp::header::("authorization")) .and(warp::query::()) .and_then(retrieve_source_file_handler); + let retrieve_files_for_job_route = warp::path("retrieve_files_for_job") + .and(warp::get()) + .and(with_sender(node_commands_sender.clone())) + .and(warp::header::("authorization")) + .and(warp::query::>()) + .and_then(retrieve_files_for_job_handler); + + let get_folder_name_for_job_route = warp::path("get_folder_name_for_job") + .and(warp::get()) + .and(with_sender(node_commands_sender.clone())) + .and(warp::header::("authorization")) + .and(warp::query::>()) + .and_then(get_folder_name_for_job_handler); + + let upload_file_to_job_route = warp::path("upload_file_to_job") + .and(warp::post()) + .and(with_sender(node_commands_sender.clone())) + .and(warp::header::("authorization")) + .and(warp::multipart::form()) + .and_then(upload_file_to_job_handler); + move_item_route .or(copy_item_route) .or(move_folder_route) @@ -121,10 +137,12 @@ pub fn vecfs_routes( .or(search_items_route) .or(retrieve_path_simplified_route) .or(retrieve_vector_resource_route) - .or(convert_files_and_save_route) .or(create_folder_route) .or(upload_file_to_folder_route) .or(retrieve_source_file_route) + .or(retrieve_files_for_job_route) + .or(get_folder_name_for_job_route) + .or(upload_file_to_job_route) } #[utoipa::path( @@ -205,45 +223,6 @@ pub async fn retrieve_vector_resource_handler( } } -#[utoipa::path( - post, - path = "/v2/convert_files_and_save", - request_body = APIConvertFilesAndSaveToFolder, - responses( - (status = 200, description = "Successfully converted files and saved to folder", body = Vec), - (status = 400, description = "Bad request", body = APIError), - (status = 500, description = "Internal server error", body = APIError) - ) -)] -pub async fn convert_files_and_save_handler( - node_commands_sender: Sender, - authorization: String, - payload: APIConvertFilesAndSaveToFolder, -) -> Result { - let bearer = authorization.strip_prefix("Bearer ").unwrap_or("").to_string(); - let (res_sender, res_receiver) = async_channel::bounded(1); - node_commands_sender - .send(NodeCommand::V2ApiConvertFilesAndSaveToFolder { - bearer, - payload, - res: res_sender, - }) - .await - .map_err(|_| warp::reject::reject())?; - let result = res_receiver.recv().await.map_err(|_| warp::reject::reject())?; - - match result { - Ok(response) => { - let response = create_success_response(response); - Ok(warp::reply::with_status(warp::reply::json(&response), StatusCode::OK)) - } - Err(error) => Ok(warp::reply::with_status( - warp::reply::json(&error), - StatusCode::from_u16(error.code).unwrap(), - )), - } -} - #[utoipa::path( post, path = "/v2/create_folder", @@ -621,39 +600,34 @@ pub async fn upload_file_to_folder_handler( })?; } "file_datetime" => { - let content = part.data().await.ok_or_else(|| { - warp::reject::custom(APIError::new( - StatusCode::BAD_REQUEST, - "Bad Request", - "Missing file_datetime", - )) - })?; - let mut content = content.map_err(|e| { - warp::reject::custom(APIError::new( - StatusCode::BAD_REQUEST, - "Bad Request", - format!("Failed to read file_datetime: {:?}", e).as_str(), - )) - })?; - let datetime_str = - String::from_utf8(content.copy_to_bytes(content.remaining()).to_vec()).map_err(|_| { + if let Some(content) = part.data().await { + let mut content = content.map_err(|e| { warp::reject::custom(APIError::new( StatusCode::BAD_REQUEST, "Bad Request", - "Invalid UTF-8 in file_datetime", + format!("Failed to read file_datetime: {:?}", e).as_str(), )) })?; - file_datetime = Some( - DateTime::parse_from_rfc3339(&datetime_str) - .map_err(|_| { + let datetime_str = + String::from_utf8(content.copy_to_bytes(content.remaining()).to_vec()).map_err(|_| { warp::reject::custom(APIError::new( StatusCode::BAD_REQUEST, "Bad Request", - "Invalid datetime format", + "Invalid UTF-8 in file_datetime", )) - })? - .with_timezone(&Utc), - ); + })?; + file_datetime = Some( + DateTime::parse_from_rfc3339(&datetime_str) + .map_err(|_| { + warp::reject::custom(APIError::new( + StatusCode::BAD_REQUEST, + "Bad Request", + "Invalid datetime format", + )) + })? + .with_timezone(&Utc), + ); + } } _ => {} } @@ -707,7 +681,7 @@ pub async fn upload_file_to_folder_handler( #[utoipa::path( post, - path = "/v2/retrieve_source_file", + path = "/v2/download_file", request_body = APIVecFsSearchItems, responses( (status = 200, description = "Successfully searched items", body = String), @@ -723,7 +697,7 @@ pub async fn retrieve_source_file_handler( let bearer = authorization.strip_prefix("Bearer ").unwrap_or("").to_string(); let (res_sender, res_receiver) = async_channel::bounded(1); node_commands_sender - .send(NodeCommand::V2ApiRetrieveSourceFile { + .send(NodeCommand::V2ApiRetrieveFile { bearer, payload, res: res_sender, @@ -741,12 +715,275 @@ pub async fn retrieve_source_file_handler( } } +#[utoipa::path( + get, + path = "/v2/retrieve_files_for_job", + responses( + (status = 200, description = "Successfully retrieved files for job", body = Value), + (status = 400, description = "Bad request", body = APIError), + (status = 500, description = "Internal server error", body = APIError) + ) +)] +pub async fn retrieve_files_for_job_handler( + node_commands_sender: Sender, + authorization: String, + query_params: HashMap, +) -> Result { + if let Some(job_id) = query_params.get("job_id") { + let bearer = authorization.strip_prefix("Bearer ").unwrap_or("").to_string(); + let (res_sender, res_receiver) = async_channel::bounded(1); + node_commands_sender + .send(NodeCommand::V2ApiVecFSRetrieveFilesForJob { + bearer, + job_id: job_id.clone(), + res: res_sender, + }) + .await + .map_err(|_| warp::reject::reject())?; + let result = res_receiver.recv().await.map_err(|_| warp::reject::reject())?; + + match result { + Ok(response) => { + let response = create_success_response(response); + Ok(warp::reply::with_status(warp::reply::json(&response), StatusCode::OK)) + } + Err(error) => Ok(warp::reply::with_status( + warp::reply::json(&error), + StatusCode::from_u16(error.code).unwrap(), + )), + } + } else { + Err(warp::reject::custom(APIError::new( + StatusCode::BAD_REQUEST, + "Bad Request", + "Missing job_id parameter", + ))) + } +} + +#[utoipa::path( + get, + path = "/v2/get_folder_name_for_job", + responses( + (status = 200, description = "Successfully retrieved folder name for job", body = String), + (status = 400, description = "Bad request", body = APIError), + (status = 500, description = "Internal server error", body = APIError) + ) +)] +pub async fn get_folder_name_for_job_handler( + node_commands_sender: Sender, + authorization: String, + query_params: HashMap, +) -> Result { + if let Some(job_id) = query_params.get("job_id") { + let bearer = authorization.strip_prefix("Bearer ").unwrap_or("").to_string(); + let (res_sender, res_receiver) = async_channel::bounded(1); + node_commands_sender + .send(NodeCommand::V2ApiVecFSGetFolderNameForJob { + bearer, + job_id: job_id.clone(), + res: res_sender, + }) + .await + .map_err(|_| warp::reject::reject())?; + let result = res_receiver.recv().await.map_err(|_| warp::reject::reject())?; + + match result { + Ok(response) => { + let response = create_success_response(response); + Ok(warp::reply::with_status(warp::reply::json(&response), StatusCode::OK)) + } + Err(error) => Ok(warp::reply::with_status( + warp::reply::json(&error), + StatusCode::from_u16(error.code).unwrap(), + )), + } + } else { + Err(warp::reject::custom(APIError::new( + StatusCode::BAD_REQUEST, + "Bad Request", + "Missing job_id parameter", + ))) + } +} + +#[utoipa::path( + post, + path = "/v2/upload_file_to_job", + request_body = AddFileToJob, + responses( + (status = 200, description = "Successfully uploaded file to job", body = String), + (status = 400, description = "Bad request", body = APIError), + (status = 500, description = "Internal server error", body = APIError) + ) +)] +pub async fn upload_file_to_job_handler( + node_commands_sender: Sender, + authorization: String, + mut form: FormData, +) -> Result { + let bearer = authorization.strip_prefix("Bearer ").unwrap_or("").to_string(); + let mut job_id = String::new(); + let mut filename = String::new(); + let mut file_data = Vec::new(); + let mut file_datetime: Option> = None; + + while let Some(part) = form.next().await { + let mut part = part.map_err(|e| { + eprintln!("Error collecting form data: {:?}", e); + warp::reject::custom(APIError::new( + StatusCode::BAD_REQUEST, + "Bad Request", + format!("Failed to collect form data: {:?}", e).as_str(), + )) + })?; + match part.name() { + "job_id" => { + let content = part.data().await.ok_or_else(|| { + warp::reject::custom(APIError::new( + StatusCode::BAD_REQUEST, + "Bad Request", + "Missing job_id", + )) + })?; + let mut content = content.map_err(|_| { + warp::reject::custom(APIError::new( + StatusCode::BAD_REQUEST, + "Bad Request", + "Failed to read job_id", + )) + })?; + job_id = String::from_utf8(content.copy_to_bytes(content.remaining()).to_vec()).map_err(|_| { + warp::reject::custom(APIError::new( + StatusCode::BAD_REQUEST, + "Bad Request", + "Invalid UTF-8 in job_id", + )) + })?; + } + "filename" => { + let content = part.data().await.ok_or_else(|| { + warp::reject::custom(APIError::new( + StatusCode::BAD_REQUEST, + "Bad Request", + "Missing filename", + )) + })?; + let mut content = content.map_err(|_| { + warp::reject::custom(APIError::new( + StatusCode::BAD_REQUEST, + "Bad Request", + "Failed to read filename", + )) + })?; + filename = String::from_utf8(content.copy_to_bytes(content.remaining()).to_vec()).map_err(|_| { + warp::reject::custom(APIError::new( + StatusCode::BAD_REQUEST, + "Bad Request", + "Invalid UTF-8 in filename", + )) + })?; + } + "file_data" => { + while let Some(content) = part.data().await { + let mut content = content.map_err(|_| { + warp::reject::custom(APIError::new( + StatusCode::BAD_REQUEST, + "Bad Request", + "Failed to read file data", + )) + })?; + file_data.extend_from_slice(&content.copy_to_bytes(content.remaining())); + } + } + "file_datetime" => { + if let Some(content) = part.data().await { + let mut content = content.map_err(|e| { + warp::reject::custom(APIError::new( + StatusCode::BAD_REQUEST, + "Bad Request", + format!("Failed to read file_datetime: {:?}", e).as_str(), + )) + })?; + let datetime_str = + String::from_utf8(content.copy_to_bytes(content.remaining()).to_vec()).map_err(|_| { + warp::reject::custom(APIError::new( + StatusCode::BAD_REQUEST, + "Bad Request", + "Invalid UTF-8 in file_datetime", + )) + })?; + file_datetime = Some( + DateTime::parse_from_rfc3339(&datetime_str) + .map_err(|_| { + warp::reject::custom(APIError::new( + StatusCode::BAD_REQUEST, + "Bad Request", + "Invalid datetime format", + )) + })? + .with_timezone(&Utc), + ); + } + } + _ => {} + } + } + + if file_data.is_empty() { + return Err(warp::reject::custom(APIError::new( + StatusCode::BAD_REQUEST, + "Bad Request", + "No file data found. Check that the file is being uploaded correctly in the `file_data` field", + ))); + } + + // Generate current UTC time if file_datetime is not provided + let file_datetime = file_datetime.unwrap_or_else(Utc::now); + + let (res_sender, res_receiver) = async_channel::bounded(1); + node_commands_sender + .send(NodeCommand::V2ApiUploadFileToJob { + bearer, + job_id, + filename, + file: file_data, + file_datetime: Some(file_datetime), + res: res_sender, + }) + .await + .map_err(|_| { + warp::reject::custom(APIError::new( + StatusCode::INTERNAL_SERVER_ERROR, + "Internal Server Error", + "Failed to send command", + )) + })?; + let result = res_receiver.recv().await.map_err(|_| { + warp::reject::custom(APIError::new( + StatusCode::INTERNAL_SERVER_ERROR, + "Internal Server Error", + "Failed to receive response", + )) + })?; + + match result { + Ok(response) => { + let response = create_success_response(response); + Ok(warp::reply::with_status(warp::reply::json(&response), StatusCode::OK)) + } + Err(error) => Ok(warp::reply::with_status( + warp::reply::json(&error), + StatusCode::from_u16(error.code).unwrap(), + )), + } +} + #[derive(OpenApi)] #[openapi( paths( retrieve_path_simplified_handler, retrieve_vector_resource_handler, - convert_files_and_save_handler, create_folder_handler, move_item_handler, copy_item_handler, @@ -757,10 +994,13 @@ pub async fn retrieve_source_file_handler( search_items_handler, upload_file_to_folder_handler, retrieve_source_file_handler, + retrieve_files_for_job_handler, + get_folder_name_for_job_handler, + upload_file_to_job_handler, ), components( - schemas(APIError, APIConvertFilesAndSaveToFolder, APIVecFsCopyFolder, APIVecFsCopyItem, APIVecFsCreateFolder, APIVecFsDeleteFolder, APIVecFsDeleteItem, - APIVecFsMoveFolder, APIVecFsMoveItem, APIVecFsRetrievePathSimplifiedJson, APIVecFsSearchItems, AddFileToInboxRequest) + schemas(APIError, APIVecFsCopyFolder, APIVecFsCopyItem, APIVecFsCreateFolder, APIVecFsDeleteFolder, APIVecFsDeleteItem, + APIVecFsMoveFolder, APIVecFsMoveItem, APIVecFsRetrievePathSimplifiedJson, APIVecFsSearchItems, AddFileToFolder, AddFileToJob) ), tags( (name = "vecfs", description = "VecFS API endpoints") diff --git a/shinkai-libs/shinkai-http-api/src/node_commands.rs b/shinkai-libs/shinkai-http-api/src/node_commands.rs index 2bff066e4..8caf1469f 100644 --- a/shinkai-libs/shinkai-http-api/src/node_commands.rs +++ b/shinkai-libs/shinkai-http-api/src/node_commands.rs @@ -24,17 +24,15 @@ use shinkai_message_primitives::{ shinkai_message::{ shinkai_message::ShinkaiMessage, shinkai_message_schemas::{ - APIAddOllamaModels, APIAvailableSharedItems, APIChangeJobAgentRequest, APIConvertFilesAndSaveToFolder, - APICreateShareableFolder, APIExportSheetPayload, APIGetLastNotifications, APIGetMySubscribers, - APIGetNotificationsBeforeTimestamp, APIImportSheetPayload, APISetSheetUploadedFilesPayload, - APISubscribeToSharedFolder, APIUnshareFolder, APIUnsubscribeToSharedFolder, APIUpdateShareableFolder, - APIVecFsCopyFolder, APIVecFsCopyItem, APIVecFsCreateFolder, APIVecFsDeleteFolder, APIVecFsDeleteItem, - APIVecFsMoveFolder, APIVecFsMoveItem, APIVecFsRetrievePathSimplifiedJson, APIVecFsRetrieveSourceFile, - APIVecFsSearchItems, ExportInboxMessagesFormat, IdentityPermissions, JobCreationInfo, JobMessage, - RegistrationCodeType, V2ChatMessage, + APIAddOllamaModels, APIAvailableSharedItems, APIChangeJobAgentRequest, APIExportSheetPayload, + APIImportSheetPayload, APISetSheetUploadedFilesPayload, APIVecFsCopyFolder, APIVecFsCopyItem, + APIVecFsCreateFolder, APIVecFsDeleteFolder, APIVecFsDeleteItem, APIVecFsMoveFolder, APIVecFsMoveItem, + APIVecFsRetrievePathSimplifiedJson, APIVecFsRetrieveSourceFile, APIVecFsSearchItems, + ExportInboxMessagesFormat, IdentityPermissions, JobCreationInfo, JobMessage, RegistrationCodeType, + V2ChatMessage, }, }, - shinkai_utils::job_scope::JobScope, + shinkai_utils::job_scope::MinimalJobScope, }; use shinkai_tools_primitives::tools::{ @@ -207,21 +205,6 @@ pub enum NodeCommand { shinkai_message: ShinkaiMessage, res: Sender<(String, String)>, }, - APICreateFilesInboxWithSymmetricKey { - msg: ShinkaiMessage, - res: Sender>, - }, - APIGetFilenamesInInbox { - msg: ShinkaiMessage, - res: Sender, APIError>>, - }, - APIAddFileToInboxWithSymmetricKey { - filename: String, - file: Vec, - public_key: String, - encrypted_nonce: String, - res: Sender>, - }, APIJobMessage { msg: ShinkaiMessage, res: Sender>, @@ -603,21 +586,15 @@ pub enum NodeCommand { path: String, res: Sender>, }, - V2ApiConvertFilesAndSaveToFolder { - bearer: String, - payload: APIConvertFilesAndSaveToFolder, - res: Sender, APIError>>, - }, - V2ApiDownloadFileFromInbox { + V2ApiVecFSRetrieveFilesForJob { bearer: String, - inbox_name: String, - filename: String, - res: Sender, APIError>>, + job_id: String, + res: Sender>, }, - V2ApiListFilesInInbox { + V2ApiVecFSGetFolderNameForJob { bearer: String, - inbox_name: String, - res: Sender, APIError>>, + job_id: String, + res: Sender>, }, V2ApiVecFSCreateFolder { bearer: String, @@ -657,7 +634,7 @@ pub enum NodeCommand { V2ApiSearchItems { bearer: String, payload: APIVecFsSearchItems, - res: Sender, APIError>>, + res: Sender>, }, V2ApiCreateFilesInbox { bearer: String, // @@ -678,7 +655,15 @@ pub enum NodeCommand { file_datetime: Option>, res: Sender>, }, - V2ApiRetrieveSourceFile { + V2ApiUploadFileToJob { + bearer: String, + job_id: String, + filename: String, + file: Vec, + file_datetime: Option>, + res: Sender>, + }, + V2ApiRetrieveFile { bearer: String, payload: APIVecFsRetrieveSourceFile, res: Sender>, @@ -918,7 +903,7 @@ pub enum NodeCommand { V2ApiUpdateJobScope { bearer: String, job_id: String, - job_scope: JobScope, + job_scope: MinimalJobScope, res: Sender>, }, V2ApiGetJobScope { diff --git a/shinkai-libs/shinkai-job-queue-manager/Cargo.toml b/shinkai-libs/shinkai-job-queue-manager/Cargo.toml index d006e9c61..534fbf6c8 100644 --- a/shinkai-libs/shinkai-job-queue-manager/Cargo.toml +++ b/shinkai-libs/shinkai-job-queue-manager/Cargo.toml @@ -7,6 +7,7 @@ authors = { workspace = true } [dependencies] shinkai_message_primitives = { workspace = true } shinkai_sqlite = { workspace = true } +shinkai_embedding = { workspace = true } tokio = { workspace = true, features = ["full"] } chrono = { workspace = true, features = ["serde"] } serde_json = { workspace = true } @@ -16,5 +17,5 @@ workspace = true features = ["derive"] [dev-dependencies] -shinkai_vector_resources = { workspace = true } +# shinkai_vector_resources = { workspace = true } tempfile = "3.2" \ No newline at end of file diff --git a/shinkai-libs/shinkai-job-queue-manager/src/job_queue_manager.rs b/shinkai-libs/shinkai-job-queue-manager/src/job_queue_manager.rs index d663142df..c650a725d 100644 --- a/shinkai-libs/shinkai-job-queue-manager/src/job_queue_manager.rs +++ b/shinkai-libs/shinkai-job-queue-manager/src/job_queue_manager.rs @@ -10,7 +10,7 @@ use std::cmp::Ordering; use std::collections::HashMap; use std::fmt::Debug; use std::sync::{Arc, Weak}; -use tokio::sync::{mpsc, Mutex, RwLock}; +use tokio::sync::{mpsc, Mutex}; type MutexQueue = Arc>>; type Subscriber = mpsc::Sender; @@ -261,7 +261,7 @@ mod tests { schemas::shinkai_name::ShinkaiName, shinkai_utils::shinkai_logging::{shinkai_log, ShinkaiLogLevel, ShinkaiLogOption}, }; - use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; + use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use std::path::PathBuf; use tempfile::NamedTempFile; @@ -316,7 +316,8 @@ mod tests { JobMessage { job_id: "job_id::123::false".to_string(), content: "my content".to_string(), - files_inbox: "".to_string(), + fs_files_paths: vec![], + job_filenames: vec![], parent: None, sheet_job_data: None, callback: None, @@ -348,7 +349,8 @@ mod tests { JobMessage { job_id: "job_id::123::false".to_string(), content: "my content".to_string(), - files_inbox: "".to_string(), + fs_files_paths: vec![], + job_filenames: vec![], parent: None, sheet_job_data: None, callback: None, @@ -362,7 +364,8 @@ mod tests { JobMessage { job_id: "job_id::123::false".to_string(), content: "my content 2".to_string(), - files_inbox: "".to_string(), + fs_files_paths: vec![], + job_filenames: vec![], parent: None, sheet_job_data: None, callback: None, @@ -461,7 +464,8 @@ mod tests { JobMessage { job_id: "job_id::a1::false".to_string(), content: "content a1".to_string(), - files_inbox: "".to_string(), + fs_files_paths: vec![], + job_filenames: vec![], parent: None, sheet_job_data: None, callback: None, @@ -475,7 +479,8 @@ mod tests { JobMessage { job_id: "job_id::a2::false".to_string(), content: "content a2".to_string(), - files_inbox: "".to_string(), + fs_files_paths: vec![], + job_filenames: vec![], parent: None, sheet_job_data: None, callback: None, @@ -489,7 +494,8 @@ mod tests { JobMessage { job_id: "job_id::a3::false".to_string(), content: "content a3".to_string(), - files_inbox: "".to_string(), + fs_files_paths: vec![], + job_filenames: vec![], parent: None, sheet_job_data: None, callback: None, @@ -504,7 +510,8 @@ mod tests { JobMessage { job_id: "job_id::b1::false".to_string(), content: "content b1".to_string(), - files_inbox: "".to_string(), + fs_files_paths: vec![], + job_filenames: vec![], parent: None, sheet_job_data: None, callback: None, @@ -519,7 +526,8 @@ mod tests { JobMessage { job_id: "job_id::c1::false".to_string(), content: "content c1".to_string(), - files_inbox: "".to_string(), + fs_files_paths: vec![], + job_filenames: vec![], parent: None, sheet_job_data: None, callback: None, @@ -534,7 +542,8 @@ mod tests { JobMessage { job_id: "job_id::c2::false".to_string(), content: "content c2".to_string(), - files_inbox: "".to_string(), + fs_files_paths: vec![], + job_filenames: vec![], parent: None, sheet_job_data: None, callback: None, diff --git a/shinkai-libs/shinkai-message-primitives/Cargo.toml b/shinkai-libs/shinkai-message-primitives/Cargo.toml index 709acb93b..5c06caaa3 100644 --- a/shinkai-libs/shinkai-message-primitives/Cargo.toml +++ b/shinkai-libs/shinkai-message-primitives/Cargo.toml @@ -12,11 +12,10 @@ chacha20poly1305 = "0.7.1" x25519-dalek = { version = "2.0.0", features = ["static_secrets"] } ed25519-dalek = { version = "2.1.0", features = ["rand_core"] } rand = { workspace = true } -chrono = { workspace = true } +chrono = { workspace = true, features = ["serde"] } regex = { workspace = true } thiserror = "1.0.44" hex = { workspace = true } -shinkai_vector_resources = { path = "../shinkai-vector-resources", default-features = false } aes-gcm = "0.10.3" blake3 = { workspace = true } rust_decimal = "1.17.0" @@ -33,6 +32,10 @@ tracing-subscriber = { version = "0.3", optional = true } [lib] crate-type = ["cdylib", "rlib"] +[dev-dependencies] +serial_test = "0.5" +tempfile = "3.10.1" + [target.'cfg(not(target_arch = "wasm32"))'.dependencies] tracing = "0.1.40" tracing-subscriber = { version = "0.3", features = ["env-filter"] } diff --git a/shinkai-libs/shinkai-message-primitives/src/schemas/inbox_name.rs b/shinkai-libs/shinkai-message-primitives/src/schemas/inbox_name.rs index d784b7afc..6db871b33 100644 --- a/shinkai-libs/shinkai-message-primitives/src/schemas/inbox_name.rs +++ b/shinkai-libs/shinkai-message-primitives/src/schemas/inbox_name.rs @@ -3,7 +3,6 @@ use std::fmt; use super::shinkai_name::{ShinkaiName, ShinkaiNameError}; use crate::shinkai_message::shinkai_message::{MessageBody, ShinkaiMessage}; use serde::{Deserialize, Serialize}; -use shinkai_vector_resources::source::ShinkaiNameString; use std::fmt::Debug; #[derive(Debug, PartialEq)] @@ -136,7 +135,7 @@ impl InboxName { pub fn get_regular_inbox_name_from_params( sender: String, - sender_subidentity: ShinkaiNameString, + sender_subidentity: String, recipient: String, recipient_subidentity: String, is_e2e: bool, diff --git a/shinkai-libs/shinkai-message-primitives/src/schemas/job.rs b/shinkai-libs/shinkai-message-primitives/src/schemas/job.rs index fa56e0c0c..5f72aa3ed 100644 --- a/shinkai-libs/shinkai-message-primitives/src/schemas/job.rs +++ b/shinkai-libs/shinkai-message-primitives/src/schemas/job.rs @@ -1,8 +1,10 @@ -use crate::{shinkai_message::shinkai_message_schemas::AssociatedUI, shinkai_utils::job_scope::{JobScope, MinimalJobScope}}; +use crate::{ + shinkai_message::{shinkai_message::ShinkaiMessage, shinkai_message_schemas::AssociatedUI}, + shinkai_utils::job_scope::MinimalJobScope, +}; -use super::{inbox_name::InboxName, job_config::JobConfig, prompts::Prompt}; +use super::{inbox_name::InboxName, job_config::JobConfig}; use serde::{Deserialize, Serialize}; -use std::collections::HashMap; pub trait JobLike: Send + Sync { fn job_id(&self) -> &str; @@ -11,7 +13,7 @@ pub trait JobLike: Send + Sync { fn is_finished(&self) -> bool; fn parent_llm_provider_id(&self) -> &str; fn scope(&self) -> &MinimalJobScope; - fn scope_with_files(&self) -> Option<&JobScope>; + // fn scope_with_files(&self) -> Option<&MinimalJobScope>; fn conversation_inbox_name(&self) -> &InboxName; fn associated_ui(&self) -> Option<&AssociatedUI>; fn config(&self) -> Option<&JobConfig>; @@ -33,18 +35,13 @@ pub struct Job { pub parent_agent_or_llm_provider_id: String, /// (Simplified version) What VectorResources the Job has access to when performing vector searches pub scope: MinimalJobScope, - /// (Full version) What VectorResources the Job has access to when performing vector searches, including files - pub scope_with_files: Option, + // /// (Full version) What VectorResources the Job has access to when performing vector searches, including files + // pub scope_with_files: Option, + /// A list of messages that were generated as output from the latest Job step + pub step_history: Vec, /// An inbox where messages to the agent from the user and messages from the agent are stored, /// enabling each job to have a classical chat/conversation UI pub conversation_inbox_name: InboxName, - /// The job's step history (an ordered list of all prompts/outputs from LLM inferencing when processing steps) - /// Under the hood this is a tree, but it looks like a simple Vec because we only care about the latest valid path - /// based on the last message sent by the user - pub step_history: Vec, - /// A hashmap which holds a bunch of labeled values which were generated as output from the latest Job step - /// Same as step_history. Under the hood this is a tree, but everything is automagically filtered and converted to a hashmap. - pub execution_context: HashMap, /// A link to the UI where the user can view the job e.g. Sheet UI pub associated_ui: Option, /// The job's configuration @@ -84,9 +81,9 @@ impl JobLike for Job { &self.scope } - fn scope_with_files(&self) -> Option<&JobScope> { - self.scope_with_files.as_ref() - } + // fn scope_with_files(&self) -> Option<&MinimalJobScope> { + // self.scope_with_files.as_ref() + // } fn conversation_inbox_name(&self) -> &InboxName { &self.conversation_inbox_name @@ -105,50 +102,50 @@ impl JobLike for Job { } } -/// Result from a Job step, holding user's message and Agent's response. -/// Includes revisions interface in case of edits. -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] -pub struct JobStepResult { - /// Datetime of the first message sent from the user that triggered this Job Step - pub initial_message_datetime: String, - /// List of Prompts that hold User->System sub prompt pairs that denote what the user - /// asked, and what the Agent finally responded with. These are the revisions for this - /// single step, meaning that if this list has more than one prompt, later ones denote - /// edits which were made off of the original message. - pub step_revisions: Vec, -} - -impl Default for JobStepResult { - fn default() -> Self { - Self::new() - } -} - -impl JobStepResult { - /// Create a new JobStepResult - pub fn new() -> Self { - Self { - initial_message_datetime: String::new(), - step_revisions: Vec::new(), - } - } - - /// Adds a new Prompt into step_revisions, thus denoting that - /// this is the latest edit/response. - pub fn add_new_step_revision(&mut self, prompt: Prompt) { - self.step_revisions.push(prompt); - } - - /// Returns the latest revisions of the Job Step Result if one exists - pub fn get_result_prompt(&self) -> Option { - self.step_revisions.last().cloned() - } - - pub fn to_json(&self) -> Result { - serde_json::to_string(self) - } - - pub fn from_json(json: &str) -> Result { - serde_json::from_str(json) - } -} +// /// Result from a Job step, holding user's message and Agent's response. +// /// Includes revisions interface in case of edits. +// #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +// pub struct JobStepResult { +// /// Datetime of the first message sent from the user that triggered this Job Step +// pub initial_message_datetime: String, +// /// List of Prompts that hold User->System sub prompt pairs that denote what the user +// /// asked, and what the Agent finally responded with. These are the revisions for this +// /// single step, meaning that if this list has more than one prompt, later ones denote +// /// edits which were made off of the original message. +// pub step_revisions: Vec, +// } + +// impl Default for JobStepResult { +// fn default() -> Self { +// Self::new() +// } +// } + +// impl JobStepResult { +// /// Create a new JobStepResult +// pub fn new() -> Self { +// Self { +// initial_message_datetime: String::new(), +// step_revisions: Vec::new(), +// } +// } + +// /// Adds a new Prompt into step_revisions, thus denoting that +// /// this is the latest edit/response. +// pub fn add_new_step_revision(&mut self, prompt: Prompt) { +// self.step_revisions.push(prompt); +// } + +// /// Returns the latest revisions of the Job Step Result if one exists +// pub fn get_result_prompt(&self) -> Option { +// self.step_revisions.last().cloned() +// } + +// pub fn to_json(&self) -> Result { +// serde_json::to_string(self) +// } + +// pub fn from_json(json: &str) -> Result { +// serde_json::from_str(json) +// } +// } diff --git a/shinkai-libs/shinkai-message-primitives/src/schemas/job_config.rs b/shinkai-libs/shinkai-message-primitives/src/schemas/job_config.rs index bdecd0ba5..dcb462e2e 100644 --- a/shinkai-libs/shinkai-message-primitives/src/schemas/job_config.rs +++ b/shinkai-libs/shinkai-message-primitives/src/schemas/job_config.rs @@ -54,3 +54,38 @@ impl JobConfig { } } } + +#[cfg(test)] +mod tests { + use super::*; + use serde_json; + + #[test] + fn test_deserialize_job_config() { + let json_data = r#"{ + "custom_system_prompt": null, + "custom_prompt": "", + "temperature": 0.8, + "max_tokens": null, + "seed": null, + "top_k": 40, + "top_p": 0.9, + "stream": true, + "other_model_params": null, + "use_tools": false + }"#; + + let job_config: JobConfig = serde_json::from_str(json_data).expect("Failed to deserialize JSON"); + + assert_eq!(job_config.custom_system_prompt, None); + assert_eq!(job_config.custom_prompt, Some("".to_string())); + assert_eq!(job_config.temperature, Some(0.8)); + assert_eq!(job_config.max_tokens, None); + assert_eq!(job_config.seed, None); + assert_eq!(job_config.top_k, Some(40)); + assert_eq!(job_config.top_p, Some(0.9)); + assert_eq!(job_config.stream, Some(true)); + assert_eq!(job_config.other_model_params, None); + assert_eq!(job_config.use_tools, Some(false)); + } +} diff --git a/shinkai-libs/shinkai-message-primitives/src/schemas/llm_providers/agent.rs b/shinkai-libs/shinkai-message-primitives/src/schemas/llm_providers/agent.rs index ae8c45c4f..87fc84a52 100644 --- a/shinkai-libs/shinkai-message-primitives/src/schemas/llm_providers/agent.rs +++ b/shinkai-libs/shinkai-message-primitives/src/schemas/llm_providers/agent.rs @@ -1,7 +1,7 @@ use serde::{Deserialize, Serialize}; use utoipa::ToSchema; -use crate::schemas::{job_config::JobConfig, shinkai_name::ShinkaiName, tool_router_key::ToolRouterKey}; +use crate::{schemas::{job_config::JobConfig, shinkai_name::ShinkaiName, tool_router_key::ToolRouterKey}, shinkai_utils::job_scope::MinimalJobScope}; #[derive(Debug, Clone, PartialEq, Serialize, Deserialize, ToSchema)] #[serde(rename_all = "snake_case")] @@ -17,6 +17,8 @@ pub struct Agent { pub tools: Vec, pub debug_mode: bool, pub config: Option, + #[serde(default)] + pub scope: MinimalJobScope, } fn deserialize_tools<'de, D>(deserializer: D) -> Result, D::Error> diff --git a/shinkai-libs/shinkai-message-primitives/src/schemas/mod.rs b/shinkai-libs/shinkai-message-primitives/src/schemas/mod.rs index f7e80ef85..54cc0f62d 100644 --- a/shinkai-libs/shinkai-message-primitives/src/schemas/mod.rs +++ b/shinkai-libs/shinkai-message-primitives/src/schemas/mod.rs @@ -16,12 +16,12 @@ pub mod prompts; pub mod registration_code; pub mod retry; pub mod sheet; +pub mod shinkai_fs; pub mod shinkai_name; pub mod shinkai_network; pub mod shinkai_proxy_builder_info; pub mod shinkai_subscription; pub mod shinkai_subscription_req; -pub mod shinkai_time; pub mod shinkai_tool_offering; pub mod shinkai_tools; pub mod smart_inbox; diff --git a/shinkai-libs/shinkai-message-primitives/src/schemas/prompts.rs b/shinkai-libs/shinkai-message-primitives/src/schemas/prompts.rs index 8c9f0bc55..7109bc237 100644 --- a/shinkai-libs/shinkai-message-primitives/src/schemas/prompts.rs +++ b/shinkai-libs/shinkai-message-primitives/src/schemas/prompts.rs @@ -2,11 +2,12 @@ use std::{collections::HashMap, fmt}; use serde::{Deserialize, Serialize}; use serde_json::Value; -use shinkai_vector_resources::vector_resource::RetrievedNode; + +use crate::shinkai_message::shinkai_message::ShinkaiMessage; use super::{ - job::JobStepResult, llm_message::{DetailedFunctionCall, LlmMessage}, + shinkai_fs::ShinkaiFileChunkCollection, subprompts::{SubPrompt, SubPromptAssetContent, SubPromptAssetDetail, SubPromptAssetType, SubPromptType}, }; @@ -111,13 +112,14 @@ impl Prompt { /// Adds RetrievedNode content into the prompt if it is a Text-holding node. Otherwise skips. pub fn add_ret_node_content( &mut self, - retrieved_node: RetrievedNode, + retrieved_node: ShinkaiFileChunkCollection, prompt_type: SubPromptType, priority_value: u8, ) { - if let Some(content) = retrieved_node.format_for_prompt(3500) { + for chunk in retrieved_node.chunks.iter() { + let content = chunk.content.clone(); if !content.trim().is_empty() { - self.add_content(content, prompt_type, priority_value); + self.add_content(content, prompt_type.clone(), priority_value); } } } @@ -249,13 +251,15 @@ impl Prompt { self.add_sub_prompts(updated_sub_prompts); } - /// Adds previous results from step history into the Prompt, up to max_tokens + /// Adds previous results from step history into the Prompt, up to max_tokens. + /// Note: The last message in the history is not added. /// Of note, priority value must be between 0-100. - pub fn add_step_history(&mut self, history: Vec, priority_value: u8) { + pub fn add_step_history(&mut self, history: Vec, priority_value: u8) { let capped_priority_value = std::cmp::min(priority_value, 100) as u8; let sub_prompts_list: Vec = history .iter() - .filter_map(|step| step.get_result_prompt()) + .take(history.len().saturating_sub(1)) // Skip the last message + .filter_map(|step| Some(step.to_prompt())) .flat_map(|prompt| prompt.sub_prompts.clone()) .collect(); self.add_sub_prompts_with_new_priority(sub_prompts_list, capped_priority_value); @@ -418,12 +422,12 @@ impl Prompt { SubPrompt::Omni(prompt_type, _, _, _) => { // Process the current sub-prompt let new_message = sub_prompt.into_chat_completion_request_message(); - + if let SubPromptType::UserLastMessage = prompt_type { last_user_message = Some(new_message); } else { current_length += - sub_prompt.count_tokens_with_pregenerated_completion_message(&new_message, token_counter); + sub_prompt.count_tokens_with_pregenerated_completion_message(&new_message, token_counter); tiktoken_messages.push(new_message); } } diff --git a/shinkai-libs/shinkai-message-primitives/src/schemas/shinkai_fs.rs b/shinkai-libs/shinkai-message-primitives/src/schemas/shinkai_fs.rs new file mode 100644 index 000000000..2264346c8 --- /dev/null +++ b/shinkai-libs/shinkai-message-primitives/src/schemas/shinkai_fs.rs @@ -0,0 +1,73 @@ +use serde::{Deserialize, Serialize}; +use std::collections::HashMap; + +use crate::shinkai_utils::shinkai_path::ShinkaiPath; + +/// Represents a file that has been parsed and indexed (e.g., split into chunks and possibly embedded). +/// This record stores metadata about the parsing process and the file itself, including its relative +/// path, extension, descriptions, and token/character counts. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ParsedFile { + /// Unique identifier for the parsed file entry. + pub id: Option, + /// The file's path relative to some base directory (e.g., "docs/manual.txt"). + pub relative_path: String, + /// The original file extension (e.g., "txt", "md", "pdf"). + pub original_extension: Option, + /// A human-readable description of the file. + pub description: Option, + /// The source of the file content (e.g., a URL or system component). + pub source: Option, + /// The name or type of the embedding model used if embeddings were generated. + pub embedding_model_used: Option, + /// Keywords or tags derived from or associated with the file. + pub keywords: Option, + /// Information about how the file is distributed or shared. + pub distribution_info: Option, + /// The timestamp when the file was parsed or created (in a UNIX timestamp format). + pub created_time: Option, + /// Arbitrary tags associated with the file for categorization or filtering. + pub tags: Option, + /// The total number of tokens in the file (if known). + pub total_tokens: Option, + /// The total number of characters in the file (if known). + pub total_characters: Option, +} + +/// Represents a chunk of a processed file. +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)] +pub struct ShinkaiFileChunk { + /// Unique identifier for the file chunk. + pub chunk_id: Option, + /// Identifier of the parsed file this chunk is associated with. + pub parsed_file_id: i64, + /// Sequence number of the chunk, indicating its order within the file. + pub position: i64, + /// The text content of this particular chunk. + pub content: String, +} + +/// Represents an embedding of a file chunk. +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] +pub struct ShinkaiFileChunkEmbedding { + /// Identifier of the file chunk this embedding is associated with. + pub chunk_id: i64, + /// Embedding vector for the file chunk. + pub embedding: Vec, +} + +/// A struct that holds a collection of `ShinkaiFileChunk`. +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +pub struct ShinkaiFileChunkCollection { + /// A set of chunks related to a parsed file. + pub chunks: Vec, + /// A map of parsed file IDs to their associated paths. + pub paths: Option>, +} + +impl ShinkaiFileChunkCollection { + /// Checks if the collection of chunks is empty. + pub fn is_empty(&self) -> bool { + self.chunks.is_empty() + } +} diff --git a/shinkai-libs/shinkai-message-primitives/src/schemas/shinkai_subscription.rs b/shinkai-libs/shinkai-message-primitives/src/schemas/shinkai_subscription.rs index 223cf5773..652d55182 100644 --- a/shinkai-libs/shinkai-message-primitives/src/schemas/shinkai_subscription.rs +++ b/shinkai-libs/shinkai-message-primitives/src/schemas/shinkai_subscription.rs @@ -4,15 +4,17 @@ use chrono::{DateTime, Utc}; use serde::{Deserialize, Serialize}; use utoipa::ToSchema; +use crate::shinkai_utils::shinkai_path::ShinkaiPath; + use super::{shinkai_name::ShinkaiName, shinkai_subscription_req::SubscriptionPayment}; -use shinkai_vector_resources::vector_resource::VRPath; +// use shinkai_vector_resources::vector_resource::VRPath; // TODO: This should have the fields stored separate, and just have get unique id build the id string. Moves validation to from_unique_id as it should be. #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash, ToSchema)] pub struct SubscriptionId { pub unique_id: String, - pub include_folders: Option>, - pub exclude_folders: Option>, + pub include_folders: Option>, + pub exclude_folders: Option>, } impl SubscriptionId { @@ -140,12 +142,12 @@ impl SubscriptionId { } // Method to update include_folders - pub fn update_include_folders(&mut self, folders: Vec) { + pub fn update_include_folders(&mut self, folders: Vec) { self.include_folders = Some(folders); } // Method to update exclude_folders - pub fn update_exclude_folders(&mut self, folders: Vec) { + pub fn update_exclude_folders(&mut self, folders: Vec) { self.exclude_folders = Some(folders); } } diff --git a/shinkai-libs/shinkai-message-primitives/src/schemas/shinkai_time.rs b/shinkai-libs/shinkai-message-primitives/src/schemas/shinkai_time.rs deleted file mode 100644 index 7093e8dc5..000000000 --- a/shinkai-libs/shinkai-message-primitives/src/schemas/shinkai_time.rs +++ /dev/null @@ -1 +0,0 @@ -pub use shinkai_vector_resources::shinkai_time::*; diff --git a/shinkai-libs/shinkai-message-primitives/src/schemas/subprompts.rs b/shinkai-libs/shinkai-message-primitives/src/schemas/subprompts.rs index 485d94185..953f4a425 100644 --- a/shinkai-libs/shinkai-message-primitives/src/schemas/subprompts.rs +++ b/shinkai-libs/shinkai-message-primitives/src/schemas/subprompts.rs @@ -1,9 +1,8 @@ use serde::{Deserialize, Serialize}; use serde_json::Value as JsonValue; -use shinkai_vector_resources::vector_resource::BaseVectorResource; use std::fmt; -use super::{llm_message::LlmMessage, prompts::Prompt}; +use super::{llm_message::LlmMessage, prompts::Prompt, shinkai_fs::ShinkaiFileChunk}; #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] pub enum SubPromptType { @@ -215,68 +214,110 @@ impl SubPrompt { token_counter(&[completion_message.clone()]) } - /// Converts a vector resource into a series of subprompts to be used in a prompt - /// If the VR is ordered, the output will be as well. - pub fn convert_resource_into_subprompts(resource: &BaseVectorResource, subprompt_priority: u8) -> Vec { - let mut temp_prompt = Prompt::new(); + // /// Converts a vector resource into a series of subprompts to be used in a prompt + // /// If the VR is ordered, the output will be as well. + // pub fn convert_resource_into_subprompts(resource: &BaseVectorResource, subprompt_priority: u8) -> Vec { + // let mut temp_prompt = Prompt::new(); - let nodes = resource.as_trait_object().get_all_nodes_flattened(); + // let nodes = resource.as_trait_object().get_all_nodes_flattened(); - // Iterate through each node and add its text string to the prompt (which is the name of the VR) - for node in nodes { - if let Ok(content) = node.get_text_content() { - temp_prompt.add_content(content.to_string(), SubPromptType::ExtraContext, subprompt_priority); - } - if let Ok(resource) = node.get_vector_resource_content() { - temp_prompt.add_content( - resource.as_trait_object().name().to_string(), - SubPromptType::ExtraContext, - subprompt_priority, - ); - } - } + // // Iterate through each node and add its text string to the prompt (which is the name of the VR) + // for node in nodes { + // if let Ok(content) = node.get_text_content() { + // temp_prompt.add_content(content.to_string(), SubPromptType::ExtraContext, subprompt_priority); + // } + // if let Ok(resource) = node.get_vector_resource_content() { + // temp_prompt.add_content( + // resource.as_trait_object().name().to_string(), + // SubPromptType::ExtraContext, + // subprompt_priority, + // ); + // } + // } - temp_prompt.sub_prompts - } + // temp_prompt.sub_prompts + // } + + // // TODO: if we have content with the same extra_info, don't repeat the extra info! + // pub fn convert_resource_into_subprompts_with_extra_info( + // resource: &BaseVectorResource, + // subprompt_priority: u8, + // ) -> Vec { + // let mut temp_prompt = Prompt::new(); + // let resource_trait = resource.as_trait_object(); + // let nodes = resource_trait.get_all_nodes_flattened(); + // let mut last_content = String::new(); + // let mut last_reference = String::new(); + // let mut buffer_content = String::new(); + + // for (i, node) in nodes.iter().enumerate() { + // let mut current_content = String::new(); + + // if let Ok(content) = node.get_text_content() { + // current_content = content.to_string(); + // } else if let Ok(resource) = node.get_vector_resource_content() { + // current_content = resource.as_trait_object().name().to_string(); + // } + + // // Some text is repeated between nodes, so we skip it + // if current_content.is_empty() || current_content == last_content { + // continue; + // } + + // let mut extra_info = String::new(); + // let file_name = resource_trait.source().format_source_string(); + + // if let Some(metadata) = &node.metadata { + // if let Some(pg_nums) = metadata.get("pg_nums") { + // extra_info = format!("\nRef. page: {} from {}.", pg_nums, file_name); + // } else { + // extra_info = format!("\nRef. from {}.", file_name); + // } + // } else { + // extra_info = format!("\nRef. from {}.", file_name); + // } - // TODO: if we have content with the same extra_info, don't repeat the extra info! - pub fn convert_resource_into_subprompts_with_extra_info( - resource: &BaseVectorResource, + // if extra_info != last_reference { + // if !buffer_content.is_empty() { + // temp_prompt.add_content(buffer_content.clone(), SubPromptType::ExtraContext, subprompt_priority); + // } + // buffer_content.clone_from(¤t_content); + // last_reference.clone_from(&extra_info); + // } else { + // buffer_content.push_str(&format!(" {}", current_content)); + // } + + // if i == nodes.len() - 1 || extra_info != last_reference { + // buffer_content.push_str(&extra_info); + // temp_prompt.add_content(buffer_content.clone(), SubPromptType::ExtraContext, subprompt_priority); + // buffer_content.clear(); + // } + + // last_content = current_content; + // } + + // temp_prompt.remove_all_subprompts() + // } + + pub fn convert_chunks_into_subprompts_with_extra_info( + chunks: &[ShinkaiFileChunk], subprompt_priority: u8, ) -> Vec { let mut temp_prompt = Prompt::new(); - let resource_trait = resource.as_trait_object(); - let nodes = resource_trait.get_all_nodes_flattened(); let mut last_content = String::new(); let mut last_reference = String::new(); let mut buffer_content = String::new(); - for (i, node) in nodes.iter().enumerate() { - let mut current_content = String::new(); - - if let Ok(content) = node.get_text_content() { - current_content = content.to_string(); - } else if let Ok(resource) = node.get_vector_resource_content() { - current_content = resource.as_trait_object().name().to_string(); - } + for (i, chunk) in chunks.iter().enumerate() { + let current_content = chunk.content.clone(); - // Some text is repeated between nodes, so we skip it + // Skip empty or repeated content if current_content.is_empty() || current_content == last_content { continue; } - let mut extra_info = String::new(); - let file_name = resource_trait.source().format_source_string(); - - if let Some(metadata) = &node.metadata { - if let Some(pg_nums) = metadata.get("pg_nums") { - extra_info = format!("\nRef. page: {} from {}.", pg_nums, file_name); - } else { - extra_info = format!("\nRef. from {}.", file_name); - } - } else { - extra_info = format!("\nRef. from {}.", file_name); - } + // Generate extra info based on the chunk's position and file ID + let extra_info = format!("\nRef. chunk: {} from file ID: {}.", chunk.position, chunk.parsed_file_id); if extra_info != last_reference { if !buffer_content.is_empty() { @@ -288,7 +329,7 @@ impl SubPrompt { buffer_content.push_str(&format!(" {}", current_content)); } - if i == nodes.len() - 1 || extra_info != last_reference { + if i == chunks.len() - 1 || extra_info != last_reference { buffer_content.push_str(&extra_info); temp_prompt.add_content(buffer_content.clone(), SubPromptType::ExtraContext, subprompt_priority); buffer_content.clear(); @@ -299,64 +340,4 @@ impl SubPrompt { temp_prompt.remove_all_subprompts() } - - pub fn convert_resource_into_submprompts_for_citation_rag( - resource: &BaseVectorResource, - ) -> Vec { - let resource_trait = resource.as_trait_object(); - let nodes = resource_trait.get_all_nodes_flattened(); - let mut last_content = String::new(); - let mut last_reference = String::new(); - let mut buffer_content = String::new(); - let mut embeddings = Vec::new(); - - for (i, node) in nodes.iter().enumerate() { - let mut current_content = String::new(); - - if let Ok(content) = node.get_text_content() { - current_content = content.to_string(); - } else if let Ok(resource) = node.get_vector_resource_content() { - current_content = resource.as_trait_object().name().to_string(); - } - - // Some text is repeated between nodes, so we skip it - if current_content.is_empty() || current_content == last_content { - continue; - } - - let mut extra_info = String::new(); - if let Some(metadata) = &node.metadata { - if let Some(pg_nums) = metadata.get("pg_nums") { - extra_info = format!("Page: {}", pg_nums); - } - } - - if extra_info != last_reference { - if !buffer_content.is_empty() { - embeddings.push(serde_json::json!({ - "text": buffer_content, - "reference": last_reference, - "file": resource_trait.source().format_source_string() - })); - } - buffer_content.clone_from(¤t_content); - last_reference.clone_from(&extra_info); - } else { - buffer_content.push_str(&format!(" {}", current_content)); - } - - if i == nodes.len() - 1 || extra_info != last_reference { - embeddings.push(serde_json::json!({ - "text": buffer_content, - "reference": extra_info, - "file": resource_trait.source().format_source_string() - })); - buffer_content.clear(); - } - - last_content = current_content; - } - - embeddings - } } diff --git a/shinkai-libs/shinkai-message-primitives/src/schemas/tool_router_key.rs b/shinkai-libs/shinkai-message-primitives/src/schemas/tool_router_key.rs index 347864c46..0593f9ef2 100644 --- a/shinkai-libs/shinkai-message-primitives/src/schemas/tool_router_key.rs +++ b/shinkai-libs/shinkai-message-primitives/src/schemas/tool_router_key.rs @@ -4,6 +4,7 @@ use utoipa::ToSchema; use super::indexable_version::IndexableVersion; #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, ToSchema)] +#[serde(try_from = "String")] pub struct ToolRouterKey { pub source: String, pub toolkit_name: String, @@ -11,6 +12,14 @@ pub struct ToolRouterKey { pub version: Option, } +impl TryFrom for ToolRouterKey { + type Error = String; + + fn try_from(s: String) -> Result { + ToolRouterKey::from_string(&s).map_err(|e| e.to_string()) + } +} + impl ToolRouterKey { pub fn new(source: String, toolkit_name: String, name: String, version: Option) -> Self { Self { @@ -21,6 +30,51 @@ impl ToolRouterKey { } } + pub fn deserialize_tool_router_keys<'de, D>(deserializer: D) -> Result>, D::Error> + where + D: serde::Deserializer<'de>, + { + let string_vec: Option> = Option::deserialize(deserializer)?; + + match string_vec { + Some(vec) => { + let router_keys = vec + .into_iter() + .map(|s| Self::from_string(&s)) + .collect::, _>>() + .map_err(serde::de::Error::custom)?; + Ok(Some(router_keys)) + } + None => Ok(None), + } + } + + pub fn serialize_tool_router_keys( + keys: &Option>, + serializer: S + ) -> Result + where + S: serde::Serializer, + { + match keys { + Some(keys) => { + let strings: Vec = keys + .iter() + .map(|k| { + // If version is Some, use to_string_with_version() + if k.version.is_some() { + k.to_string_with_version() + } else { + k.to_string_without_version() + } + }) + .collect(); + strings.serialize(serializer) + } + None => serializer.serialize_none(), + } + } + fn sanitize(input: &str) -> String { input.chars() .map(|c| if c.is_ascii_alphanumeric() || c == '_' { c } else { '_' }) diff --git a/shinkai-libs/shinkai-message-primitives/src/shinkai_message/shinkai_message.rs b/shinkai-libs/shinkai-message-primitives/src/shinkai_message/shinkai_message.rs index c288cb04a..df32249a5 100644 --- a/shinkai-libs/shinkai-message-primitives/src/shinkai_message/shinkai_message.rs +++ b/shinkai-libs/shinkai-message-primitives/src/shinkai_message/shinkai_message.rs @@ -1,7 +1,6 @@ use super::shinkai_message_schemas::MessageSchemaType; use crate::shinkai_utils::encryption::EncryptionMethod; use serde::{Deserialize, Serialize}; -use shinkai_vector_resources::source::ShinkaiNameString; use utoipa::ToSchema; #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, ToSchema)] @@ -20,10 +19,8 @@ pub struct ShinkaiBody { #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, ToSchema)] pub struct InternalMetadata { - #[schema(value_type = String)] - pub sender_subidentity: ShinkaiNameString, - #[schema(value_type = String)] - pub recipient_subidentity: ShinkaiNameString, + pub sender_subidentity: String, + pub recipient_subidentity: String, pub inbox: String, pub signature: String, pub encryption: EncryptionMethod, @@ -33,14 +30,11 @@ pub struct InternalMetadata { #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, ToSchema)] pub struct ExternalMetadata { - #[schema(value_type = String)] - pub sender: ShinkaiNameString, - #[schema(value_type = String)] - pub recipient: ShinkaiNameString, + pub sender: String, + pub recipient: String, pub scheduled_time: String, pub signature: String, - #[schema(value_type = String)] - pub intra_sender: ShinkaiNameString, + pub intra_sender: String, pub other: String, } diff --git a/shinkai-libs/shinkai-message-primitives/src/shinkai_message/shinkai_message_schemas.rs b/shinkai-libs/shinkai-message-primitives/src/shinkai_message/shinkai_message_schemas.rs index ea5585f63..6fddcaf12 100644 --- a/shinkai-libs/shinkai-message-primitives/src/shinkai_message/shinkai_message_schemas.rs +++ b/shinkai-libs/shinkai-message-primitives/src/shinkai_message/shinkai_message_schemas.rs @@ -3,7 +3,8 @@ use crate::schemas::shinkai_subscription_req::{FolderSubscription, SubscriptionP use crate::schemas::shinkai_tools::DynamicToolType; use crate::schemas::tool_router_key::ToolRouterKey; use crate::schemas::{inbox_name::InboxName, llm_providers::serialized_llm_provider::SerializedLLMProvider}; -use crate::shinkai_utils::job_scope::JobScope; +use crate::shinkai_utils::job_scope::MinimalJobScope; +use crate::shinkai_utils::shinkai_path::ShinkaiPath; use chrono::{DateTime, Utc}; use serde::{Deserialize, Deserializer, Serialize, Serializer}; use std::collections::HashMap; @@ -300,7 +301,7 @@ pub enum AssociatedUI { #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] pub struct JobCreationInfo { - pub scope: JobScope, + pub scope: MinimalJobScope, pub is_hidden: Option, pub associated_ui: Option, } @@ -318,7 +319,6 @@ pub enum CallbackAction { pub struct JobMessage { pub job_id: String, pub content: String, - pub files_inbox: String, pub parent: Option, pub sheet_job_data: Option, // Whenever we need to chain actions, we can use this @@ -327,6 +327,11 @@ pub struct JobMessage { pub metadata: Option, // Whenever we want to force the use of a specific tool, we can use this pub tool_key: Option, + // Field that lists associated files of the message + #[serde(default)] + pub fs_files_paths: Vec, + #[serde(default)] + pub job_filenames: Vec, } #[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq, ToSchema)] diff --git a/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/job_scope.rs b/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/job_scope.rs index 8fd548115..94a9e2aea 100644 --- a/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/job_scope.rs +++ b/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/job_scope.rs @@ -1,16 +1,19 @@ use serde::{Deserialize, Serialize}; -use shinkai_vector_resources::vector_resource::{VRKai, VRPack, VRPath}; -use shinkai_vector_resources::vector_resource::{VectorResourceCore, VectorSearchMode}; -use shinkai_vector_resources::{source::VRSourceReference, vector_resource::BaseVectorResource}; -use std::fmt; use utoipa::ToSchema; -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)] +use super::{search_mode::VectorSearchMode, shinkai_path::ShinkaiPath}; + +#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] pub struct MinimalJobScope { - pub local_vrkai: Vec, - pub local_vrpack: Vec, - pub vector_fs_items: Vec, - pub vector_fs_folders: Vec, + pub vector_fs_items: Vec, // TODO: rename this to non-vector-fs-items + pub vector_fs_folders: Vec, + #[serde(default = "default_vector_search_mode")] + pub vector_search_mode: VectorSearchMode, +} + +// Function to provide the default value for vector_search_mode +fn default_vector_search_mode() -> VectorSearchMode { + VectorSearchMode::FillUpTo25k } impl MinimalJobScope { @@ -23,241 +26,76 @@ impl MinimalJobScope { pub fn from_bytes(bytes: &[u8]) -> serde_json::Result { serde_json::from_slice(bytes) } -} - -impl From<&JobScope> for MinimalJobScope { - fn from(job_scope: &JobScope) -> Self { - let local_vrkai_ids: Vec = job_scope - .local_vrkai - .iter() - .map(|entry| match &entry.vrkai.resource { - BaseVectorResource::Document(doc) => doc.reference_string(), - BaseVectorResource::Map(map) => map.reference_string(), - }) - .collect(); - - let local_vrpack_ids: Vec = job_scope.local_vrpack.iter().map(|entry| entry.vrpack.id()).collect(); - - let vector_fs_item_paths: Vec = job_scope - .vector_fs_items - .iter() - .map(|entry| entry.path.to_string()) - .collect(); - let vector_fs_folder_paths: Vec = job_scope - .vector_fs_folders - .iter() - .map(|entry| entry.path.to_string()) - .collect(); - - MinimalJobScope { - local_vrkai: local_vrkai_ids, - local_vrpack: local_vrpack_ids, - vector_fs_items: vector_fs_item_paths, - vector_fs_folders: vector_fs_folder_paths, - } + /// Checks if both vector_fs_items and vector_fs_folders are empty. + pub fn is_empty(&self) -> bool { + self.vector_fs_items.is_empty() && self.vector_fs_folders.is_empty() } } -#[derive(Serialize, Deserialize, Clone, PartialEq, ToSchema)] -/// Job's scope which includes both Local entries (vrkai stored locally only in job) -/// and VecFS entries (source/vector resource stored in the FS, accessible to all jobs) -pub struct JobScope { - pub local_vrkai: Vec, - pub local_vrpack: Vec, - pub vector_fs_items: Vec, - pub vector_fs_folders: Vec, - #[serde(default, deserialize_with = "deserialize_vec")] - pub vector_search_mode: Vec, -} - -impl JobScope {} -impl JobScope { - /// Create a new JobScope - pub fn new( - local_vrkai: Vec, - local_vrpack: Vec, - vector_fs_items: Vec, - vector_fs_folders: Vec, - vector_search_mode: Vec, - ) -> Self { - Self { - local_vrkai, - local_vrpack, - vector_fs_items, - vector_fs_folders, - vector_search_mode, - } - } - - /// Create a new JobScope with empty defaults - pub fn new_default() -> Self { +impl Default for MinimalJobScope { + fn default() -> Self { Self { - local_vrkai: Vec::new(), - local_vrpack: Vec::new(), vector_fs_items: Vec::new(), vector_fs_folders: Vec::new(), - vector_search_mode: Vec::new(), + vector_search_mode: VectorSearchMode::FillUpTo25k, } } +} - /// Checks if the Job Scope is empty (has no entries) - pub fn is_empty(&self) -> bool { - self.local_vrkai.is_empty() - && self.local_vrpack.is_empty() - && self.vector_fs_items.is_empty() - && self.vector_fs_folders.is_empty() - } - - /// Determines if the JobScope contains significant amount of content to justify - /// more advanced vector searching/more iterations in inference chains. - pub fn contains_significant_content(&self) -> bool { - let mut count = 0; - - // Each VRKai and VectorFSItem counts as 1 - count += self.local_vrkai.len() + self.vector_fs_items.len(); - - // Each VRPack and folder (both VectorFS and Network) counts as a multiple. - count += (self.local_vrpack.len() + self.vector_fs_folders.len()) * 3; - count >= 4 - } +#[cfg(test)] +mod tests { + use super::*; + use serde_json::json; + + #[test] + fn test_deserialize_minimal_job_scope() { + let json_data = json!({ + "vector_fs_items": [], + "vector_fs_folders": ["/My Files (Private)"], + "vector_search_mode": "FillUpTo25k" + }); - pub fn to_bytes(&self) -> serde_json::Result> { - let j = serde_json::to_string(self)?; - Ok(j.into_bytes()) - } + let deserialized: MinimalJobScope = serde_json::from_value(json_data).expect("Failed to deserialize"); - pub fn from_bytes(bytes: &[u8]) -> serde_json::Result { - serde_json::from_slice(bytes) + assert!(deserialized.vector_fs_items.is_empty()); + assert_eq!(deserialized.vector_fs_folders.len(), 1); + assert_eq!(deserialized.vector_fs_folders[0].relative_path(), "My Files (Private)"); + assert_eq!(deserialized.vector_search_mode, VectorSearchMode::FillUpTo25k); } - pub fn from_json_str(s: &str) -> serde_json::Result { - let deserialized: Self = serde_json::from_str(s)?; - Ok(deserialized) - } + #[test] + fn test_deserialize_minimal_job_scope_with_string_items() { + let json_data = json!({ + "vector_fs_items": ["/path/to/file1", "/path/to/file2"], + "vector_fs_folders": [{"path": "/My Files (Private)"}], + "vector_search_mode": "FillUpTo25k" + }); - pub fn to_json_str(&self) -> serde_json::Result { - let json_str = serde_json::to_string(self)?; - Ok(json_str) - } + let deserialized: MinimalJobScope = serde_json::from_value(json_data).expect("Failed to deserialize"); - /// Serializes the JobScope to a JSON value. - pub fn to_json_value(&self) -> serde_json::Result { - serde_json::to_value(self) + assert_eq!(deserialized.vector_fs_items.len(), 2); + assert_eq!(deserialized.vector_fs_items[0].relative_path(), "path/to/file1"); + assert_eq!(deserialized.vector_fs_items[1].relative_path(), "path/to/file2"); + assert_eq!(deserialized.vector_fs_folders.len(), 1); + assert_eq!(deserialized.vector_fs_folders[0].relative_path(), "My Files (Private)"); + assert_eq!(deserialized.vector_search_mode, VectorSearchMode::FillUpTo25k); } - /// Serializes the JobScope to a minimal JSON value similar to the Debug output. - pub fn to_json_value_minimal(&self) -> serde_json::Result { - let local_vrkai_ids: Vec = self - .local_vrkai - .iter() - .map(|entry| match &entry.vrkai.resource { - BaseVectorResource::Document(doc) => doc.reference_string(), - BaseVectorResource::Map(map) => map.reference_string(), - }) - .collect(); - - let local_vrpack_ids: Vec = self.local_vrpack.iter().map(|entry| entry.vrpack.id()).collect(); - - let vector_fs_item_paths: Vec = self - .vector_fs_items - .iter() - .map(|entry| entry.path.to_string()) - .collect(); - - let vector_fs_folder_paths: Vec = self - .vector_fs_folders - .iter() - .map(|entry| entry.path.to_string()) - .collect(); - - let minimal_json = serde_json::json!({ - "local_vrkai": local_vrkai_ids, - "local_vrpack": local_vrpack_ids, - "vector_fs_items": vector_fs_item_paths, - "vector_fs_folders": vector_fs_folder_paths + #[test] + fn test_deserialize_minimal_job_scope_without_vector_search_mode() { + let json_data = json!({ + "vector_fs_items": ["/path/to/file1"], + "vector_fs_folders": ["/My Files (Private)"] + // vector_search_mode is intentionally omitted }); - Ok(minimal_json) - } -} - -impl fmt::Debug for JobScope { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let local_vrkai_ids: Vec = self - .local_vrkai - .iter() - .map(|entry| match &entry.vrkai.resource { - BaseVectorResource::Document(doc) => doc.reference_string(), - BaseVectorResource::Map(map) => map.reference_string(), - }) - .collect(); - - let local_vrpack_ids: Vec = self.local_vrpack.iter().map(|entry| entry.vrpack.id()).collect(); - - let vector_fs_item_paths: Vec = self - .vector_fs_items - .iter() - .map(|entry| entry.path.to_string()) - .collect(); + let deserialized: MinimalJobScope = serde_json::from_value(json_data).expect("Failed to deserialize"); - let vector_fs_folder_paths: Vec = self - .vector_fs_folders - .iter() - .map(|entry| entry.path.to_string()) - .collect(); - - f.debug_struct("JobScope") - .field("local_vrkai", &format_args!("{:?}", local_vrkai_ids)) - .field("local_vrpack", &format_args!("{:?}", local_vrpack_ids)) - .field("vector_fs_items", &format_args!("{:?}", vector_fs_item_paths)) - .field("vector_fs_folders", &format_args!("{:?}", vector_fs_folder_paths)) - .finish() + assert_eq!(deserialized.vector_fs_items.len(), 1); + assert_eq!(deserialized.vector_fs_items[0].relative_path(), "path/to/file1"); + assert_eq!(deserialized.vector_fs_folders.len(), 1); + assert_eq!(deserialized.vector_fs_folders[0].relative_path(), "My Files (Private)"); + assert_eq!(deserialized.vector_search_mode, VectorSearchMode::FillUpTo25k); // Check default } } - -// Convert null values to empty vectors -fn deserialize_vec<'de, D>(deserializer: D) -> Result, D::Error> -where - D: serde::Deserializer<'de>, -{ - Option::deserialize(deserializer).map(|opt| opt.unwrap_or_else(Vec::new)) -} - -/// Enum holding both Local and VectorFS scope entries -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] -pub enum ScopeEntry { - LocalScopeVRKai(LocalScopeVRKaiEntry), - LocalScopeVRPack(LocalScopeVRPackEntry), - VectorFSItem(VectorFSItemScopeEntry), - VectorFSFolder(VectorFSFolderScopeEntry), -} - -/// A Scope Entry for a local VRKai that only lives in the -/// Job's scope (not in the VectorFS & thus not available to other jobs) -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] -pub struct LocalScopeVRKaiEntry { - pub vrkai: VRKai, -} - -/// A Scope Entry for a local VRPack that only lives in the -/// Job's scope (not in the VectorFS & thus not available to other jobs) -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] -pub struct LocalScopeVRPackEntry { - pub vrpack: VRPack, -} - -/// A Scope Entry for a FSItem saved in the VectorFS. -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] -pub struct VectorFSItemScopeEntry { - pub name: String, - pub path: VRPath, - pub source: VRSourceReference, -} - -/// A Scope Entry for a FSFolder saved in the VectorFS. -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] -pub struct VectorFSFolderScopeEntry { - pub name: String, - pub path: VRPath, -} diff --git a/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/mod.rs b/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/mod.rs index 6acfcdd17..526accc67 100644 --- a/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/mod.rs +++ b/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/mod.rs @@ -7,4 +7,9 @@ pub mod shinkai_message_builder_bundled_tools; pub mod signatures; pub mod utils; pub mod file_encryption; -pub mod shinkai_logging; \ No newline at end of file +pub mod shinkai_logging; +pub mod shinkai_time; +pub mod search_mode; +pub mod shinkai_path; +pub mod shinkai_message_to_prompt; +pub mod test_utils; \ No newline at end of file diff --git a/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/search_mode.rs b/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/search_mode.rs new file mode 100644 index 000000000..6efc8737b --- /dev/null +++ b/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/search_mode.rs @@ -0,0 +1,7 @@ +use serde::{Deserialize, Serialize}; +use utoipa::ToSchema; + +#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] +pub enum VectorSearchMode { + FillUpTo25k, +} diff --git a/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/shinkai_message_builder.rs b/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/shinkai_message_builder.rs index 7665686e7..732ef6660 100644 --- a/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/shinkai_message_builder.rs +++ b/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/shinkai_message_builder.rs @@ -3,7 +3,7 @@ use ed25519_dalek::{SigningKey, VerifyingKey}; use x25519_dalek::{PublicKey as EncryptionPublicKey, StaticSecret as EncryptionStaticKey}; use crate::{ - schemas::{inbox_name::InboxName, shinkai_time::ShinkaiStringTime}, + schemas::inbox_name::InboxName, shinkai_message::{ shinkai_message::{ ExternalMetadata, InternalMetadata, MessageBody, MessageData, ShinkaiBody, ShinkaiData, ShinkaiMessage, @@ -18,8 +18,7 @@ use crate::{ }; use super::{ - encryption::{clone_static_secret_key, encryption_secret_key_to_string}, - signatures::{clone_signature_secret_key, signature_secret_key_to_string}, + encryption::{clone_static_secret_key, encryption_secret_key_to_string}, shinkai_time::ShinkaiStringTime, signatures::{clone_signature_secret_key, signature_secret_key_to_string} }; pub type ShinkaiNameString = String; diff --git a/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/shinkai_message_builder_bundled.rs b/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/shinkai_message_builder_bundled.rs index d3cc4fe60..e05ede5a6 100644 --- a/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/shinkai_message_builder_bundled.rs +++ b/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/shinkai_message_builder_bundled.rs @@ -1,7 +1,4 @@ -use crate::{ - schemas::shinkai_name::ShinkaiName, shinkai_message::shinkai_message_schemas::MessageMetadata, - shinkai_utils::job_scope::JobScope, -}; +use crate::{schemas::shinkai_name::ShinkaiName, shinkai_message::shinkai_message_schemas::MessageMetadata}; use ed25519_dalek::SigningKey; use serde::Serialize; use x25519_dalek::{PublicKey as EncryptionPublicKey, StaticSecret as EncryptionStaticKey}; @@ -25,8 +22,7 @@ use crate::{ }; use super::{ - encryption::unsafe_deterministic_encryption_keypair, - shinkai_message_builder::{ShinkaiMessageBuilder, ShinkaiNameString}, + encryption::unsafe_deterministic_encryption_keypair, job_scope::MinimalJobScope, shinkai_message_builder::{ShinkaiMessageBuilder, ShinkaiNameString}, shinkai_path::ShinkaiPath }; impl ShinkaiMessageBuilder { @@ -97,7 +93,7 @@ impl ShinkaiMessageBuilder { #[allow(clippy::too_many_arguments)] #[allow(dead_code)] pub fn job_creation( - scope: JobScope, + scope: MinimalJobScope, is_hidden: bool, my_encryption_secret_key: EncryptionStaticKey, my_signature_secret_key: SigningKey, @@ -134,7 +130,7 @@ impl ShinkaiMessageBuilder { pub fn job_message( job_id: String, content: String, - files_inbox: String, + fs_files_path: Vec, parent_hash: String, my_encryption_secret_key: EncryptionStaticKey, my_signature_secret_key: SigningKey, @@ -148,12 +144,13 @@ impl ShinkaiMessageBuilder { let job_message = JobMessage { job_id, content, - files_inbox, + fs_files_paths: fs_files_path, parent: Some(parent_hash), sheet_job_data: None, callback: None, metadata: None, tool_key: None, + job_filenames: vec![], }; let body = serde_json::to_string(&job_message).map_err(|_| "Failed to serialize job message to JSON")?; @@ -181,7 +178,7 @@ impl ShinkaiMessageBuilder { pub fn job_message_unencrypted( job_id: String, content: String, - files_inbox: String, + fs_files: Vec, parent_hash: String, my_signature_secret_key: SigningKey, node_sender: ShinkaiNameString, @@ -193,12 +190,13 @@ impl ShinkaiMessageBuilder { let job_message = JobMessage { job_id, content, - files_inbox, + fs_files_paths: fs_files, parent: Some(parent_hash), sheet_job_data: None, callback: None, metadata: None, tool_key: None, + job_filenames: vec![], }; let body = serde_json::to_string(&job_message).map_err(|_| "Failed to serialize job message to JSON")?; @@ -208,26 +206,30 @@ impl ShinkaiMessageBuilder { let (placeholder_encryption_sk, placeholder_encryption_pk) = unsafe_deterministic_encryption_keypair(0); - ShinkaiMessageBuilder::new(placeholder_encryption_sk, my_signature_secret_key, placeholder_encryption_pk) - .message_raw_content(body) - .internal_metadata_with_schema( - sender_subidentity.to_string(), - node_receiver_subidentity.clone(), - inbox, - MessageSchemaType::JobMessageSchema, - EncryptionMethod::None, - None, - ) - .body_encryption(EncryptionMethod::None) - .external_metadata_with_intra_sender(node_receiver, node_sender, sender_subidentity) - .build() + ShinkaiMessageBuilder::new( + placeholder_encryption_sk, + my_signature_secret_key, + placeholder_encryption_pk, + ) + .message_raw_content(body) + .internal_metadata_with_schema( + sender_subidentity.to_string(), + node_receiver_subidentity.clone(), + inbox, + MessageSchemaType::JobMessageSchema, + EncryptionMethod::None, + None, + ) + .body_encryption(EncryptionMethod::None) + .external_metadata_with_intra_sender(node_receiver, node_sender, sender_subidentity) + .build() } #[allow(dead_code)] pub fn job_message_from_llm_provider( job_id: String, content: String, - files_inbox: String, + files: Vec, metadata: Option, my_signature_secret_key: SigningKey, node_sender: ShinkaiNameString, @@ -237,12 +239,13 @@ impl ShinkaiMessageBuilder { let job_message = JobMessage { job_id, content, - files_inbox, parent: None, sheet_job_data: None, callback: None, metadata, tool_key: None, + fs_files_paths: files, + job_filenames: vec![], }; let body = serde_json::to_string(&job_message).map_err(|_| "Failed to serialize job message to JSON")?; @@ -448,37 +451,6 @@ impl ShinkaiMessageBuilder { .build() } - #[allow(clippy::too_many_arguments)] - #[allow(dead_code)] - pub fn create_files_inbox_with_sym_key( - my_subidentity_encryption_sk: EncryptionStaticKey, - my_subidentity_signature_sk: SigningKey, - receiver_public_key: EncryptionPublicKey, - inbox: String, - symmetric_key_sk: String, - sender_subidentity: ShinkaiNameString, - sender: ShinkaiNameString, - receiver: ShinkaiNameString, - ) -> Result { - ShinkaiMessageBuilder::new( - my_subidentity_encryption_sk, - my_subidentity_signature_sk, - receiver_public_key, - ) - .message_raw_content(symmetric_key_sk) - .body_encryption(EncryptionMethod::DiffieHellmanChaChaPoly1305) - .internal_metadata_with_schema( - sender_subidentity.clone(), - "".to_string(), - inbox.to_string(), - MessageSchemaType::SymmetricKeyExchange, - EncryptionMethod::None, - None, - ) - .external_metadata_with_intra_sender(receiver.clone(), sender, sender_subidentity) - .build() - } - #[allow(clippy::too_many_arguments)] #[allow(dead_code)] pub fn get_all_inboxes_for_profile( diff --git a/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/shinkai_message_to_prompt.rs b/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/shinkai_message_to_prompt.rs new file mode 100644 index 000000000..6e0abdf85 --- /dev/null +++ b/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/shinkai_message_to_prompt.rs @@ -0,0 +1,129 @@ +use crate::{ + schemas::{prompts::Prompt, subprompts::SubPromptType}, + shinkai_message::shinkai_message::{MessageBody, ShinkaiMessage}, + shinkai_message::shinkai_message_schemas::JobMessage, +}; +use serde_json; +use std::collections::HashMap; + +impl ShinkaiMessage { + pub fn to_prompt(&self) -> Prompt { + let mut prompt = Prompt::new(); + + // Access the recipient_subidentity from the internal metadata + let recipient_subidentity = match &self.body { + MessageBody::Unencrypted(body) => &body.internal_metadata.recipient_subidentity, + _ => { + println!("Message is encrypted, returning empty prompt."); + return prompt; // Return an empty prompt if the message is encrypted + } + }; + + // Attempt to deserialize the message content into a JobMessage + let job_message: JobMessage = match serde_json::from_str(&self.get_message_content().unwrap_or_default()) { + Ok(msg) => msg, + Err(_) => { + JobMessage { + content: self.get_message_content().unwrap_or_default(), + job_id: "".to_string(), + parent: None, + sheet_job_data: None, + callback: None, + metadata: None, + tool_key: None, + fs_files_paths: vec![], + job_filenames: vec![], + } + } + }; + + // Determine the source of the message based on recipient_subidentity + let sub_prompt_type = if recipient_subidentity == "main" { + SubPromptType::Assistant + } else { + SubPromptType::User + }; + + // Add the job message content as an Omni sub-prompt + // println!("Adding omni sub-prompt with content: {}", job_message.content); + prompt.add_omni(job_message.content, HashMap::new(), sub_prompt_type, 100); + + prompt + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::schemas::{inbox_name::InboxName, subprompts::SubPrompt}; + use crate::shinkai_message::shinkai_message_schemas::MessageSchemaType; + use crate::shinkai_utils::encryption::EncryptionMethod; + use crate::shinkai_utils::shinkai_message_builder::ShinkaiMessageBuilder; + use ed25519_dalek::SigningKey; + use x25519_dalek::{PublicKey as EncryptionPublicKey, StaticSecret as EncryptionStaticKey}; + + fn generate_shinkai_message( + content: String, + my_encryption_secret_key: EncryptionStaticKey, + my_signature_secret_key: SigningKey, + receiver_public_key: EncryptionPublicKey, + recipient_subidentity_name: String, + origin_destination_identity_name: String, + timestamp: String, + ) -> ShinkaiMessage { + let inbox_name = InboxName::get_job_inbox_name_from_params("test_job".to_string()).unwrap(); + + let inbox_name_value = match inbox_name { + InboxName::RegularInbox { value, .. } | InboxName::JobInbox { value, .. } => value, + }; + + ShinkaiMessageBuilder::new(my_encryption_secret_key, my_signature_secret_key, receiver_public_key) + .message_raw_content(content.to_string()) + .body_encryption(EncryptionMethod::None) + .message_schema_type(MessageSchemaType::TextContent) + .internal_metadata_with_inbox( + "".to_string(), + recipient_subidentity_name.clone().to_string(), + inbox_name_value, + EncryptionMethod::None, + None, + ) + .external_metadata_with_schedule( + origin_destination_identity_name.clone().to_string(), + origin_destination_identity_name.clone().to_string(), + timestamp, + ) + .build() + .unwrap() + } + + #[test] + fn test_to_prompt() { + // Setup keys and other parameters + let my_encryption_secret_key = EncryptionStaticKey::from([0u8; 32]); + let my_signature_secret_key = SigningKey::from([0u8; 32]); + let receiver_public_key = EncryptionPublicKey::from([0u8; 32]); + let recipient_subidentity_name = "main_profile_node1".to_string(); + let origin_destination_identity_name = "@@node1.shinkai".to_string(); + let timestamp = "2023-07-02T20:53:34.811Z".to_string(); + + // Generate the ShinkaiMessage using the helper function + let message = generate_shinkai_message( + "Hello World 1".to_string(), + my_encryption_secret_key, + my_signature_secret_key, + receiver_public_key, + recipient_subidentity_name, + origin_destination_identity_name, + timestamp, + ); + + let prompt = message.to_prompt(); + assert_eq!(prompt.sub_prompts.len(), 1); + if let SubPrompt::Omni(_, content, _, _) = &prompt.sub_prompts[0] { + assert_eq!(content, "Hello World 1"); + } else { + panic!("Expected Omni variant"); + } + } +} diff --git a/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/shinkai_path.rs b/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/shinkai_path.rs new file mode 100644 index 000000000..fdf29932c --- /dev/null +++ b/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/shinkai_path.rs @@ -0,0 +1,354 @@ +use serde::de::{self, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize, Serializer}; +use serde_json; +use std::env; +use std::fmt; +use std::hash::Hash; +use std::path::{Path, PathBuf}; + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ShinkaiPath { + pub path: PathBuf, +} + +impl ShinkaiPath { + /// Private helper method to create a ShinkaiPath from a &str. + pub fn new(path: &str) -> Self { + let base_path = Self::base_path(); + let path_buf = PathBuf::from(path); + + let final_path = if path_buf.is_absolute() { + if path_buf.starts_with(&base_path) { + path_buf + } else { + base_path.join(path_buf.strip_prefix("/").unwrap_or(&path_buf)) + } + } else { + // Check if base_path is part of path_buf + if path_buf.starts_with(&base_path) { + path_buf + } else { + base_path.join(path_buf) + } + }; + + ShinkaiPath { path: final_path } + } + + /// Returns the base path from the NODE_STORAGE_PATH environment variable, + /// joined with "filesystem". Defaults to "storage/filesystem" if not set. + pub fn base_path() -> PathBuf { + env::var("NODE_STORAGE_PATH") + .ok() + .map(|p| PathBuf::from(p).join("filesystem")) + .unwrap_or_else(|| PathBuf::from("storage/filesystem")) + } + + /// Creates a new ShinkaiPath from a string slice, ensuring it's absolute relative to the base path. + /// If `path` is not absolute, it is joined to the base path. + pub fn from_str(path: &str) -> Self { + Self::new(path) + } + + /// Creates a new ShinkaiPath from a String, ensuring it's absolute relative to the base path. + /// If `path` is not absolute, it is joined to the base path. + /// Note: This doesn't check if the path exists. + pub fn from_string(path: String) -> Self { + Self::new(&path) + } + + /// Returns the path as a string slice. + pub fn as_str(&self) -> &str { + self.path.to_str().unwrap_or("") + } + + /// Checks if the path exists. + pub fn exists(&self) -> bool { + self.path.exists() + } + + /// Appends a component to the path. + pub fn push>(&mut self, component: P) { + self.path.push(component); + } + + /// Converts the ShinkaiPath to a Path reference. + pub fn as_path(&self) -> &Path { + &self.path + } + + /// Returns the relative path of this ShinkaiPath with respect to the base path. + /// If the path is not under the base directory, returns the full path as-is. + pub fn relative_path(&self) -> &str { + let base = Self::base_path(); + if let Ok(stripped) = self.path.strip_prefix(&base) { + stripped.to_str().unwrap_or("") + } else { + // If the path does not lie under the base path, + // you can decide what to do. Here we return the full path string. + self.as_str() + } + } + + /// Returns the extension of the path, if any. + pub fn extension(&self) -> Option<&str> { + self.path.extension().and_then(|ext| ext.to_str()) + } + + /// Returns the full path as a string slice. + pub fn full_path(&self) -> &str { + self.as_str() + } + + /// Returns the base path as a String. + pub fn base_path_as_string() -> String { + Self::base_path().to_str().unwrap_or("").to_string() + } + + /// Creates a new ShinkaiPath representing the base path. + pub fn from_base_path() -> Self { + Self::new("") + } + + /// Checks if the path is a file. + pub fn is_file(&self) -> bool { + self.path.is_file() + } + + /// Returns the filename with its extension, if any, and if it's not a directory. + pub fn filename(&self) -> Option<&str> { + if self.is_file() { + self.path.file_name().and_then(|name| name.to_str()) + } else { + None + } + } + + /// Returns the parent directory as a new ShinkaiPath, if it exists. + pub fn parent(&self) -> Option { + self.path.parent().map(|p| ShinkaiPath::new(p.to_str().unwrap())) + } +} + +// Implement Display for ShinkaiPath to easily print it +impl fmt::Display for ShinkaiPath { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "{}", self.as_str()) + } +} + +impl<'de> Deserialize<'de> for ShinkaiPath { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ShinkaiPathVisitor; + + impl<'de> Visitor<'de> for ShinkaiPathVisitor { + type Value = ShinkaiPath; + + fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + formatter.write_str("either a string or an object with a `path` field") + } + + fn visit_str(self, value: &str) -> Result + where + E: de::Error, + { + Ok(ShinkaiPath::from_str(value)) + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'de>, + { + let mut path_field = None; + while let Some(key) = map.next_key::()? { + match key.as_str() { + "path" => { + if path_field.is_some() { + return Err(de::Error::duplicate_field("path")); + } + path_field = Some(map.next_value()?); + } + _ => { + let _ignored: de::IgnoredAny = map.next_value()?; + } + } + } + let actual_path: String = path_field.ok_or_else(|| de::Error::missing_field("path"))?; + Ok(ShinkaiPath::from_str(&actual_path)) + } + } + + // deserialize_any will check the JSON token and call visit_str or visit_map accordingly + deserializer.deserialize_any(ShinkaiPathVisitor) + } +} + +impl Serialize for ShinkaiPath { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + // Serialize the relative path as a string + serializer.serialize_str(self.relative_path()) + } +} + +// Add tests for the new functionality +#[cfg(test)] +mod tests { + use crate::shinkai_utils::test_utils::testing_create_tempdir_and_set_env_var; + + use super::*; + use serial_test::serial; + use std::{env, fs}; + + #[test] + #[serial] + fn test_base_path() { + let _dir = testing_create_tempdir_and_set_env_var(); + assert_eq!( + ShinkaiPath::base_path(), + PathBuf::from(env::var("NODE_STORAGE_PATH").unwrap()).join("filesystem") + ); + } + + #[test] + #[serial] + fn test_from_string_with_base_path() { + let _dir = testing_create_tempdir_and_set_env_var(); + let path = ShinkaiPath::from_string("word_files/christmas.docx".to_string()); + assert_eq!( + path.as_path(), + Path::new(&format!( + "{}/filesystem/word_files/christmas.docx", + env::var("NODE_STORAGE_PATH").unwrap() + )) + ); + assert_eq!(path.relative_path(), "word_files/christmas.docx"); + } + + #[test] + #[serial] + fn test_from_string_without_base_path() { + let _dir = testing_create_tempdir_and_set_env_var(); + env::remove_var("NODE_STORAGE_PATH"); + let path = ShinkaiPath::from_string("word_files/christmas.docx".to_string()); + assert_eq!( + path.as_path(), + Path::new("storage/filesystem/word_files/christmas.docx") + ); + assert_eq!(path.relative_path(), "word_files/christmas.docx"); + } + + #[test] + #[serial] + fn test_relative_path_outside_base() { + let _dir = testing_create_tempdir_and_set_env_var(); + let absolute_outside = ShinkaiPath::from_string("/some/other/path".to_string()); + assert_eq!(absolute_outside.relative_path(), "some/other/path"); + } + + #[test] + #[serial] + fn test_extension() { + let _dir = testing_create_tempdir_and_set_env_var(); + let path_with_extension = ShinkaiPath::from_string("word_files/christmas.docx".to_string()); + assert_eq!(path_with_extension.extension(), Some("docx")); + + let path_without_extension = ShinkaiPath::from_string("word_files/christmas".to_string()); + assert_eq!(path_without_extension.extension(), None); + } + + #[test] + #[serial] + fn test_new_with_base_path() { + let _dir = testing_create_tempdir_and_set_env_var(); + let base_path = ShinkaiPath::base_path(); + eprintln!("base_path: {:?}", base_path); + let test_path = base_path.join("some/relative/path"); + eprintln!("test_path: {:?}", test_path); + let shinkai_path = ShinkaiPath::new(test_path.to_str().unwrap()); + eprintln!("shinkai_path: {:?}", shinkai_path.full_path()); + assert_eq!(shinkai_path.path, test_path); + } + + #[test] + #[serial] + fn test_new_without_base_path() { + let _dir = testing_create_tempdir_and_set_env_var(); + let base_path = ShinkaiPath::base_path(); + let relative_path = "some/relative/path"; + let expected_path = base_path.join(relative_path); + let shinkai_path = ShinkaiPath::new(relative_path); + eprintln!("shinkai_path: {:?}", shinkai_path.full_path()); + eprintln!("expected_path: {:?}", expected_path); + + assert_eq!(shinkai_path.path, expected_path); + } + + #[test] + #[serial] + fn test_new_with_root_path() { + let _dir = testing_create_tempdir_and_set_env_var(); + let root_path = "/"; + let shinkai_path = ShinkaiPath::new(root_path); + + let expected_path = ShinkaiPath::base_path().join(root_path.trim_start_matches('/')); + assert_eq!(shinkai_path.path, expected_path); + } + + #[test] + #[serial] + fn test_is_file() { + let _dir = testing_create_tempdir_and_set_env_var(); + let file_path = "test_file.txt"; + let shinkai_path = ShinkaiPath::from_string(file_path.to_string()); + + fs::create_dir_all(shinkai_path.as_path().parent().unwrap()).unwrap(); + fs::write(shinkai_path.as_path(), "test".as_bytes()).unwrap(); + + assert!(shinkai_path.is_file()); + } + + #[test] + #[serial] + fn test_filename() { + let _dir = testing_create_tempdir_and_set_env_var(); + + // Create a file to test the filename method + let path_with_extension = "word_files/christmas.docx"; + let shinkai_path_with_extension = ShinkaiPath::from_string(path_with_extension.to_string()); + fs::create_dir_all(shinkai_path_with_extension.as_path().parent().unwrap()).unwrap(); + fs::write(shinkai_path_with_extension.as_path(), "test".as_bytes()).unwrap(); + assert_eq!(shinkai_path_with_extension.filename(), Some("christmas.docx")); + + // Create a file without an extension + let path_without_extension = "word_files/christmas"; + let shinkai_path_without_extension = ShinkaiPath::from_string(path_without_extension.to_string()); + fs::write(shinkai_path_without_extension.as_path(), "test".as_bytes()).unwrap(); + assert_eq!(shinkai_path_without_extension.filename(), Some("christmas")); + + // Test a directory path + let path_with_no_filename = "word_files/"; + let shinkai_path_with_no_filename = ShinkaiPath::from_string(path_with_no_filename.to_string()); + assert_eq!(shinkai_path_with_no_filename.filename(), None); + } + + #[test] + #[serial] + fn test_serialize_relative_path() { + let _dir = testing_create_tempdir_and_set_env_var(); + + // Create a ShinkaiPath instance + let path = ShinkaiPath::from_string("word_files/christmas.docx".to_string()); + + // Serialize the ShinkaiPath + let serialized_path = serde_json::to_string(&path).unwrap(); + + // Check if the serialized output matches the expected relative path + assert_eq!(serialized_path, "\"word_files/christmas.docx\""); + } +} diff --git a/shinkai-libs/shinkai-vector-resources/src/shinkai_time.rs b/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/shinkai_time.rs similarity index 100% rename from shinkai-libs/shinkai-vector-resources/src/shinkai_time.rs rename to shinkai-libs/shinkai-message-primitives/src/shinkai_utils/shinkai_time.rs diff --git a/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/test_utils.rs b/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/test_utils.rs new file mode 100644 index 000000000..8b0925d0f --- /dev/null +++ b/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/test_utils.rs @@ -0,0 +1,26 @@ +#[cfg(test)] + +/// Create a temporary directory and set the NODE_STORAGE_PATH environment variable +/// Return the TempDir object (required so it doesn't get deleted when the function returns) +pub fn testing_create_tempdir_and_set_env_var() -> tempfile::TempDir { + use std::env; + use std::fs; + use tempfile::tempdir; + + use crate::shinkai_utils::shinkai_path::ShinkaiPath; + + let dir = tempdir().unwrap(); + env::set_var("NODE_STORAGE_PATH", dir.path().to_string_lossy().to_string()); + + let shinkai_path = ShinkaiPath::from_base_path(); + + // Check if the directory exists, and create it if it doesn't + if !shinkai_path.as_path().exists() { + let _ = fs::create_dir_all(&shinkai_path.as_path()).map_err(|e| { + eprintln!("Failed to create directory {}: {}", shinkai_path.as_path().display(), e); + panic!("Failed to create directory {}: {}", shinkai_path.as_path().display(), e); + }); + } + + dir // Return the TempDir object +} \ No newline at end of file diff --git a/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/utils.rs b/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/utils.rs index e69de29bb..66496e8af 100644 --- a/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/utils.rs +++ b/shinkai-libs/shinkai-message-primitives/src/shinkai_utils/utils.rs @@ -0,0 +1,71 @@ +use blake3::Hasher; +use rand::RngCore; + +/// Cleans an input string to ensure that it does not have any +/// characters which would break a VRPath, or cause issues generally for the VectorFS. +pub fn clean_string(s: &str) -> String { + s.replace("/", "-").replace(":", "_") +} + +/// Hashes a String using Blake3, returning the hash as an output String +pub fn hash_string(input: &str) -> String { + let mut hasher = blake3::Hasher::new(); + hasher.update(input.as_bytes()); + let result = hasher.finalize(); + hex::encode(result.as_bytes()) +} + +/// Generates a random hex String +pub fn random_string() -> String { + let mut key = [0u8; 32]; + rand::rngs::OsRng.fill_bytes(&mut key); + + let mut hasher = Hasher::new(); + hasher.update(&key); + let hash = hasher.finalize(); + + hex::encode(hash.as_bytes()) +} + +/// Counts the number of tokens from a single message string for llama3 model, +/// where every three normal letters (a-zA-Z) allow an empty space to not be counted, +/// and other symbols are counted as 1 token. +/// This implementation avoids floating point arithmetic by scaling counts. +pub fn count_tokens_from_message_llama3(message: &str) -> usize { + let mut token_count = 0; + let mut alphabetic_count = 0; // Total count of alphabetic characters + let mut space_count = 0; // Total count of spaces + // ^ need to fix this + + // First pass: count alphabetic characters and spaces + for c in message.chars() { + if c.is_ascii_alphabetic() { + alphabetic_count += 1; + } else if c.is_whitespace() { + space_count += 1; + } + } + + // Calculate how many spaces can be ignored + let spaces_to_ignore = alphabetic_count / 3; + + // Determine the alphabetic token weight based on the number of alphabetic characters + let alphabetic_token_weight = if alphabetic_count > 500 { 8 } else { 10 }; + + // Second pass: count tokens, adjusting for spaces that can be ignored + for c in message.chars() { + if c.is_ascii_alphabetic() { + token_count += alphabetic_token_weight; // Counting as 1/3, so add 1 to the scaled count + } else if c.is_whitespace() { + if spaces_to_ignore > 0 { + space_count -= 10; // Reduce the count of spaces to ignore by the scaling factor + } else { + token_count += 30; // Count the space as a full token if not enough alphabetic characters + } + } else { + token_count += 30; // Non-alphabetic characters count as a full token, add 3 to the scaled count + } + } + + (token_count / 30) + 1 // Divide the scaled count by 30 and floor the result, add 1 to account for any remainder +} diff --git a/shinkai-libs/shinkai-message-primitives/tests/shinkai_message_builder_tests.rs b/shinkai-libs/shinkai-message-primitives/tests/shinkai_message_builder_tests.rs index 4e1849f24..cb6b7644d 100644 --- a/shinkai-libs/shinkai-message-primitives/tests/shinkai_message_builder_tests.rs +++ b/shinkai-libs/shinkai-message-primitives/tests/shinkai_message_builder_tests.rs @@ -36,7 +36,7 @@ mod tests { let message_result = ShinkaiMessageBuilder::job_message( inbox.clone(), message_raw_content.clone(), - "".to_string(), + vec![], "".to_string(), my_encryption_sk.clone(), my_signature_sk.clone(), @@ -56,7 +56,7 @@ mod tests { let job_message: JobMessage = serde_json::from_str(&shinkai_data.message_raw_content).unwrap(); assert_eq!(job_message.job_id, inbox); assert_eq!(job_message.content, "hello hello, are u there?"); - assert_eq!(job_message.files_inbox, ""); + assert_eq!(job_message.fs_files_paths, vec![]); } } diff --git a/shinkai-libs/shinkai-message-primitives/tests/shinkai_message_tests.rs b/shinkai-libs/shinkai-message-primitives/tests/shinkai_message_tests.rs index 39fce064e..50e23a7f5 100644 --- a/shinkai-libs/shinkai-message-primitives/tests/shinkai_message_tests.rs +++ b/shinkai-libs/shinkai-message-primitives/tests/shinkai_message_tests.rs @@ -1,10 +1,13 @@ mod tests { + use serde_json; use shinkai_message_primitives::shinkai_message::shinkai_message::ShinkaiMessage; + use shinkai_message_primitives::shinkai_message::shinkai_message_schemas::JobMessage; use shinkai_message_primitives::shinkai_message::shinkai_message_schemas::MessageSchemaType; use shinkai_message_primitives::shinkai_utils::encryption::unsafe_deterministic_encryption_keypair; use shinkai_message_primitives::shinkai_utils::encryption::EncryptionMethod; use shinkai_message_primitives::shinkai_utils::shinkai_message_builder::ShinkaiMessageBuilder; + use shinkai_message_primitives::shinkai_utils::shinkai_path::ShinkaiPath; use shinkai_message_primitives::shinkai_utils::signatures::clone_signature_secret_key; use shinkai_message_primitives::shinkai_utils::signatures::unsafe_deterministic_signature_keypair; @@ -12,7 +15,7 @@ mod tests { fn test_encode_decode_message() { // Initialize the message let (my_encryption_secret_key, my_encryption_public_key) = unsafe_deterministic_encryption_keypair(0); - let (my_signature_secret_key, my_signature_public_key) = unsafe_deterministic_signature_keypair(0); + let (my_signature_secret_key, _my_signature_public_key) = unsafe_deterministic_signature_keypair(0); let receiver_public_key = my_encryption_public_key.clone(); let message = ShinkaiMessageBuilder::new( @@ -139,4 +142,54 @@ mod tests { deserialized_message.calculate_message_hash_for_pagination() ); } + + #[test] + fn test_serialize_deserialize_job_message() { + // Create a sample JobMessage + let job_message = JobMessage { + job_id: "test_job_id".to_string(), + content: "This is a test message".to_string(), + parent: Some("parent_id".to_string()), + sheet_job_data: Some("sheet_data".to_string()), + callback: None, + metadata: None, + tool_key: Some("tool_key".to_string()), + fs_files_paths: vec![], + job_filenames: vec![], + }; + + // Serialize the JobMessage to a JSON string + let serialized = serde_json::to_string(&job_message).expect("Failed to serialize JobMessage"); + + // Deserialize the JSON string back to a JobMessage + let deserialized: JobMessage = serde_json::from_str(&serialized).expect("Failed to deserialize JobMessage"); + + // Assert that the original and deserialized JobMessages are the same + assert_eq!(job_message, deserialized); + } + + #[test] + fn test_serialize_deserialize_job_message_with_files() { + // Create a sample JobMessage with a ShinkaiPath in files + let job_message = JobMessage { + job_id: "test_job_id".to_string(), + content: "This is a test message with files".to_string(), + parent: Some("parent_id".to_string()), + sheet_job_data: Some("sheet_data".to_string()), + callback: None, + metadata: None, + tool_key: Some("tool_key".to_string()), + fs_files_paths: vec![ShinkaiPath::new("/path/to/file")], + job_filenames: vec!["file1.txt".to_string()], + }; + + // Serialize the JobMessage to a JSON string + let serialized = serde_json::to_string(&job_message).expect("Failed to serialize JobMessage"); + + // Deserialize the JSON string back to a JobMessage + let deserialized: JobMessage = serde_json::from_str(&serialized).expect("Failed to deserialize JobMessage"); + + // Assert that the original and deserialized JobMessages are the same + assert_eq!(job_message, deserialized); + } } diff --git a/shinkai-libs/shinkai-spreadsheet-llm/Cargo.toml b/shinkai-libs/shinkai-spreadsheet-llm/Cargo.toml index e1f07f2de..5731d125f 100644 --- a/shinkai-libs/shinkai-spreadsheet-llm/Cargo.toml +++ b/shinkai-libs/shinkai-spreadsheet-llm/Cargo.toml @@ -5,7 +5,7 @@ edition = { workspace = true } authors = { workspace = true } [dependencies] -async-trait = "0.1.74" +async-trait = { workspace = true } chrono = { workspace = true } ndarray = "0.16.1" regex = { workspace = true } diff --git a/shinkai-libs/shinkai-sqlite/Cargo.toml b/shinkai-libs/shinkai-sqlite/Cargo.toml index e0ffa27f2..4d78c806b 100644 --- a/shinkai-libs/shinkai-sqlite/Cargo.toml +++ b/shinkai-libs/shinkai-sqlite/Cargo.toml @@ -14,9 +14,9 @@ r2d2 = "0.8.10" r2d2_sqlite = "0.25" keyphrases = { workspace = true } shinkai_tools_primitives = { workspace = true } -shinkai_vector_resources = { workspace = true } shinkai_message_primitives = { workspace = true } shinkai_sheet = { workspace = true } +shinkai_embedding = { workspace = true } reqwest = { workspace = true } bincode = { workspace = true } zerocopy = "0.8.9" diff --git a/shinkai-libs/shinkai-sqlite/src/agent_manager.rs b/shinkai-libs/shinkai-sqlite/src/agent_manager.rs index cc69a9855..5364eedc5 100644 --- a/shinkai-libs/shinkai-sqlite/src/agent_manager.rs +++ b/shinkai-libs/shinkai-sqlite/src/agent_manager.rs @@ -31,10 +31,11 @@ impl SqliteManager { let knowledge = serde_json::to_string(&agent.knowledge).unwrap(); let config = agent.config.map(|c| serde_json::to_string(&c).unwrap()); let tools = serde_json::to_string(&agent.tools).unwrap(); - + let scope = serde_json::to_string(&agent.scope).unwrap(); + tx.execute( - "INSERT INTO shinkai_agents (name, agent_id, full_identity_name, llm_provider_id, ui_description, knowledge, storage_path, tools, debug_mode, config) - VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10)", + "INSERT INTO shinkai_agents (name, agent_id, full_identity_name, llm_provider_id, ui_description, knowledge, storage_path, tools, debug_mode, config, scope) + VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11)", params![ agent.name, agent.agent_id.to_lowercase(), @@ -46,6 +47,7 @@ impl SqliteManager { tools, agent.debug_mode, config, + scope, ], )?; @@ -81,7 +83,7 @@ impl SqliteManager { let knowledge: String = row.get(5)?; let tools: String = row.get(7)?; let config: Option = row.get(9)?; - + let scope: String = row.get(10)?; Ok(Agent { agent_id: row.get(0)?, name: row.get(1)?, @@ -112,6 +114,11 @@ impl SqliteManager { })?), None => None, }, + scope: serde_json::from_str(&scope).map_err(|e| { + rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError( + e.to_string(), + ))) + })?, }) })?; @@ -131,6 +138,7 @@ impl SqliteManager { let knowledge: String = row.get(5)?; let tools: String = row.get(7)?; let config: Option = row.get(9)?; + let scope: String = row.get(10)?; Ok(Agent { agent_id: row.get(0)?, @@ -162,6 +170,11 @@ impl SqliteManager { })?), None => None, }, + scope: serde_json::from_str(&scope).map_err(|e| { + rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError( + e.to_string(), + ))) + })?, }) }); @@ -189,11 +202,12 @@ impl SqliteManager { let knowledge = serde_json::to_string(&updated_agent.knowledge).unwrap(); let config = updated_agent.config.map(|c| serde_json::to_string(&c).unwrap()); let tools = serde_json::to_string(&updated_agent.tools).unwrap(); + let scope = serde_json::to_string(&updated_agent.scope).unwrap(); // Serialize the scope tx.execute( "UPDATE shinkai_agents - SET name = ?1, full_identity_name = ?2, llm_provider_id = ?3, ui_description = ?4, knowledge = ?5, storage_path = ?6, tools = ?7, debug_mode = ?8, config = ?9 - WHERE agent_id = ?10", + SET name = ?1, full_identity_name = ?2, llm_provider_id = ?3, ui_description = ?4, knowledge = ?5, storage_path = ?6, tools = ?7, debug_mode = ?8, config = ?9, scope = ?10 + WHERE agent_id = ?11", params![ updated_agent.name, updated_agent.full_identity_name.full_name, @@ -204,6 +218,7 @@ impl SqliteManager { tools, updated_agent.debug_mode, config, + scope, updated_agent.agent_id, ], )?; @@ -216,8 +231,8 @@ impl SqliteManager { #[cfg(test)] mod tests { use super::*; + use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; - use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use std::path::PathBuf; use tempfile::NamedTempFile; @@ -245,6 +260,7 @@ mod tests { tools: Default::default(), debug_mode: false, config: None, + scope: Default::default(), }; let profile = ShinkaiName::new("@@test_user.shinkai/main".to_string()).unwrap(); @@ -269,6 +285,7 @@ mod tests { tools: Default::default(), debug_mode: false, config: None, + scope: Default::default(), }; let profile = ShinkaiName::new("@@test_user.shinkai/main".to_string()).unwrap(); @@ -295,6 +312,7 @@ mod tests { tools: Default::default(), debug_mode: false, config: None, + scope: Default::default(), }; let agent2 = Agent { agent_id: "test_agent2".to_string(), @@ -307,6 +325,7 @@ mod tests { tools: Default::default(), debug_mode: false, config: None, + scope: Default::default(), }; let profile = ShinkaiName::new("@@test_user.shinkai/main".to_string()).unwrap(); @@ -333,6 +352,7 @@ mod tests { tools: Default::default(), debug_mode: false, config: None, + scope: Default::default(), }; let profile = ShinkaiName::new("@@test_user.shinkai/main".to_string()).unwrap(); @@ -359,6 +379,7 @@ mod tests { tools: Default::default(), debug_mode: false, config: None, + scope: Default::default(), }; let profile = ShinkaiName::new("@@test_user.shinkai/main".to_string()).unwrap(); @@ -375,6 +396,7 @@ mod tests { tools: Default::default(), debug_mode: true, config: None, + scope: Default::default(), }; let result = db.update_agent(updated_agent.clone()); diff --git a/shinkai-libs/shinkai-sqlite/src/cron_task_manager.rs b/shinkai-libs/shinkai-sqlite/src/cron_task_manager.rs index 22fcf2d2c..1bb196cf2 100644 --- a/shinkai-libs/shinkai-sqlite/src/cron_task_manager.rs +++ b/shinkai-libs/shinkai-sqlite/src/cron_task_manager.rs @@ -213,8 +213,8 @@ impl SqliteManager { #[cfg(test)] mod tests { use super::*; - use shinkai_message_primitives::shinkai_message::shinkai_message_schemas::JobMessage; - use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; + use shinkai_message_primitives::{shinkai_message::shinkai_message_schemas::JobMessage, shinkai_utils::shinkai_path::ShinkaiPath}; + use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use std::path::PathBuf; use tempfile::NamedTempFile; @@ -236,7 +236,8 @@ mod tests { message: JobMessage { job_id: "test_job_id".to_string(), content: "test_message".to_string(), - files_inbox: "".to_string(), + fs_files_paths: vec![], + job_filenames: vec![], parent: None, sheet_job_data: None, callback: None, @@ -265,7 +266,8 @@ mod tests { message: JobMessage { job_id: "test_job_id".to_string(), content: "test_message".to_string(), - files_inbox: "".to_string(), + fs_files_paths: vec![], + job_filenames: vec![], parent: None, sheet_job_data: None, callback: None, @@ -292,7 +294,8 @@ mod tests { message: JobMessage { job_id: "job_id_1".to_string(), content: "message_1".to_string(), - files_inbox: "".to_string(), + fs_files_paths: vec![], + job_filenames: vec![], parent: None, sheet_job_data: None, callback: None, @@ -305,7 +308,8 @@ mod tests { message: JobMessage { job_id: "job_id_2".to_string(), content: "message_2".to_string(), - files_inbox: "".to_string(), + fs_files_paths: vec![], + job_filenames: vec![], parent: None, sheet_job_data: None, callback: None, @@ -338,7 +342,8 @@ mod tests { message: JobMessage { job_id: "test_job_id".to_string(), content: "test_message".to_string(), - files_inbox: "".to_string(), + fs_files_paths: vec![], + job_filenames: vec![], parent: None, sheet_job_data: None, callback: None, @@ -360,7 +365,8 @@ mod tests { message: JobMessage { job_id: "updated_job_id".to_string(), content: "updated_message".to_string(), - files_inbox: "".to_string(), + fs_files_paths: vec![], + job_filenames: vec![], parent: None, sheet_job_data: None, callback: None, @@ -390,7 +396,8 @@ mod tests { message: JobMessage { job_id: "test_job_id".to_string(), content: "test_message".to_string(), - files_inbox: "".to_string(), + fs_files_paths: vec![], + job_filenames: vec![], parent: None, sheet_job_data: None, callback: None, @@ -428,7 +435,8 @@ mod tests { message: JobMessage { job_id: "test_job_id".to_string(), content: "test_message".to_string(), - files_inbox: "".to_string(), + fs_files_paths: vec![], + job_filenames: vec![], parent: None, sheet_job_data: None, callback: None, @@ -468,7 +476,8 @@ mod tests { message: JobMessage { job_id: "test_job_id".to_string(), content: "test_message".to_string(), - files_inbox: "".to_string(), + fs_files_paths: vec![], + job_filenames: vec![], parent: None, sheet_job_data: None, callback: None, diff --git a/shinkai-libs/shinkai-sqlite/src/embedding_function.rs b/shinkai-libs/shinkai-sqlite/src/embedding_function.rs index c4d448e46..8818d56b6 100644 --- a/shinkai-libs/shinkai-sqlite/src/embedding_function.rs +++ b/shinkai-libs/shinkai-sqlite/src/embedding_function.rs @@ -1,7 +1,7 @@ use reqwest::Client; use rusqlite::Result; use serde::{Deserialize, Serialize}; -use shinkai_vector_resources::model_type::EmbeddingModelType; +use shinkai_embedding::model_type::EmbeddingModelType; #[derive(Serialize, Deserialize)] struct OllamaResponse { diff --git a/shinkai-libs/shinkai-sqlite/src/errors.rs b/shinkai-libs/shinkai-sqlite/src/errors.rs index f568d8942..727f70277 100644 --- a/shinkai-libs/shinkai-sqlite/src/errors.rs +++ b/shinkai-libs/shinkai-sqlite/src/errors.rs @@ -1,4 +1,3 @@ -use shinkai_vector_resources::resource_errors::VRError; use thiserror::Error; #[derive(Error, Debug)] @@ -57,16 +56,25 @@ pub enum SqliteManagerError { InboxNotFound(String), #[error("Lock error")] LockError, - #[error("VR error: {0}")] - VRError(VRError), #[error("Invalid data")] InvalidData, #[error("Failed fetching value")] FailedFetchingValue, #[error("Query error: {query}, source: {source}")] - QueryError { query: String, source: rusqlite::Error }, + QueryError { + query: String, + source: rusqlite::Error, + }, + #[error("Directory not empty")] + DirectoryNotEmpty, + #[error("Directory not found")] + DirectoryNotFound, #[error("Unsupported embedding length: {0}")] UnsupportedEmbeddingLength(usize), + #[error("Deserialization error")] + DeserializationError, + #[error("Chrono parse error: {0}")] + ChronoParseError(chrono::ParseError), #[error("Version Converson Error: {0}")] VersionConversionError(String), #[error("Tool key not found: {0}")] @@ -78,18 +86,18 @@ pub enum SqliteManagerError { // Add other error variants as needed } -impl From for SqliteManagerError { - fn from(err: VRError) -> SqliteManagerError { - SqliteManagerError::VRError(err) - } -} - impl From<&str> for SqliteManagerError { fn from(err: &str) -> SqliteManagerError { SqliteManagerError::SomeError(err.to_string()) } } +impl From for SqliteManagerError { + fn from(err: chrono::ParseError) -> SqliteManagerError { + SqliteManagerError::ChronoParseError(err) + } +} + impl From for SqliteManagerError { fn from(err: String) -> SqliteManagerError { SqliteManagerError::SomeError(err) diff --git a/shinkai-libs/shinkai-sqlite/src/file_inbox_manager.rs b/shinkai-libs/shinkai-sqlite/src/file_inbox_manager.rs index ebe7f15a3..e89cfcec2 100644 --- a/shinkai-libs/shinkai-sqlite/src/file_inbox_manager.rs +++ b/shinkai-libs/shinkai-sqlite/src/file_inbox_manager.rs @@ -1,161 +1,70 @@ use rusqlite::params; +use shinkai_message_primitives::shinkai_utils::shinkai_path::ShinkaiPath; use crate::{errors::SqliteManagerError, SqliteManager}; impl SqliteManager { - pub fn add_file_to_files_message_inbox( - &self, - file_inbox_name: String, - file_name: String, - file_content: Vec, - ) -> Result<(), SqliteManagerError> { - let file_inboxes_path = self.get_file_inboxes_path(); - let inbox_dir_name = Self::get_inbox_directory_name(&file_inbox_name); - let file_path = file_inboxes_path.join(&inbox_dir_name).join(&file_name); - - // Store the file content in the inboxes directory - std::fs::create_dir_all(file_path.parent().unwrap()).map_err(|_| SqliteManagerError::FailedFetchingValue)?; - std::fs::write(file_path, file_content).map_err(|_| SqliteManagerError::FailedFetchingValue)?; - - // Store inboxes metadata in the database - let conn = self.get_connection()?; - conn.execute( - "INSERT OR REPLACE INTO file_inboxes (file_inbox_name, file_name) VALUES (?1, ?2)", - params![file_inbox_name, file_name], - )?; - - Ok(()) + fn sanitize_folder_name(inbox_name: &str) -> String { + let invalid_chars = ['\\', '/', ':', '*', '?', '"', '<', '>', '|']; + let sanitized_name: String = inbox_name + .chars() + .map(|c| if invalid_chars.contains(&c) { '_' } else { c }) + .collect(); + + // Trim any trailing whitespace + sanitized_name.trim_end().to_string() } - pub fn get_all_files_from_inbox( - &self, - file_inbox_name: String, - ) -> Result)>, SqliteManagerError> { - let file_inboxes_path = self.get_file_inboxes_path(); - let inbox_dir_name = Self::get_inbox_directory_name(&file_inbox_name); - let inbox_path = file_inboxes_path.join(&inbox_dir_name); + pub fn get_and_create_job_folder(&self, job_id: &str) -> Result { + // Get the job folder name + let folder_path = self.get_job_folder_name(job_id)?; - let conn = self.get_connection()?; - let mut stmt = conn.prepare("SELECT file_name FROM file_inboxes WHERE file_inbox_name = ?1")?; - let file_names = stmt.query_map(params![file_inbox_name], |row| row.get::<_, String>(0))?; - - let mut files = Vec::new(); - for file_name in file_names { - let file_name = file_name?; - let file_path = inbox_path.join(&file_name); - let file_content = std::fs::read(file_path).map_err(|_| SqliteManagerError::FailedFetchingValue)?; - files.push((file_name, file_content)); + // Create the folder if it doesn't exist + if !folder_path.exists() { + std::fs::create_dir_all(&folder_path.path).map_err(|_| SqliteManagerError::FailedFetchingValue)?; } - Ok(files) + Ok(folder_path) } - pub fn get_all_filenames_from_inbox(&self, file_inbox_name: String) -> Result, SqliteManagerError> { + pub fn get_job_folder_name(&self, job_id: &str) -> Result { let conn = self.get_connection()?; - let mut stmt = conn.prepare("SELECT file_name FROM file_inboxes WHERE file_inbox_name = ?1")?; - let file_names = stmt.query_map(params![file_inbox_name], |row| row.get::<_, String>(0))?; - - let mut files = Vec::new(); - for file_name in file_names { - files.push(file_name?); - } - - Ok(files) - } - - pub fn remove_inbox(&self, file_inbox_name: &str) -> Result<(), SqliteManagerError> { - let file_inboxes_path = self.get_file_inboxes_path(); - let inbox_dir_name = Self::get_inbox_directory_name(&file_inbox_name); - let inbox_path = file_inboxes_path.join(&inbox_dir_name); - - std::fs::remove_dir_all(inbox_path).map_err(|_| SqliteManagerError::FailedFetchingValue)?; - - let conn = self.get_connection()?; - conn.execute( - "DELETE FROM file_inboxes WHERE file_inbox_name = ?1", - params![file_inbox_name], - )?; - - Ok(()) - } + let mut stmt = conn.prepare("SELECT conversation_inbox_name, datetime_created FROM jobs WHERE job_id = ?1")?; + let mut rows = stmt.query(params![job_id])?; - pub fn get_file_from_inbox( - &self, - file_inbox_name: String, - file_name: String, - ) -> Result, SqliteManagerError> { - let file_inboxes_path = self.get_file_inboxes_path(); - let inbox_dir_name = Self::get_inbox_directory_name(&file_inbox_name); - let file_path = file_inboxes_path.join(&inbox_dir_name).join(&file_name); + let row = rows.next()?.ok_or(SqliteManagerError::DataNotFound)?; + let conversation_inbox_name: String = row.get(0)?; + let datetime_created: String = row.get(1)?; - std::fs::read(file_path).map_err(|_| SqliteManagerError::FailedFetchingValue) - } - - fn get_file_inboxes_path(&self) -> std::path::PathBuf { - match std::env::var("NODE_STORAGE_PATH").ok() { - Some(path) => std::path::PathBuf::from(path).join("files"), - None => std::path::PathBuf::from("files"), - } - } - - fn get_inbox_directory_name(name: &str) -> String { - let sanitized_dir = name.replace(|c: char| !c.is_ascii_alphanumeric(), "_"); - format!("inbox_{}", sanitized_dir) - } -} - -#[cfg(test)] -mod tests { - use super::*; - use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; - use std::path::PathBuf; - use tempfile::NamedTempFile; - - fn setup_test_db() -> SqliteManager { - let temp_file = NamedTempFile::new().unwrap(); - let db_path = PathBuf::from(temp_file.path()); - let api_url = String::new(); - let model_type = - EmbeddingModelType::OllamaTextEmbeddingsInference(OllamaTextEmbeddingsInference::SnowflakeArcticEmbed_M); - - std::env::set_var("NODE_STORAGE_PATH", db_path.parent().unwrap()); - - SqliteManager::new(db_path, api_url, model_type).unwrap() - } + // Fetch the smart inbox name using the conversation_inbox_name + let smart_inbox_name = self.get_smart_inbox_name(&conversation_inbox_name)?; - #[test] - fn test_files_message_inbox() { - let db = setup_test_db(); - let hex_blake3_hash = "1234567890abcdef".to_string(); - let file_name1 = "test_file.txt".to_string(); - let file_content1 = b"test content".to_vec(); - let file_name2 = "test_file2.txt".to_string(); - let file_content2 = b"test content2".to_vec(); + // Format the datetime_created to a more readable format + let date = chrono::NaiveDateTime::parse_from_str(&datetime_created, "%Y-%m-%dT%H:%M:%S%.fZ")?; + let formatted_date = date.format("%b %d").to_string(); - db.add_file_to_files_message_inbox(hex_blake3_hash.clone(), file_name1.clone(), file_content1.clone()) - .unwrap(); + // Extract the last 4 characters of the job_id + let job_id_suffix = &job_id[job_id.len() - 4..]; - db.add_file_to_files_message_inbox(hex_blake3_hash.clone(), file_name2.clone(), file_content2.clone()) - .unwrap(); + // Create the folder name with the job_id suffix + let folder_name = format!("{} - ({}) {}", formatted_date, job_id_suffix, smart_inbox_name); - let files = db.get_all_files_from_inbox(hex_blake3_hash.clone()).unwrap(); - assert_eq!(files.len(), 2); - assert_eq!(files[0].0, file_name1); - assert_eq!(files[0].1, file_content1); - assert_eq!(files[1].0, file_name2); - assert_eq!(files[1].1, file_content2); + // Use the sanitize_folder_name function to ensure compatibility + let valid_folder_name = Self::sanitize_folder_name(&folder_name); - let file_names = db.get_all_filenames_from_inbox(hex_blake3_hash.clone()).unwrap(); - assert_eq!(file_names.len(), 2); - assert_eq!(file_names[0], file_name1); - assert_eq!(file_names[1], file_name2); + // Truncate if the name is too long + let max_length = 30; // Max length + let final_folder_name = if valid_folder_name.len() > max_length { + valid_folder_name[..max_length].to_string() + } else { + valid_folder_name + }; - let file_content = db.get_file_from_inbox(hex_blake3_hash.clone(), file_name1).unwrap(); - assert_eq!(file_content, file_content1); + // Trim any trailing whitespace from the final folder name + let trimmed_final_folder_name = final_folder_name.trim_end().to_string(); - db.remove_inbox(&hex_blake3_hash).unwrap(); + let folder_name = ShinkaiPath::new(&trimmed_final_folder_name); - let files = db.get_all_files_from_inbox(hex_blake3_hash).unwrap(); - assert_eq!(files.len(), 0); + Ok(folder_name) } } diff --git a/shinkai-libs/shinkai-sqlite/src/file_system.rs b/shinkai-libs/shinkai-sqlite/src/file_system.rs new file mode 100644 index 000000000..22953bbc9 --- /dev/null +++ b/shinkai-libs/shinkai-sqlite/src/file_system.rs @@ -0,0 +1,909 @@ +use crate::{SqliteManager, SqliteManagerError}; +use rusqlite::params; +use shinkai_message_primitives::{ + schemas::shinkai_fs::{ParsedFile, ShinkaiFileChunk}, + shinkai_utils::shinkai_path::ShinkaiPath, +}; + +impl SqliteManager { + pub fn initialize_filesystem_tables(conn: &rusqlite::Connection) -> Result<(), rusqlite::Error> { + // parsed_files table + conn.execute( + "CREATE TABLE IF NOT EXISTS parsed_files ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + relative_path TEXT NOT NULL UNIQUE, + original_extension TEXT, + description TEXT, + source TEXT, + embedding_model_used TEXT, + keywords TEXT, + distribution_info TEXT, + created_time INTEGER, + tags TEXT, + total_tokens INTEGER, + total_characters INTEGER + );", + [], + )?; + + conn.execute( + "CREATE INDEX IF NOT EXISTS idx_parsed_files_rel_path ON parsed_files(relative_path);", + [], + )?; + + // chunks table + conn.execute( + "CREATE TABLE IF NOT EXISTS chunks ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + parsed_file_id INTEGER NOT NULL REFERENCES parsed_files(id) ON DELETE CASCADE, + position INTEGER NOT NULL, + chunk TEXT NOT NULL, + tokens INTEGER, + characters INTEGER, + metadata TEXT + );", + [], + )?; + + conn.execute( + "CREATE INDEX IF NOT EXISTS idx_chunks_parsed_file_position ON chunks(parsed_file_id, position);", + [], + )?; + + // Create our new virtual table for chunk embeddings using sqlite-vec + conn.execute( + "CREATE VIRTUAL TABLE IF NOT EXISTS chunk_vec USING vec0( + embedding float[384], + parsed_file_id INTEGER, + +chunk_id INTEGER -- Normal column recognized as chunk_id + );", + [], + )?; + + Ok(()) + } + + // ------------------------- + // Parsed Files + // ------------------------- + pub fn add_parsed_file(&self, pf: &ParsedFile) -> Result<(), SqliteManagerError> { + let mut conn = self.get_connection()?; + let tx = conn.transaction()?; + + let exists: bool = tx.query_row( + "SELECT EXISTS(SELECT 1 FROM parsed_files WHERE relative_path = ?)", + [&pf.relative_path], + |row| row.get(0), + )?; + if exists { + return Err(SqliteManagerError::DataAlreadyExists); + } + + tx.execute( + "INSERT INTO parsed_files (relative_path, original_extension, description, source, embedding_model_used, + keywords, distribution_info, created_time, tags, total_tokens, total_characters) + VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11)", + params![ + pf.relative_path, + pf.original_extension, + pf.description, + pf.source, + pf.embedding_model_used, + pf.keywords, + pf.distribution_info, + pf.created_time, + pf.tags, + pf.total_tokens, + pf.total_characters + ], + )?; + + tx.commit()?; + Ok(()) + } + + pub fn get_parsed_file_by_rel_path(&self, rel_path: &str) -> Result, SqliteManagerError> { + let conn = self.get_connection()?; + let mut stmt = conn.prepare( + " + SELECT id, relative_path, original_extension, description, source, embedding_model_used, keywords, + distribution_info, created_time, tags, total_tokens, total_characters + FROM parsed_files + WHERE relative_path = ?", + )?; + + let res = stmt.query_row([rel_path], |row| { + Ok(ParsedFile { + id: row.get(0)?, + relative_path: row.get(1)?, + original_extension: row.get(2)?, + description: row.get(3)?, + source: row.get(4)?, + embedding_model_used: row.get(5)?, + keywords: row.get(6)?, + distribution_info: row.get(7)?, + created_time: row.get(8)?, + tags: row.get(9)?, + total_tokens: row.get(10)?, + total_characters: row.get(11)?, + }) + }); + + match res { + Ok(pf) => Ok(Some(pf)), + Err(rusqlite::Error::QueryReturnedNoRows) => Ok(None), + Err(e) => Err(SqliteManagerError::DatabaseError(e)), + } + } + + pub fn update_parsed_file(&self, pf: &ParsedFile) -> Result<(), SqliteManagerError> { + let mut conn = self.get_connection()?; + let tx = conn.transaction()?; + + let exists: bool = tx.query_row( + "SELECT EXISTS(SELECT 1 FROM parsed_files WHERE id = ?)", + [pf.id], + |row| row.get(0), + )?; + + if !exists { + return Err(SqliteManagerError::DataNotFound); + } + + tx.execute( + "UPDATE parsed_files + SET relative_path = ?1, original_extension = ?2, description = ?3, source = ?4, embedding_model_used = ?5, + keywords = ?6, distribution_info = ?7, created_time = ?8, tags = ?9, total_tokens = ?10, total_characters = ?11 + WHERE id = ?12", + params![ + pf.relative_path, + pf.original_extension, + pf.description, + pf.source, + pf.embedding_model_used, + pf.keywords, + pf.distribution_info, + pf.created_time, + pf.tags, + pf.total_tokens, + pf.total_characters, + pf.id, + ], + )?; + + tx.commit()?; + Ok(()) + } + + pub fn remove_parsed_file(&self, parsed_file_id: i64) -> Result<(), SqliteManagerError> { + let mut conn = self.get_connection()?; + let tx = conn.transaction()?; + + let exists: bool = tx.query_row( + "SELECT EXISTS(SELECT 1 FROM parsed_files WHERE id = ?)", + [parsed_file_id], + |row| row.get(0), + )?; + + if !exists { + return Err(SqliteManagerError::DataNotFound); + } + + tx.execute("DELETE FROM parsed_files WHERE id = ?", [parsed_file_id])?; + tx.commit()?; + + Ok(()) + } + + // ------------------------- + // Chunk Embeddings + // ------------------------- + + /// Insert a new chunk (with text/metadata) into the `chunks` table + /// and optionally insert the embedding into `chunk_vec` in one go. + /// Returns the newly-created `chunk_id`. + pub fn create_chunk_with_embedding( + &self, + chunk: &ShinkaiFileChunk, + embedding: Option<&[f32]>, + ) -> Result { + let mut conn = self.get_connection()?; + let tx = conn.transaction()?; + + // 1) Verify the parsed file exists + let parsed_file_exists: bool = tx.query_row( + "SELECT EXISTS(SELECT 1 FROM parsed_files WHERE id = ?)", + [chunk.parsed_file_id], + |row| row.get(0), + )?; + if !parsed_file_exists { + return Err(SqliteManagerError::DataNotFound); + } + + // 2) Insert into `chunks` table + tx.execute( + "INSERT INTO chunks (parsed_file_id, position, chunk) + VALUES (?1, ?2, ?3)", + params![chunk.parsed_file_id, chunk.position, chunk.content], + )?; + + // 3) Retrieve the auto-generated `chunk_id` + let new_chunk_id = tx.last_insert_rowid(); + + // 4) If we have an embedding, insert into `chunk_vec` + if let Some(vec_data) = embedding { + tx.execute( + "INSERT INTO chunk_vec (embedding, parsed_file_id, chunk_id) + VALUES (?, ?, ?)", + params![ + bytemuck::cast_slice(vec_data), // from &[f32] to &[u8] + chunk.parsed_file_id, + new_chunk_id + ], + )?; + } + + tx.commit()?; + Ok(new_chunk_id) + } + + /// Fetch a single chunk from `chunks` (text, metadata) plus + /// *optionally* its embedding from `chunk_vec` in one query. + /// Returns `None` if no chunk is found with that `chunk_id`. + pub fn get_chunk_with_embedding( + &self, + chunk_id: i64, + ) -> Result>)>, SqliteManagerError> { + // We'll do a LEFT JOIN: if there's an embedding in chunk_vec, we get it; + // otherwise we get NULL and interpret that as "no embedding." + let sql = r#" + SELECT + c.id AS c_id, + c.parsed_file_id, + c.position, + c.chunk, + cv.embedding AS vec_data + FROM chunks c + LEFT JOIN chunk_vec cv + ON c.id = cv.chunk_id + WHERE c.id = ? + LIMIT 1 + "#; + + let conn = self.get_connection()?; + let mut stmt = conn.prepare(sql)?; + + let row_result = stmt.query_row([chunk_id], |row| { + // Basic chunk columns: + let c_id: i64 = row.get("c_id")?; + let parsed_file_id: i64 = row.get("parsed_file_id")?; + let position: i64 = row.get("position")?; + let content: String = row.get("chunk")?; + + // Optional embedding column: + let maybe_vec_data: Option> = row.get("vec_data")?; + let embedding_opt: Option> = maybe_vec_data.map(|raw_bytes| { + // Convert &[u8] back to Vec + bytemuck::cast_slice(&raw_bytes).to_vec() + }); + + // Build the chunk + let chunk_struct = ShinkaiFileChunk { + chunk_id: Some(c_id), + parsed_file_id, + position, + content, + }; + + Ok((chunk_struct, embedding_opt)) + }); + + match row_result { + Ok((chunk, embedding)) => Ok(Some((chunk, embedding))), + Err(rusqlite::Error::QueryReturnedNoRows) => Ok(None), + Err(e) => Err(SqliteManagerError::DatabaseError(e)), + } + } + + pub fn get_chunks_for_parsed_file(&self, parsed_file_id: i64) -> Result, SqliteManagerError> { + let conn = self.get_connection()?; + let mut stmt = conn.prepare( + "SELECT id, parsed_file_id, position, chunk FROM chunks WHERE parsed_file_id = ? ORDER BY position", + )?; + let rows = stmt.query_map([parsed_file_id], |row| { + Ok(ShinkaiFileChunk { + chunk_id: Some(row.get(0)?), + parsed_file_id: row.get(1)?, + position: row.get(2)?, + content: row.get(3)?, + }) + })?; + + let mut result = Vec::new(); + for row in rows { + result.push(row?); + } + Ok(result) + } + + /// Removes the chunk (and embedding if present) for the given `chunk_id` in a single transaction. + pub fn remove_chunk_with_embedding(&self, chunk_id: i64) -> Result<(), SqliteManagerError> { + let mut conn = self.get_connection()?; + let tx = conn.transaction()?; + + // 1) Check that the chunk actually exists + let chunk_exists: bool = + tx.query_row("SELECT EXISTS(SELECT 1 FROM chunks WHERE id = ?)", [chunk_id], |row| { + row.get(0) + })?; + if !chunk_exists { + return Err(SqliteManagerError::DataNotFound); + } + + // 2) Remove embedding from `chunk_vec` (if any) + tx.execute("DELETE FROM chunk_vec WHERE chunk_id = ?", [chunk_id])?; + + // 3) Remove the chunk itself + tx.execute("DELETE FROM chunks WHERE id = ?", [chunk_id])?; + + tx.commit()?; + Ok(()) + } + + /// Fetch neighboring chunks around a given position within a specified proximity window. + pub fn get_neighboring_chunks( + &self, + parsed_file_id: i64, + position: i64, + proximity_window_size: usize, + ) -> Result, SqliteManagerError> { + let conn = self.get_connection()?; + let mut stmt = conn.prepare( + "SELECT id, parsed_file_id, position, chunk + FROM chunks + WHERE parsed_file_id = ? AND position BETWEEN ? AND ? + ORDER BY position", + )?; + + let start_position = position - proximity_window_size as i64; + let end_position = position + proximity_window_size as i64; + + let rows = stmt.query_map(params![parsed_file_id, start_position, end_position], |row| { + Ok(ShinkaiFileChunk { + chunk_id: Some(row.get(0)?), + parsed_file_id: row.get(1)?, + position: row.get(2)?, + content: row.get(3)?, + }) + })?; + + let mut result = Vec::new(); + for row in rows { + result.push(row?); + } + Ok(result) + } + + pub fn search_chunks( + &self, + parsed_file_ids: &[i64], + query_embedding: Vec, + limit: usize, + ) -> Result, SqliteManagerError> { + let conn = self.get_connection()?; + + // Serialize the vector to a JSON array string + let vector_json = serde_json::to_string(&query_embedding).map_err(|e| { + eprintln!("Vector serialization error: {}", e); + SqliteManagerError::SerializationError(e.to_string()) + })?; + + // Create a placeholder string for the number of parsed_file_ids + let placeholders = parsed_file_ids.iter().map(|_| "?").collect::>().join(","); + + // SQL query to perform the vector search + let sql = format!( + r#" + SELECT v.chunk_id, v.distance + FROM chunk_vec v + WHERE v.embedding MATCH json(?) + AND v.parsed_file_id IN ({}) + ORDER BY v.distance + LIMIT ? + "#, + placeholders + ); + + let mut stmt = conn.prepare(&sql)?; + + // Convert parsed_file_ids to a Vec of &dyn ToSql + let mut params: Vec<&dyn rusqlite::ToSql> = vec![&vector_json]; + params.extend(parsed_file_ids.iter().map(|id| id as &dyn rusqlite::ToSql)); + + // Create a binding for the limit to ensure it lives long enough + let limit_binding = limit as i64; + params.push(&limit_binding); + + // Convert Vec to slice + let params_slice: Vec<&dyn rusqlite::ToSql> = params.iter().map(|&p| p).collect(); + + // Execute the query and collect results using query_map + let chunk_ids_and_distances: Vec<(i64, f64)> = stmt + .query_map(params_slice.as_slice(), |row| Ok((row.get(0)?, row.get(1)?)))? + .collect::, _>>()?; + + // Fetch the chunk details for each chunk_id + let mut results = Vec::new(); + for (chunk_id, distance) in chunk_ids_and_distances { + if let Some(chunk) = self.get_chunk_with_embedding(chunk_id)? { + results.push((chunk.0, distance)); // Assuming get_chunk_with_embedding returns (ShinkaiFileChunk, Option>) + } + } + + Ok(results) + } + + // ------------------------- + // Folder Paths + // ------------------------- + + pub fn update_folder_paths(&self, old_prefix: &str, new_prefix: &str) -> Result<(), SqliteManagerError> { + let mut conn = self.get_connection()?; + let tx = conn.transaction()?; + + // Construct a wildcard for the old_prefix + let like_pattern = format!("{}%", old_prefix); + + tx.execute( + "UPDATE parsed_files + SET relative_path = REPLACE(relative_path, ?1, ?2) + WHERE relative_path LIKE ?3", + params![old_prefix, new_prefix, like_pattern], + )?; + + tx.commit()?; + Ok(()) + } + + pub fn get_processed_files_in_directory( + &self, + directory_path: &str, + ) -> Result, SqliteManagerError> { + let conn = self.get_connection()?; + let mut stmt = conn.prepare( + "SELECT id, relative_path, original_extension, description, source, embedding_model_used, keywords, + distribution_info, created_time, tags, total_tokens, total_characters + FROM parsed_files + WHERE relative_path LIKE ? AND relative_path NOT LIKE ?", + )?; + + let like_pattern = format!("{}%", directory_path); + let not_like_pattern = format!("{}%/%", directory_path); + + let rows = stmt.query_map(params![like_pattern, not_like_pattern], |row| { + Ok(ParsedFile { + id: row.get(0)?, + relative_path: row.get(1)?, + original_extension: row.get(2)?, + description: row.get(3)?, + source: row.get(4)?, + embedding_model_used: row.get(5)?, + keywords: row.get(6)?, + distribution_info: row.get(7)?, + created_time: row.get(8)?, + tags: row.get(9)?, + total_tokens: row.get(10)?, + total_characters: row.get(11)?, + }) + })?; + + let mut result = Vec::new(); + for row in rows { + result.push(row?); + } + Ok(result) + } + + pub fn get_parsed_file_by_shinkai_path( + &self, + path: &ShinkaiPath, + ) -> Result, SqliteManagerError> { + let rel_path = path.relative_path(); + self.get_parsed_file_by_rel_path(rel_path) + } + + /// Retrieve all parsed files for debugging purposes. + pub fn debug_get_all_parsed_files(&self) -> Result, SqliteManagerError> { + let conn = self.get_connection()?; + let mut stmt = conn.prepare( + "SELECT id, relative_path, original_extension, description, source, embedding_model_used, keywords, + distribution_info, created_time, tags, total_tokens, total_characters + FROM parsed_files", + )?; + + let rows = stmt.query_map([], |row| { + Ok(ParsedFile { + id: row.get(0)?, + relative_path: row.get(1)?, + original_extension: row.get(2)?, + description: row.get(3)?, + source: row.get(4)?, + embedding_model_used: row.get(5)?, + keywords: row.get(6)?, + distribution_info: row.get(7)?, + created_time: row.get(8)?, + tags: row.get(9)?, + total_tokens: row.get(10)?, + total_characters: row.get(11)?, + }) + })?; + + let mut result = Vec::new(); + for row in rows { + result.push(row?); + } + Ok(result) + } + + /// Retrieve all parsed files whose relative paths start with the given prefix. + pub fn get_parsed_files_by_prefix(&self, prefix: &str) -> Result, SqliteManagerError> { + let conn = self.get_connection()?; + let mut stmt = conn.prepare( + "SELECT id, relative_path, original_extension, description, source, embedding_model_used, keywords, + distribution_info, created_time, tags, total_tokens, total_characters + FROM parsed_files + WHERE relative_path LIKE ?", + )?; + + let like_pattern = format!("{}%", prefix); + + let rows = stmt.query_map([like_pattern], |row| { + Ok(ParsedFile { + id: row.get(0)?, + relative_path: row.get(1)?, + original_extension: row.get(2)?, + description: row.get(3)?, + source: row.get(4)?, + embedding_model_used: row.get(5)?, + keywords: row.get(6)?, + distribution_info: row.get(7)?, + created_time: row.get(8)?, + tags: row.get(9)?, + total_tokens: row.get(10)?, + total_characters: row.get(11)?, + }) + })?; + + let mut result = Vec::new(); + for row in rows { + result.push(row?); + } + Ok(result) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; + use std::path::PathBuf; + use tempfile::NamedTempFile; + + fn setup_test_db() -> SqliteManager { + let temp_file = NamedTempFile::new().unwrap(); + let db_path = PathBuf::from(temp_file.path()); + let api_url = String::new(); + let model_type = + EmbeddingModelType::OllamaTextEmbeddingsInference(OllamaTextEmbeddingsInference::SnowflakeArcticEmbed_M); + + SqliteManager::new(db_path, api_url, model_type).unwrap() + } + + fn create_test_parsed_file(id: i64, relative_path: &str) -> ParsedFile { + ParsedFile { + id: Some(id), + relative_path: relative_path.to_string(), + original_extension: None, + description: None, + source: None, + embedding_model_used: None, + keywords: None, + distribution_info: None, + created_time: None, + tags: None, + total_tokens: None, + total_characters: None, + } + } + + #[test] + fn test_add_and_get_parsed_file() { + let db = setup_test_db(); + + let parsed_file = create_test_parsed_file(1, "file.txt"); + let result = db.add_parsed_file(&parsed_file); + assert!(result.is_ok()); + + let fetched = db.get_parsed_file_by_rel_path("file.txt").unwrap().unwrap(); + assert_eq!(fetched.relative_path, "file.txt"); + } + + #[test] + fn test_add_duplicate_parsed_file() { + let db = setup_test_db(); + + let parsed_file1 = create_test_parsed_file(1, "file.txt"); + db.add_parsed_file(&parsed_file1).unwrap(); + + let parsed_file2 = create_test_parsed_file(2, "file.txt"); + let result = db.add_parsed_file(&parsed_file2); + assert!(matches!(result, Err(SqliteManagerError::DataAlreadyExists))); + } + + #[test] + fn test_update_parsed_file() { + let db = setup_test_db(); + + let mut parsed_file = create_test_parsed_file(1, "file.txt"); + db.add_parsed_file(&parsed_file).unwrap(); + + // Update file path + parsed_file.relative_path = "file_new.txt".to_string(); + let result = db.update_parsed_file(&parsed_file); + assert!(result.is_ok()); + + let fetched = db.get_parsed_file_by_rel_path("file_new.txt").unwrap().unwrap(); + assert_eq!(fetched.relative_path, "file_new.txt"); + } + + #[test] + fn test_remove_parsed_file() { + let db = setup_test_db(); + + let parsed_file = create_test_parsed_file(1, "file.txt"); + db.add_parsed_file(&parsed_file).unwrap(); + + let result = db.remove_parsed_file(1); + assert!(result.is_ok()); + + let fetched = db.get_parsed_file_by_rel_path("file.txt").unwrap(); + assert!(fetched.is_none()); + } + + #[test] + fn test_remove_nonexistent_parsed_file() { + let db = setup_test_db(); + + let result = db.remove_parsed_file(999); + assert!(matches!(result, Err(SqliteManagerError::DataNotFound))); + } + + #[test] + fn test_update_folder_paths() { + let db = setup_test_db(); + + let pf1 = create_test_parsed_file(1, "docs/reports/2024/january.txt"); + let pf2 = create_test_parsed_file(2, "docs/reports/2024/february.txt"); + let pf3 = create_test_parsed_file(3, "docs/reports/old_stuff/misc.txt"); + db.add_parsed_file(&pf1).unwrap(); + db.add_parsed_file(&pf2).unwrap(); + db.add_parsed_file(&pf3).unwrap(); + + // Rename folder "docs/reports/2024/" to "docs/reports/2025/" + db.update_folder_paths("docs/reports/2024/", "docs/reports/2025/") + .unwrap(); + + // Check updated files + let updated_pf1 = db + .get_parsed_file_by_rel_path("docs/reports/2025/january.txt") + .unwrap() + .unwrap(); + let updated_pf2 = db + .get_parsed_file_by_rel_path("docs/reports/2025/february.txt") + .unwrap() + .unwrap(); + assert_eq!(updated_pf1.relative_path, "docs/reports/2025/january.txt"); + assert_eq!(updated_pf2.relative_path, "docs/reports/2025/february.txt"); + + // Check that non-matching files are unaffected + let unchanged_pf3 = db + .get_parsed_file_by_rel_path("docs/reports/old_stuff/misc.txt") + .unwrap() + .unwrap(); + assert_eq!(unchanged_pf3.relative_path, "docs/reports/old_stuff/misc.txt"); + } + + #[test] + fn test_get_files_in_directory() { + let db = setup_test_db(); + + // Add parsed files with different relative paths + let pf1 = create_test_parsed_file(1, "docs/reports/2024/january.txt"); + let pf2 = create_test_parsed_file(2, "docs/reports/2024/february.txt"); + let pf3 = create_test_parsed_file(3, "docs/reports/2024/march/summary.txt"); + let pf4 = create_test_parsed_file(4, "docs/reports/old_stuff/misc.txt"); + db.add_parsed_file(&pf1).unwrap(); + db.add_parsed_file(&pf2).unwrap(); + db.add_parsed_file(&pf3).unwrap(); + db.add_parsed_file(&pf4).unwrap(); + + // Retrieve files directly under "docs/reports/2024/" + let files_in_directory = db.get_processed_files_in_directory("docs/reports/2024/").unwrap(); + + // Check that only pf1 and pf2 are returned + assert_eq!(files_in_directory.len(), 2); + assert!(files_in_directory + .iter() + .any(|pf| pf.relative_path == "docs/reports/2024/january.txt")); + assert!(files_in_directory + .iter() + .any(|pf| pf.relative_path == "docs/reports/2024/february.txt")); + assert!(!files_in_directory + .iter() + .any(|pf| pf.relative_path == "docs/reports/2024/march/summary.txt")); + assert!(!files_in_directory + .iter() + .any(|pf| pf.relative_path == "docs/reports/old_stuff/misc.txt")); + } + + #[test] + fn test_add_chunk_auto_id() { + let db = setup_test_db(); + + // Create and add a parsed file to associate with the chunk + let parsed_file = create_test_parsed_file(1, "file.txt"); + db.add_parsed_file(&parsed_file).unwrap(); + + // Create a chunk without specifying an id + let chunk = ShinkaiFileChunk { + chunk_id: None, // No id specified + parsed_file_id: parsed_file.id.unwrap(), + position: 1, + content: "This is a test chunk.".to_string(), + }; + + // Add the chunk to the database + let result = db.create_chunk_with_embedding(&chunk, None); + assert!(result.is_ok()); + + // Retrieve the chunk to verify it was added and has an auto-generated id + let chunks = db.get_chunks_for_parsed_file(parsed_file.id.unwrap()).unwrap(); + assert_eq!(chunks.len(), 1); + assert!(chunks[0].chunk_id.is_some()); // Check that the id is auto-generated + assert_eq!(chunks[0].content, "This is a test chunk."); + } + + #[test] + fn test_vector_search_on_specific_parsed_file() { + let db = setup_test_db(); + + // Create and add two parsed files + let parsed_file1 = create_test_parsed_file(1, "file1.txt"); + let parsed_file2 = create_test_parsed_file(2, "file2.txt"); + db.add_parsed_file(&parsed_file1).unwrap(); + db.add_parsed_file(&parsed_file2).unwrap(); + + // Create and add chunks for the first parsed file + let chunk1_file1 = ShinkaiFileChunk { + chunk_id: None, + parsed_file_id: parsed_file1.id.unwrap(), + position: 1, + content: "This is the first chunk of file1.".to_string(), + }; + let chunk2_file1 = ShinkaiFileChunk { + chunk_id: None, + parsed_file_id: parsed_file1.id.unwrap(), + position: 2, + content: "This is the second chunk of file1.".to_string(), + }; + db.create_chunk_with_embedding(&chunk1_file1, Some(&SqliteManager::generate_vector_for_testing(0.9))) + .unwrap(); + db.create_chunk_with_embedding(&chunk2_file1, Some(&SqliteManager::generate_vector_for_testing(0.9))) + .unwrap(); + + // Create and add chunks for the second parsed file + let chunk1_file2 = ShinkaiFileChunk { + chunk_id: None, + parsed_file_id: parsed_file2.id.unwrap(), + position: 1, + content: "This is the first chunk of file2.".to_string(), + }; + let chunk2_file2 = ShinkaiFileChunk { + chunk_id: None, + parsed_file_id: parsed_file2.id.unwrap(), + position: 2, + content: "This is the second chunk of file2.".to_string(), + }; + db.create_chunk_with_embedding(&chunk1_file2, Some(&SqliteManager::generate_vector_for_testing(0.9))) + .unwrap(); + db.create_chunk_with_embedding(&chunk2_file2, Some(&SqliteManager::generate_vector_for_testing(0.9))) + .unwrap(); + + // Generate a mock query embedding + let query_embedding = SqliteManager::generate_vector_for_testing(0.1); + + // Perform a vector search on the first parsed file + let search_results = db + .search_chunks(&[parsed_file1.id.unwrap()], query_embedding, 10) + .unwrap(); + + // Ensure that only chunks from the first parsed file are returned + assert!(!search_results.is_empty()); + assert!(search_results.iter().all(|(chunk, _)| { + db.get_chunks_for_parsed_file(parsed_file1.id.unwrap()) + .unwrap() + .iter() + .any(|c| c.chunk_id == chunk.chunk_id) + })); + + // Ensure no chunks from the second parsed file are returned + assert!(search_results.iter().all(|(chunk, _)| { + !db.get_chunks_for_parsed_file(parsed_file2.id.unwrap()) + .unwrap() + .iter() + .any(|c| c.chunk_id == chunk.chunk_id) + })); + + // Check that embeddings were added + for (chunk, _) in search_results { + let (_chunk, embedding) = db.get_chunk_with_embedding(chunk.chunk_id.unwrap()).unwrap().unwrap(); + assert!( + embedding.is_some(), + "Embedding should be present for chunk_id: {:?}", + chunk.chunk_id + ); + } + } + + #[test] + fn test_get_neighboring_chunks() { + let db = setup_test_db(); + + // Create and add a parsed file + let parsed_file = create_test_parsed_file(1, "file.txt"); + db.add_parsed_file(&parsed_file).unwrap(); + + // Create and add chunks for the parsed file + for i in 1..=10 { + let chunk = ShinkaiFileChunk { + chunk_id: None, + parsed_file_id: parsed_file.id.unwrap(), + position: i, + content: format!("This is chunk number {}.", i), + }; + db.create_chunk_with_embedding(&chunk, None).unwrap(); + } + + // Fetch neighboring chunks around position 5 with a window size of 2 + let neighbors = db.get_neighboring_chunks(parsed_file.id.unwrap(), 5, 2).unwrap(); + + // Check that the correct neighboring chunks are returned + assert_eq!(neighbors.len(), 5); + let expected_positions = vec![3, 4, 5, 6, 7]; + for (i, chunk) in neighbors.iter().enumerate() { + assert_eq!(chunk.position, expected_positions[i]); + } + } + + #[test] + fn test_get_parsed_files_by_prefix() { + let db = setup_test_db(); + + // Create and add parsed files + let pf1 = create_test_parsed_file(1, "docs/reports/2024/january.txt"); + let pf2 = create_test_parsed_file(2, "docs/reports/2024/february.txt"); + let pf3 = create_test_parsed_file(3, "docs/other/2024/march.txt"); + db.add_parsed_file(&pf1).unwrap(); + db.add_parsed_file(&pf2).unwrap(); + db.add_parsed_file(&pf3).unwrap(); + + // Retrieve files with the prefix "docs/reports/2024/" + let files_with_prefix = db.get_parsed_files_by_prefix("docs/reports/2024/").unwrap(); + + // Check that only pf1 and pf2 are returned + assert_eq!(files_with_prefix.len(), 2); + assert!(files_with_prefix.iter().any(|pf| pf.relative_path == "docs/reports/2024/january.txt")); + assert!(files_with_prefix.iter().any(|pf| pf.relative_path == "docs/reports/2024/february.txt")); + assert!(!files_with_prefix.iter().any(|pf| pf.relative_path == "docs/other/2024/march.txt")); + } +} diff --git a/shinkai-libs/shinkai-sqlite/src/identity_manager.rs b/shinkai-libs/shinkai-sqlite/src/identity_manager.rs index e806e930d..ca0ab0107 100644 --- a/shinkai-libs/shinkai-sqlite/src/identity_manager.rs +++ b/shinkai-libs/shinkai-sqlite/src/identity_manager.rs @@ -588,7 +588,7 @@ mod tests { encryption::unsafe_deterministic_encryption_keypair, signatures::unsafe_deterministic_signature_keypair, }, }; - use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; + use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use std::path::PathBuf; use tempfile::NamedTempFile; diff --git a/shinkai-libs/shinkai-sqlite/src/identity_registration.rs b/shinkai-libs/shinkai-sqlite/src/identity_registration.rs index 132f96cac..16926e2fb 100644 --- a/shinkai-libs/shinkai-sqlite/src/identity_registration.rs +++ b/shinkai-libs/shinkai-sqlite/src/identity_registration.rs @@ -373,7 +373,7 @@ impl SqliteManager { #[cfg(test)] mod tests { use super::*; - use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; + use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use std::path::PathBuf; use tempfile::NamedTempFile; diff --git a/shinkai-libs/shinkai-sqlite/src/inbox_manager.rs b/shinkai-libs/shinkai-sqlite/src/inbox_manager.rs index b1482a27a..138816d95 100644 --- a/shinkai-libs/shinkai-sqlite/src/inbox_manager.rs +++ b/shinkai-libs/shinkai-sqlite/src/inbox_manager.rs @@ -17,8 +17,8 @@ use shinkai_message_primitives::{ shinkai_message::{NodeApiData, ShinkaiMessage}, shinkai_message_schemas::WSTopic, }, + shinkai_utils::shinkai_time::ShinkaiStringTime, }; -use shinkai_vector_resources::shinkai_time::ShinkaiStringTime; use tokio::sync::Mutex; use crate::{SqliteManager, SqliteManagerError}; @@ -532,7 +532,7 @@ impl SqliteManager { let is_finished = if inbox_id.starts_with("job_inbox::") { match InboxName::new(inbox_id.clone()).map_err(|e| SqliteManagerError::SomeError(e.to_string()))? { InboxName::JobInbox { unique_id, .. } => { - let job = self.get_job_with_options(&unique_id, false, false)?; + let job = self.get_job_with_options(&unique_id, false)?; let scope_value = job.scope.to_json_value()?; job_scope_value = Some(scope_value); job_config_value = job.config; @@ -555,7 +555,7 @@ impl SqliteManager { { InboxName::JobInbox { unique_id, .. } => { // Start the timer - let job = self.get_job_with_options(&unique_id, false, false)?; + let job = self.get_job_with_options(&unique_id, false)?; let agent_id = job.parent_agent_or_llm_provider_id; // Check if the agent_id is an LLM provider @@ -628,7 +628,9 @@ impl SqliteManager { Ok(smart_inboxes) } - pub fn update_smart_inbox_name(&self, inbox_id: &str, new_name: &str) -> Result<(), SqliteManagerError> { + // Note: This is unsafe because it does not update folder names which depend on the inbox name + pub fn unsafe_update_smart_inbox_name(&self, inbox_id: &str, new_name: &str) -> Result<(), SqliteManagerError> { + // Update the name in the database let conn = self.get_connection()?; conn.execute( "UPDATE inboxes SET smart_inbox_name = ?1 WHERE inbox_name = ?2", @@ -637,6 +639,16 @@ impl SqliteManager { Ok(()) } + pub fn get_smart_inbox_name(&self, conversation_inbox_name: &str) -> Result { + let conn = self.get_connection()?; + let mut stmt = conn.prepare("SELECT smart_inbox_name FROM inboxes WHERE inbox_name = ?1")?; + let mut rows = stmt.query(params![conversation_inbox_name])?; + + let row = rows.next()?.ok_or(SqliteManagerError::DataNotFound)?; + let smart_inbox_name: String = row.get(0)?; + Ok(smart_inbox_name) + } + pub fn get_last_messages_from_all(&self, n: usize) -> Result, SqliteManagerError> { let conn = self.get_connection()?; let mut stmt = conn.prepare( @@ -664,6 +676,7 @@ impl SqliteManager { mod tests { use super::*; use ed25519_dalek::SigningKey; + use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use shinkai_message_primitives::{ schemas::identity::StandardIdentityType, shinkai_message::{ @@ -676,7 +689,6 @@ mod tests { signatures::{clone_signature_secret_key, unsafe_deterministic_signature_keypair}, }, }; - use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use std::path::PathBuf; use tempfile::NamedTempFile; use x25519_dalek::{PublicKey as EncryptionPublicKey, StaticSecret as EncryptionStaticKey}; diff --git a/shinkai-libs/shinkai-sqlite/src/invoice_manager.rs b/shinkai-libs/shinkai-sqlite/src/invoice_manager.rs index 7f1129992..5d750ca19 100644 --- a/shinkai-libs/shinkai-sqlite/src/invoice_manager.rs +++ b/shinkai-libs/shinkai-sqlite/src/invoice_manager.rs @@ -421,7 +421,7 @@ mod tests { shinkai_tool_offering::{ShinkaiToolOffering, ToolPrice, UsageType, UsageTypeInquiry}, wallet_mixed::{NetworkIdentifier, PublicAddress}, }; - use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; + use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use std::path::PathBuf; use tempfile::NamedTempFile; diff --git a/shinkai-libs/shinkai-sqlite/src/invoice_request_manager.rs b/shinkai-libs/shinkai-sqlite/src/invoice_request_manager.rs index 50c22aff2..df1bf64d2 100644 --- a/shinkai-libs/shinkai-sqlite/src/invoice_request_manager.rs +++ b/shinkai-libs/shinkai-sqlite/src/invoice_request_manager.rs @@ -142,7 +142,7 @@ impl SqliteManager { mod tests { use super::*; use shinkai_message_primitives::schemas::{shinkai_name::ShinkaiName, shinkai_tool_offering::UsageTypeInquiry}; - use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; + use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use std::path::PathBuf; use tempfile::NamedTempFile; diff --git a/shinkai-libs/shinkai-sqlite/src/job_manager.rs b/shinkai-libs/shinkai-sqlite/src/job_manager.rs index f41222dc1..5759982a8 100644 --- a/shinkai-libs/shinkai-sqlite/src/job_manager.rs +++ b/shinkai-libs/shinkai-sqlite/src/job_manager.rs @@ -1,19 +1,16 @@ -use std::{collections::HashMap, sync::Arc}; +use std::sync::Arc; use rusqlite::params; use shinkai_message_primitives::{ schemas::{ inbox_name::InboxName, - job::{ForkedJob, Job, JobLike, JobStepResult}, + job::{ForkedJob, Job, JobLike}, job_config::JobConfig, - prompts::Prompt, - subprompts::SubPromptType, ws_types::WSUpdateHandler, }, shinkai_message::{shinkai_message::ShinkaiMessage, shinkai_message_schemas::AssociatedUI}, - shinkai_utils::job_scope::{JobScope, MinimalJobScope}, + shinkai_utils::{job_scope::MinimalJobScope, shinkai_time::ShinkaiStringTime}, }; -use shinkai_vector_resources::shinkai_time::ShinkaiStringTime; use tokio::sync::Mutex; use crate::{SqliteManager, SqliteManagerError}; @@ -23,7 +20,7 @@ impl SqliteManager { &self, job_id: String, llm_provider_id: String, - scope: JobScope, + scope: MinimalJobScope, is_hidden: bool, associated_ui: Option, config: Option, @@ -34,9 +31,13 @@ impl SqliteManager { let conn = self.get_connection()?; let current_time = ShinkaiStringTime::generate_time_now(); - let scope_with_files_bytes = scope.to_bytes()?; - let scope_bytes = serde_json::to_vec(&scope.to_json_value_minimal()?)?; - + let scope_text = serde_json::to_string(&scope)?; + let associated_ui_text = associated_ui.map_or(Ok("".to_string()), |ui| serde_json::to_string(&ui))?; + let config_text = match &config { + Some(cfg) => serde_json::to_string(cfg)?, + None => "{}".to_string(), + }; + let mut stmt = conn.prepare( "INSERT INTO jobs ( job_id, @@ -45,32 +46,22 @@ impl SqliteManager { is_finished, parent_agent_or_llm_provider_id, scope, - scope_with_files, conversation_inbox_name, - execution_context, associated_ui, config - ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11)", + ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)", )?; - + stmt.execute(params![ job_id, is_hidden, current_time, false, llm_provider_id, - scope_bytes, - scope_with_files_bytes, + scope_text, job_inbox_name.clone(), - serde_json::to_vec(&HashMap::::new()).map_err(|e| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) - })?, - serde_json::to_vec(&associated_ui).map_err(|e| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) - })?, - serde_json::to_vec(&config).map_err(|e| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) - })?, + associated_ui_text, + config_text, ])?; } @@ -82,11 +73,13 @@ impl SqliteManager { pub fn update_job_config(&self, job_id: &str, config: JobConfig) -> Result<(), SqliteManagerError> { let conn = self.get_connection()?; - let config_bytes = serde_json::to_vec(&config)?; + // Serialize the config to a JSON string + let config_text = serde_json::to_string(&config)?; let mut stmt = conn.prepare("UPDATE jobs SET config = ?1 WHERE job_id = ?2")?; - stmt.execute(params![config_bytes, job_id])?; + // Store the JSON as a string + stmt.execute(params![config_text, job_id])?; Ok(()) } @@ -114,26 +107,19 @@ impl SqliteManager { full_hash[..full_hash.len() / 2].to_string() } - pub fn get_job_with_options( - &self, - job_id: &str, - fetch_step_history: bool, - fetch_scope_with_files: bool, - ) -> Result { + pub fn get_job_with_options(&self, job_id: &str, fetch_step_history: bool) -> Result { let ( scope, - scope_with_files, is_finished, is_hidden, datetime_created, parent_agent_id, conversation_inbox, step_history, - execution_context, associated_ui, config, forked_jobs, - ) = self.get_job_data(job_id, fetch_step_history, fetch_scope_with_files)?; + ) = self.get_job_data(job_id, fetch_step_history)?; let job = Job { job_id: job_id.to_string(), @@ -142,10 +128,8 @@ impl SqliteManager { is_finished, parent_agent_or_llm_provider_id: parent_agent_id, scope, - scope_with_files, conversation_inbox_name: conversation_inbox, step_history: step_history.unwrap_or_else(Vec::new), - execution_context, associated_ui, config, forked_jobs, @@ -155,42 +139,12 @@ impl SqliteManager { } pub fn get_job(&self, job_id: &str) -> Result { - self.get_job_with_options(job_id, true, true) - } - - pub fn get_job_like(&self, job_id: &str) -> Result, SqliteManagerError> { - let ( - scope, - scope_with_files, - is_finished, - is_hidden, - datetime_created, - parent_agent_id, - conversation_inbox, - _, - execution_context, - associated_ui, - config, - forked_jobs, - ) = self.get_job_data(job_id, false, true)?; - - let job = Job { - job_id: job_id.to_string(), - is_hidden, - datetime_created, - is_finished, - parent_agent_or_llm_provider_id: parent_agent_id, - scope, - scope_with_files, - conversation_inbox_name: conversation_inbox, - step_history: Vec::new(), // Empty step history for JobLike - execution_context, - associated_ui, - config, - forked_jobs, - }; + let conn = self.get_connection()?; + let mut stmt = conn.prepare("SELECT * FROM jobs WHERE job_id = ?1")?; + let mut rows = stmt.query(params![job_id])?; - Ok(Box::new(job)) + let row = rows.next()?.ok_or(SqliteManagerError::DataNotFound)?; + self.parse_job_from_row(&row, true) } #[allow(clippy::type_complexity)] @@ -198,18 +152,15 @@ impl SqliteManager { &self, job_id: &str, fetch_step_history: bool, - fetch_scope_with_files: bool, ) -> Result< ( MinimalJobScope, - Option, bool, bool, String, String, InboxName, - Option>, - HashMap, + Option>, Option, Option, Vec, @@ -218,12 +169,7 @@ impl SqliteManager { > { let conn = self.get_connection()?; - let scope_with_files = match fetch_scope_with_files { - true => "scope_with_files", - false => "NULL", - }; - - let mut stmt = conn.prepare(&format!( + let mut stmt = conn.prepare( "SELECT job_id, is_hidden, @@ -231,37 +177,36 @@ impl SqliteManager { is_finished, parent_agent_or_llm_provider_id, scope, - {scope_with_files}, conversation_inbox_name, - execution_context, associated_ui, config - FROM jobs WHERE job_id = ?1" - ))?; + FROM jobs WHERE job_id = ?1", + )?; let mut rows = stmt.query(params![job_id])?; let row = rows.next()?.ok_or(SqliteManagerError::DataNotFound)?; - let scope_bytes: Vec = row.get(5)?; + let scope_text: String = row.get(5)?; let is_finished: bool = row.get(3)?; let is_hidden: bool = row.get(1)?; let datetime_created: String = row.get(2)?; let parent_agent_id: String = row.get(4)?; - let inbox_name: String = row.get(7)?; + let inbox_name: String = row.get(6)?; let conversation_inbox: InboxName = InboxName::new(inbox_name).map_err(|e| SqliteManagerError::SomeError(e.to_string()))?; - let execution_context_bytes: Option> = row.get(8)?; - let associated_ui_bytes: Option> = row.get(9)?; - let config_bytes: Option> = row.get(10)?; - - let scope = serde_json::from_slice(&scope_bytes)?; - let scope_with_files = if fetch_scope_with_files { - let scope_with_files_bytes: Option> = row.get(6)?; - serde_json::from_slice(&scope_with_files_bytes.unwrap_or_default())? - } else { - None - }; + let associated_ui_text: Option = row.get(7)?; + let config_text: Option = row.get(8)?; + + let scope: MinimalJobScope = serde_json::from_str(&scope_text)?; + let associated_ui = associated_ui_text + .as_deref() + .filter(|s| !s.is_empty()) + .map_or(Ok(None), |s| serde_json::from_str(s).map(Some))?; + let config = config_text + .as_deref() + .filter(|s| !s.is_empty()) + .map_or(Ok(None), |s| serde_json::from_str(s).map(Some))?; let step_history = if fetch_step_history { self.get_step_history(job_id, true)? @@ -269,10 +214,6 @@ impl SqliteManager { None }; - let execution_context = serde_json::from_slice(&execution_context_bytes.unwrap_or_default())?; - let associated_ui = serde_json::from_slice(&associated_ui_bytes.unwrap_or_default())?; - let config = serde_json::from_slice(&config_bytes.unwrap_or_default())?; - let mut forked_jobs = vec![]; let mut stmt = conn.prepare("SELECT * FROM forked_jobs WHERE parent_job_id = ?1")?; @@ -290,14 +231,12 @@ impl SqliteManager { Ok(( scope, - scope_with_files, is_finished, is_hidden, datetime_created, parent_agent_id, conversation_inbox, step_history, - execution_context, associated_ui, config, forked_jobs, @@ -312,73 +251,21 @@ impl SqliteManager { let mut jobs = vec![]; while let Some(row) = rows.next()? { - let job_id: String = row.get(0)?; - let is_hidden: bool = row.get(1)?; - let datetime_created: String = row.get(2)?; - let is_finished: bool = row.get(3)?; - let parent_agent_id: String = row.get(4)?; - let scope_bytes: Vec = row.get(5)?; - let scope_with_files_bytes: Option> = row.get(6)?; - let inbox_name: String = row.get(7)?; - let conversation_inbox: InboxName = - InboxName::new(inbox_name).map_err(|e| SqliteManagerError::SomeError(e.to_string()))?; - let execution_context_bytes: Option> = row.get(8)?; - let associated_ui_bytes: Option> = row.get(9)?; - let config_bytes: Option> = row.get(10)?; - let scope = serde_json::from_slice(&scope_bytes)?; - let scope_with_files = serde_json::from_slice(&scope_with_files_bytes.unwrap_or_default())?; - let step_history = self.get_step_history(&job_id, false)?; - let execution_context = serde_json::from_slice(&execution_context_bytes.unwrap_or_default())?; - let associated_ui = serde_json::from_slice(&associated_ui_bytes.unwrap_or_default())?; - let config = serde_json::from_slice(&config_bytes.unwrap_or_default())?; - - let mut forked_jobs = vec![]; - - let mut stmt = conn.prepare("SELECT * FROM forked_jobs WHERE parent_job_id = ?1")?; - - let mut rows = stmt.query(params![job_id])?; - - while let Some(row) = rows.next()? { - let forked_job_id: String = row.get(1)?; - let message_id: String = row.get(2)?; - - forked_jobs.push(ForkedJob { - job_id: forked_job_id, - message_id, - }); - } - - let job = Job { - job_id, - is_hidden, - datetime_created, - is_finished, - parent_agent_or_llm_provider_id: parent_agent_id, - scope, - scope_with_files, - conversation_inbox_name: conversation_inbox, - step_history: step_history.unwrap_or_else(Vec::new), - execution_context, - associated_ui, - config, - forked_jobs, - }; - - jobs.push(job); + let job = self.parse_job_from_row(&row, false)?; + jobs.push(Box::new(job) as Box); } - Ok(jobs.into_iter().map(|job| Box::new(job) as Box).collect()) + Ok(jobs) } - pub fn update_job_scope(&self, job_id: String, scope: JobScope) -> Result<(), SqliteManagerError> { + pub fn update_job_scope(&self, job_id: String, scope: MinimalJobScope) -> Result<(), SqliteManagerError> { let conn = self.get_connection()?; - let scope_bytes = serde_json::to_vec(&scope.to_json_value_minimal()?)?; - let scope_with_files_bytes = scope.to_bytes()?; + let scope_text = serde_json::to_string(&scope.to_json_value()?)?; - let mut stmt = conn.prepare("UPDATE jobs SET scope = ?1, scope_with_files = ?2 WHERE job_id = ?3")?; + let mut stmt = conn.prepare("UPDATE jobs SET scope = ?1 WHERE job_id = ?2")?; - stmt.execute(params![scope_bytes, scope_with_files_bytes, job_id])?; + stmt.execute(params![scope_text, job_id])?; Ok(()) } @@ -391,91 +278,11 @@ impl SqliteManager { let mut jobs = vec![]; while let Some(row) = rows.next()? { - let job_id: String = row.get(0)?; - let is_hidden: bool = row.get(1)?; - let datetime_created: String = row.get(2)?; - let is_finished: bool = row.get(3)?; - let parent_agent_id: String = row.get(4)?; - let scope_bytes: Vec = row.get(5)?; - let scope_with_files_bytes: Option> = row.get(6)?; - let inbox_name: String = row.get(7)?; - let conversation_inbox: InboxName = - InboxName::new(inbox_name).map_err(|e| SqliteManagerError::SomeError(e.to_string()))?; - let execution_context_bytes: Option> = row.get(8)?; - let associated_ui_bytes: Option> = row.get(9)?; - let config_bytes: Option> = row.get(10)?; - let scope = serde_json::from_slice(&scope_bytes)?; - let scope_with_files = serde_json::from_slice(&scope_with_files_bytes.unwrap_or_default())?; - let step_history = self.get_step_history(&job_id, false)?; - let execution_context = serde_json::from_slice(&execution_context_bytes.unwrap_or_default())?; - let associated_ui = serde_json::from_slice(&associated_ui_bytes.unwrap_or_default())?; - let config = serde_json::from_slice(&config_bytes.unwrap_or_default())?; - - let mut forked_jobs = vec![]; - - let mut stmt = conn.prepare("SELECT * FROM forked_jobs WHERE parent_job_id = ?1")?; - let mut rows = stmt.query(params![job_id])?; - - while let Some(row) = rows.next()? { - let forked_job_id: String = row.get(1)?; - let message_id: String = row.get(2)?; - - forked_jobs.push(ForkedJob { - job_id: forked_job_id, - message_id, - }); - } - - let job = Job { - job_id, - is_hidden, - datetime_created, - is_finished, - parent_agent_or_llm_provider_id: parent_agent_id, - scope, - scope_with_files, - conversation_inbox_name: conversation_inbox, - step_history: step_history.unwrap_or_else(Vec::new), - execution_context, - associated_ui, - config, - forked_jobs, - }; - - jobs.push(job); + let job = self.parse_job_from_row(&row, false)?; + jobs.push(Box::new(job) as Box); } - Ok(jobs.into_iter().map(|job| Box::new(job) as Box).collect()) - } - - pub fn set_job_execution_context( - &self, - job_id: String, - context: HashMap, - _message_key: Option, - ) -> Result<(), SqliteManagerError> { - let conn = self.get_connection()?; - - let context_bytes = serde_json::to_vec(&context)?; - - let mut stmt = conn.prepare("UPDATE jobs SET execution_context = ?1 WHERE job_id = ?2")?; - - stmt.execute(params![context_bytes, job_id])?; - - Ok(()) - } - - pub fn get_job_execution_context(&self, job_id: &str) -> Result, SqliteManagerError> { - let conn = self.get_connection()?; - let mut stmt = conn.prepare("SELECT execution_context FROM jobs WHERE job_id = ?1")?; - let mut rows = stmt.query(params![job_id])?; - - let row = rows.next()?.ok_or(SqliteManagerError::DataNotFound)?; - - let execution_context_bytes: Vec = row.get(0)?; - let execution_context = serde_json::from_slice(&execution_context_bytes)?; - - Ok(execution_context) + Ok(jobs) } pub fn update_job_to_finished(&self, job_id: &str) -> Result<(), SqliteManagerError> { @@ -493,114 +300,36 @@ impl SqliteManager { Ok(()) } - pub fn add_step_history( - &self, - job_id: String, - user_message: String, - user_files: Option>, - agent_response: String, - agent_files: Option>, - message_key: Option, - ) -> Result<(), SqliteManagerError> { - let message_key = match message_key { - Some(key) => key, - None => { - // Fetch the most recent message from the job's inbox - let inbox_name = InboxName::get_job_inbox_name_from_params(job_id.clone()) - .map_err(|e| SqliteManagerError::SomeError(format!("Error getting inbox name: {}", e)))?; - let last_messages = self.get_last_messages_from_inbox(inbox_name.to_string(), 1, None)?; - if let Some(message) = last_messages.first() { - if let Some(message) = message.first() { - message.calculate_message_hash_for_pagination() - } else { - return Err(SqliteManagerError::SomeError( - "No messages found in the inbox".to_string(), - )); - } - } else { - return Err(SqliteManagerError::SomeError( - "No messages found in the inbox".to_string(), - )); - } - } - }; - - // Create prompt & JobStepResult - let mut prompt = Prompt::new(); - let user_files = user_files.unwrap_or_default(); - let agent_files = agent_files.unwrap_or_default(); - prompt.add_omni(user_message, user_files, SubPromptType::User, 100); - prompt.add_omni(agent_response, agent_files, SubPromptType::Assistant, 100); - let mut job_step_result = JobStepResult::new(); - job_step_result.add_new_step_revision(prompt); - - let step_result_bytes = serde_json::to_vec(&job_step_result) - .map_err(|e| SqliteManagerError::SerializationError(format!("Error serializing JobStepResult: {}", e)))?; - - let conn = self.get_connection()?; - let mut stmt = - conn.prepare("INSERT INTO step_history (message_key, job_id, job_step_result) VALUES (?1, ?2, ?3)")?; - stmt.execute(params![message_key, job_id, step_result_bytes])?; - - Ok(()) - } - pub fn get_step_history( &self, job_id: &str, fetch_step_history: bool, - ) -> Result>, SqliteManagerError> { + ) -> Result>, SqliteManagerError> { if !fetch_step_history { return Ok(None); } let inbox_name = InboxName::get_job_inbox_name_from_params(job_id.to_string()) .map_err(|e| SqliteManagerError::SomeError(format!("Error getting inbox name: {}", e)))?; - let mut step_history: Vec = Vec::new(); - let mut until_offset_key: Option = None; - - let conn = self.get_connection()?; - - loop { - // Note(Nico): changing n to 2 helps a lot to debug potential pagination problems - let mut messages = - self.get_last_messages_from_inbox(inbox_name.to_string(), 2, until_offset_key.clone())?; - if messages.is_empty() { - break; - } - - messages.reverse(); - - for message_path in &messages { - if let Some(message) = message_path.first() { - let message_key = message.calculate_message_hash_for_pagination(); - let mut stmt = conn.prepare("SELECT job_step_result FROM step_history WHERE message_key = ?1")?; - let mut rows = stmt.query(params![message_key])?; + let messages = self.get_last_messages_from_inbox(inbox_name.to_string(), 1000, None)?; + eprintln!("(get_step_history) Messages: {:?}", messages); - while let Some(row) = rows.next()? { - let step_result_bytes: Vec = row.get(0)?; - let step_result: JobStepResult = serde_json::from_slice(&step_result_bytes)?; - - step_history.push(step_result); - } - } - } - - if let Some(last_message_path) = messages.last() { - if let Some(last_message) = last_message_path.first() { - until_offset_key = Some(last_message.calculate_message_hash_for_pagination()); + // Map and collect the first element of each inner vector + let first_messages: Vec = messages + .into_iter() + .filter_map(|mut msg_vec| { + if !msg_vec.is_empty() { + Some(msg_vec.remove(0)) } else { - break; + None } - } else { - break; - } - } + }) + .collect(); + + eprintln!("(get_step_history) First messages: {:?}", first_messages); - // Reverse the step history before returning - step_history.reverse(); - Ok(Some(step_history)) + Ok(Some(first_messages)) } pub fn is_job_inbox_empty(&self, job_id: &str) -> Result { @@ -654,33 +383,98 @@ impl SqliteManager { params![inbox_name.to_string()], )?; - tx.execute("DELETE FROM step_history WHERE job_id = ?1", params![job_id])?; tx.execute("DELETE FROM jobs WHERE job_id = ?1", params![job_id])?; tx.commit()?; Ok(()) } + + fn parse_job_from_row(&self, row: &rusqlite::Row, fetch_step_history: bool) -> Result { + let job_id: String = row.get(0)?; + let is_hidden: bool = row.get(1)?; + let datetime_created: String = row.get(2)?; + let is_finished: bool = row.get(3)?; + let parent_agent_id: String = row.get(4)?; + let scope_text: String = row.get(5)?; + let inbox_name: String = row.get(6)?; + let conversation_inbox: InboxName = + InboxName::new(inbox_name).map_err(|e| SqliteManagerError::SomeError(e.to_string()))?; + let associated_ui_text: Option = row.get(7)?; + let config_text: Option = row.get(8)?; + + if let Some(ref text) = config_text { + match serde_json::from_str::(text) { + Ok(config) => eprintln!("Deserialized config: {:?}", config), + Err(e) => eprintln!("Failed to deserialize config: {:?}", e), + } + } + + let scope: MinimalJobScope = serde_json::from_str(&scope_text)?; + let associated_ui = associated_ui_text + .as_deref() + .filter(|s| !s.is_empty()) + .map_or(Ok(None), |s| serde_json::from_str(s).map(Some))?; + let config = config_text + .as_deref() + .filter(|s| !s.is_empty()) + .map_or(Ok(None), |s| serde_json::from_str(s).map(Some))?; + + let step_history = if fetch_step_history { + self.get_step_history(&job_id, true)? + } else { + None + }; + + let mut forked_jobs = vec![]; + + let conn = self.get_connection()?; + let mut stmt = conn.prepare("SELECT * FROM forked_jobs WHERE parent_job_id = ?1")?; + let mut rows = stmt.query(params![job_id])?; + + while let Some(row) = rows.next()? { + let forked_job_id: String = row.get(1)?; + let message_id: String = row.get(2)?; + + forked_jobs.push(ForkedJob { + job_id: forked_job_id, + message_id, + }); + } + + Ok(Job { + job_id, + is_hidden, + datetime_created, + is_finished, + parent_agent_or_llm_provider_id: parent_agent_id, + scope, + conversation_inbox_name: conversation_inbox, + step_history: step_history.unwrap_or_else(Vec::new), + associated_ui, + config, + forked_jobs, + }) + } } #[cfg(test)] mod tests { use super::*; use ed25519_dalek::SigningKey; + use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use shinkai_message_primitives::schemas::identity::StandardIdentity; use shinkai_message_primitives::schemas::inbox_permission::InboxPermission; use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; - use shinkai_message_primitives::schemas::subprompts::SubPromptType::{Assistant, User}; use shinkai_message_primitives::{ - schemas::{identity::StandardIdentityType, subprompts::SubPrompt}, + schemas::identity::StandardIdentityType, shinkai_message::shinkai_message_schemas::{IdentityPermissions, JobMessage, MessageSchemaType}, shinkai_utils::{ encryption::{unsafe_deterministic_encryption_keypair, EncryptionMethod}, shinkai_message_builder::ShinkaiMessageBuilder, - signatures::{clone_signature_secret_key, unsafe_deterministic_signature_keypair}, + signatures::unsafe_deterministic_signature_keypair, }, }; - use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use std::{collections::HashSet, path::PathBuf, time::Duration}; use tempfile::NamedTempFile; use tokio::time::sleep; @@ -696,7 +490,7 @@ mod tests { SqliteManager::new(db_path, api_url, model_type).unwrap() } - fn create_new_job(db: &SqliteManager, job_id: String, agent_id: String, scope: JobScope) { + fn create_new_job(db: &SqliteManager, job_id: String, agent_id: String, scope: MinimalJobScope) { match db.create_new_job(job_id, agent_id, scope, false, None, None) { Ok(_) => (), Err(e) => panic!("Failed to create a new job: {}", e), @@ -743,7 +537,7 @@ mod tests { let db = setup_test_db(); let job_id = "job1".to_string(); let agent_id = "agent1".to_string(); - let scope = JobScope::new_default(); + let scope = MinimalJobScope::default(); // Create a new job create_new_job(&db, job_id.clone(), agent_id.clone(), scope); @@ -771,7 +565,7 @@ mod tests { for i in 1..=5 { let job_id = format!("job{}", i); eprintln!("job_id: {}", job_id.clone()); - let scope = JobScope::new_default(); + let scope = MinimalJobScope::default(); create_new_job(&db, job_id, agent_id.clone(), scope); } @@ -795,7 +589,7 @@ mod tests { let job_id = "job_to_change_agent".to_string(); let initial_agent_id = "initial_agent".to_string(); let new_agent_id = "new_agent".to_string(); - let scope = JobScope::new_default(); + let scope = MinimalJobScope::default(); // Create a new job with the initial agent create_new_job(&db, job_id.clone(), initial_agent_id.clone(), scope); @@ -826,7 +620,7 @@ mod tests { // let inbox_name = // InboxName::new("inbox::@@node1.shinkai/subidentity::@@node2.shinkai/subidentity2::true".to_string()) // .unwrap(); - let scope = JobScope::new_default(); + let scope = MinimalJobScope::default(); // Create a new job create_new_job(&db, job_id.clone(), agent_id.clone(), scope); @@ -839,61 +633,6 @@ mod tests { assert!(job.is_finished); } - #[tokio::test] - async fn test_update_step_history() { - let db = setup_test_db(); - let job_id = "test_job".to_string(); - - let node1_identity_name = "@@node1.shinkai"; - let node1_subidentity_name = "main_profile_node1"; - let (node1_identity_sk, _) = unsafe_deterministic_signature_keypair(0); - let (node1_encryption_sk, node1_encryption_pk) = unsafe_deterministic_encryption_keypair(0); - - let agent_id = "agent_test".to_string(); - let scope = JobScope::new_default(); - - // Create a new job - create_new_job(&db, job_id.clone(), agent_id.clone(), scope); - - let message = generate_message_with_text( - "Hello World".to_string(), - node1_encryption_sk.clone(), - clone_signature_secret_key(&node1_identity_sk), - node1_encryption_pk, - node1_subidentity_name.to_string(), - node1_identity_name.to_string(), - "2023-07-02T20:53:34.810Z".to_string(), - ); - - // Insert the ShinkaiMessage into the database - db.unsafe_insert_inbox_message(&message, None, None).await.unwrap(); - - // Update step history - db.add_step_history( - job_id.clone(), - "What is 10 + 25".to_string(), - None, - "The answer is 35".to_string(), - None, - None, - ) - .unwrap(); - sleep(Duration::from_millis(10)).await; - db.add_step_history( - job_id.clone(), - "2) What is 10 + 25".to_string(), - None, - "2) The answer is 35".to_string(), - None, - None, - ) - .unwrap(); - - // Retrieve the job and check that step history is updated - let job = db.get_job(&job_id.clone()).unwrap(); - assert_eq!(job.step_history.len(), 2); - } - #[test] fn test_get_non_existent_job() { let db = setup_test_db(); @@ -935,7 +674,7 @@ mod tests { // Create new jobs for the agent for i in 1..=5 { let job_id = format!("job{}", i); - let scope = JobScope::new_default(); + let scope = MinimalJobScope::default(); create_new_job(&db, job_id, agent_id.clone(), scope); } @@ -955,7 +694,7 @@ mod tests { let db = setup_test_db(); let job_id = "job_test".to_string(); let agent_id = "agent_test".to_string(); - let scope = JobScope::new_default(); + let scope = MinimalJobScope::default(); // Create a new job create_new_job(&db, job_id.clone(), agent_id.clone(), scope); @@ -967,7 +706,7 @@ mod tests { let shinkai_message = ShinkaiMessageBuilder::job_message_from_llm_provider( job_id.to_string(), "something".to_string(), - "".to_string(), + vec![], None, placeholder_signature_sk, "@@node1.shinkai".to_string(), @@ -989,7 +728,7 @@ mod tests { let db = setup_test_db(); let job_id = "job_test".to_string(); let agent_id = "agent_test".to_string(); - let scope = JobScope::new_default(); + let scope = MinimalJobScope::default(); // Create a new job create_new_job(&db, job_id.clone(), agent_id.clone(), scope); @@ -1010,7 +749,7 @@ mod tests { let shinkai_message = ShinkaiMessageBuilder::job_message_from_llm_provider( job_id.clone(), format!("Hello World {}", i), - "".to_string(), + vec![], None, placeholder_signature_sk.clone(), "@@node1.shinkai".to_string(), @@ -1025,9 +764,10 @@ mod tests { }; // Add a message to the job - let _ = db + let result = db .add_message_to_job_inbox(&job_id.clone(), &shinkai_message, parent_hash.clone(), None) .await; + eprintln!("result {:?}", result); // Update the parent message according to the tree structure if i == 1 { @@ -1078,327 +818,12 @@ mod tests { assert_eq!(job_message_4.content, "Hello World 4".to_string()); } - #[tokio::test] - async fn test_job_inbox_tree_structure_with_step_history_and_execution_context() { - let db = setup_test_db(); - let job_id = "job_test".to_string(); - let agent_id = "agent_test".to_string(); - let scope = JobScope::new_default(); - - // Create a new job - create_new_job(&db, job_id.clone(), agent_id.clone(), scope); - - let (placeholder_signature_sk, _) = unsafe_deterministic_signature_keypair(0); - - let mut parent_message_hash: Option = None; - let mut parent_message_hash_2: Option = None; - - /* - The tree that we are creating looks like: - 1 - ├── 2 - │ ├── 4 - └── 3 - */ - let mut current_level = 0; - let mut results = Vec::new(); - for i in 1..=4 { - let shinkai_message = ShinkaiMessageBuilder::job_message_from_llm_provider( - job_id.clone(), - format!("Hello World {}", i), - "".to_string(), - None, - placeholder_signature_sk.clone(), - "@@node1.shinkai".to_string(), - "@@node1.shinkai".to_string(), - ) - .unwrap(); - - let parent_hash: Option = match i { - 2 | 3 => { - current_level += 1; - parent_message_hash.clone() - } - 4 => { - results.pop(); - parent_message_hash_2.clone() - } - _ => None, - }; - - // Add a message to the job - let _ = db - .add_message_to_job_inbox(&job_id.clone(), &shinkai_message, parent_hash.clone(), None) - .await; - - // Add a step history - let result = format!("Result {}", i); - db.add_step_history( - job_id.clone(), - format!("Step {} Level {}", i, current_level), - None, - result.clone(), - None, - None, - ) - .unwrap(); - - // Add the result to the results vector - results.push(result); - - // Set job execution context - let mut execution_context = HashMap::new(); - execution_context.insert("context".to_string(), results.join(", ")); - db.set_job_execution_context(job_id.clone(), execution_context, None) - .unwrap(); - - // Update the parent message according to the tree structure - if i == 1 { - parent_message_hash = Some(shinkai_message.calculate_message_hash_for_pagination()); - } else if i == 2 { - parent_message_hash_2 = Some(shinkai_message.calculate_message_hash_for_pagination()); - } - } - - // Check if the job inbox is not empty after adding a message - assert!(!db.is_job_inbox_empty(&job_id).unwrap()); - - // Get the inbox name - let inbox_name = InboxName::get_job_inbox_name_from_params(job_id.clone()).unwrap(); - let inbox_name_value = match inbox_name { - InboxName::RegularInbox { value, .. } | InboxName::JobInbox { value, .. } => value, - }; - - // Get the messages from the job inbox - let last_messages_inbox = db - .get_last_messages_from_inbox(inbox_name_value.clone().to_string(), 4, None) - .unwrap(); - - // Check the content of the messages - assert_eq!(last_messages_inbox.len(), 3); - - // Check the content of the first message array - assert_eq!(last_messages_inbox[0].len(), 1); - let message_content_1 = last_messages_inbox[0][0].clone().get_message_content().unwrap(); - let job_message_1: JobMessage = serde_json::from_str(&message_content_1).unwrap(); - assert_eq!(job_message_1.content, "Hello World 1".to_string()); - - // Check the content of the second message array - assert_eq!(last_messages_inbox[1].len(), 2); - let message_content_2 = last_messages_inbox[1][0].clone().get_message_content().unwrap(); - let job_message_2: JobMessage = serde_json::from_str(&message_content_2).unwrap(); - assert_eq!(job_message_2.content, "Hello World 2".to_string()); - - let message_content_3 = last_messages_inbox[1][1].clone().get_message_content().unwrap(); - let job_message_3: JobMessage = serde_json::from_str(&message_content_3).unwrap(); - assert_eq!(job_message_3.content, "Hello World 3".to_string()); - - // Check the content of the third message array - assert_eq!(last_messages_inbox[2].len(), 1); - let message_content_4 = last_messages_inbox[2][0].clone().get_message_content().unwrap(); - let job_message_4: JobMessage = serde_json::from_str(&message_content_4).unwrap(); - assert_eq!(job_message_4.content, "Hello World 4".to_string()); - - // Check the step history and execution context - let job = db.get_job(&job_id.clone()).unwrap(); - eprintln!("job execution context: {:?}", job.execution_context); - - // Check the execution context - assert_eq!( - job.execution_context.get("context").unwrap(), - "Result 1, Result 2, Result 4" - ); - - // Check the step history - let step1 = &job.step_history[0]; - let step2 = &job.step_history[1]; - let step4 = &job.step_history[2]; - - assert_eq!( - step1.step_revisions[0].sub_prompts[0], - SubPrompt::Omni(User, "Step 1 Level 0".to_string(), vec![], 100) - ); - assert_eq!( - step1.step_revisions[0].sub_prompts[1], - SubPrompt::Omni(Assistant, "Result 1".to_string(), vec![], 100) - ); - - assert_eq!( - step2.step_revisions[0].sub_prompts[0], - SubPrompt::Omni(User, "Step 2 Level 1".to_string(), vec![], 100) - ); - assert_eq!( - step2.step_revisions[0].sub_prompts[1], - SubPrompt::Omni(Assistant, "Result 2".to_string(), vec![], 100) - ); - - assert_eq!( - step4.step_revisions[0].sub_prompts[0], - SubPrompt::Omni(User, "Step 4 Level 2".to_string(), vec![], 100) - ); - assert_eq!( - step4.step_revisions[0].sub_prompts[1], - SubPrompt::Omni(Assistant, "Result 4".to_string(), vec![], 100) - ); - } - - #[tokio::test] - async fn test_insert_steps_with_simple_tree_structure() { - let db = setup_test_db(); - - let node1_identity_name = "@@node1.shinkai"; - let node1_subidentity_name = "main_profile_node1"; - let (node1_identity_sk, _) = unsafe_deterministic_signature_keypair(0); - let (node1_encryption_sk, node1_encryption_pk) = unsafe_deterministic_encryption_keypair(0); - - let job_id = "test_job"; - let agent_id = "agent_test".to_string(); - let scope = JobScope::new_default(); - - create_new_job(&db, job_id.to_string(), agent_id.clone(), scope); - - eprintln!("Inserting steps...\n\n"); - let mut parent_message_hash: Option = None; - let mut parent_message_hash_2: Option = None; - - /* - The tree that we are creating looks like: - 1 - ├── 2 - │ └── 4 - └── 3 - */ - for i in 1..=4 { - let user_message = format!("User message {}", i); - let agent_response = format!("Agent response {}", i); - - // Generate the ShinkaiMessage - let message = generate_message_with_text( - format!("Hello World {}", i), - node1_encryption_sk.clone(), - clone_signature_secret_key(&node1_identity_sk), - node1_encryption_pk, - node1_subidentity_name.to_string(), - node1_identity_name.to_string(), - format!("2023-07-02T20:53:34.81{}Z", i), - ); - - eprintln!("Message: {:?}", message); - - let parent_hash: Option = match i { - 2 | 3 => parent_message_hash.clone(), - 4 => parent_message_hash_2.clone(), - _ => None, - }; - - // Insert the ShinkaiMessage into the database - db.unsafe_insert_inbox_message(&message, parent_hash.clone(), None) - .await - .unwrap(); - - db.add_step_history(job_id.to_string(), user_message, None, agent_response, None, None) - .unwrap(); - - // Update the parent message hash according to the tree structure - if i == 1 { - parent_message_hash = Some(message.calculate_message_hash_for_pagination()); - } else if i == 2 { - parent_message_hash_2 = Some(message.calculate_message_hash_for_pagination()); - } - } - - eprintln!("\n\n Getting messages..."); - let inbox_name = InboxName::get_job_inbox_name_from_params(job_id.to_string()).unwrap(); - let last_messages_inbox = db - .get_last_messages_from_inbox(inbox_name.to_string(), 3, None) - .unwrap(); - - let last_messages_content: Vec> = last_messages_inbox - .iter() - .map(|message_array| { - message_array - .iter() - .map(|message| message.clone().get_message_content().unwrap()) - .collect() - }) - .collect(); - - eprintln!("Messages: {:?}", last_messages_content); - - eprintln!("\n\n Getting steps..."); - - let step_history = db.get_step_history(job_id, true).unwrap().unwrap(); - - let step_history_content: Vec = step_history - .iter() - .map(|step| { - let user_message = match &step.step_revisions[0].sub_prompts[0] { - SubPrompt::Omni(_, text, _, _) => text, - _ => panic!("Unexpected SubPrompt variant"), - }; - let agent_response = match &step.step_revisions[0].sub_prompts[1] { - SubPrompt::Omni(_, text, _, _) => text, - _ => panic!("Unexpected SubPrompt variant"), - }; - format!("{} {}", user_message, agent_response) - }) - .collect(); - - eprintln!("Step history: {:?}", step_history_content); - - assert_eq!(step_history.len(), 3); - - // Check the content of the steps - assert_eq!( - format!( - "{} {}", - match &step_history[0].step_revisions[0].sub_prompts[0] { - SubPrompt::Omni(_, text, _, _) => text, - _ => panic!("Unexpected SubPrompt variant"), - }, - match &step_history[0].step_revisions[0].sub_prompts[1] { - SubPrompt::Omni(_, text, _, _) => text, - _ => panic!("Unexpected SubPrompt variant"), - } - ), - "User message 1 Agent response 1".to_string() - ); - assert_eq!( - format!( - "{} {}", - match &step_history[1].step_revisions[0].sub_prompts[0] { - SubPrompt::Omni(_, text, _, _) => text, - _ => panic!("Unexpected SubPrompt variant"), - }, - match &step_history[1].step_revisions[0].sub_prompts[1] { - SubPrompt::Omni(_, text, _, _) => text, - _ => panic!("Unexpected SubPrompt variant"), - } - ), - "User message 2 Agent response 2".to_string() - ); - assert_eq!( - format!( - "{} {}", - match &step_history[2].step_revisions[0].sub_prompts[0] { - SubPrompt::Omni(_, text, _, _) => text, - _ => panic!("Unexpected SubPrompt variant"), - }, - match &step_history[2].step_revisions[0].sub_prompts[1] { - SubPrompt::Omni(_, text, _, _) => text, - _ => panic!("Unexpected SubPrompt variant"), - } - ), - "User message 4 Agent response 4".to_string() - ); - } - #[tokio::test] async fn test_job_inbox_tree_structure_with_invalid_date() { let db = setup_test_db(); let job_id = "job_test".to_string(); let agent_id = "agent_test".to_string(); - let scope = JobScope::new_default(); + let scope = MinimalJobScope::default(); // Create a new job create_new_job(&db, job_id.clone(), agent_id.clone(), scope); @@ -1411,7 +836,7 @@ mod tests { let shinkai_message = ShinkaiMessageBuilder::job_message_from_llm_provider( job_id.clone(), format!("Hello World {}", i), - "".to_string(), + vec![], None, placeholder_signature_sk.clone(), "@@node1.shinkai".to_string(), @@ -1478,7 +903,7 @@ mod tests { let db = setup_test_db(); let job_id = "job1".to_string(); let agent_id = "agent1".to_string(); - let scope = JobScope::new_default(); + let scope = MinimalJobScope::default(); // Create a new job create_new_job(&db, job_id.clone(), agent_id.clone(), scope.clone()); @@ -1499,7 +924,7 @@ mod tests { let shinkai_message = ShinkaiMessageBuilder::job_message_from_llm_provider( job_id.clone(), format!("Hello World {}", i), - "".to_string(), + vec![], None, placeholder_signature_sk.clone(), "@@node1.shinkai".to_string(), @@ -1551,7 +976,7 @@ mod tests { .unwrap() .calculate_message_hash_for_pagination(); create_new_job(&db, forked_job1_id.clone(), agent_id.clone(), scope.clone()); - create_new_job(&db, forked_job2_id.clone(), agent_id.clone(), scope); + create_new_job(&db, forked_job2_id.clone(), agent_id.clone(), scope.clone()); let forked_job1 = ForkedJob { job_id: forked_job1_id.clone(), @@ -1585,11 +1010,11 @@ mod tests { let job1_id = "job1".to_string(); let job2_id = "job2".to_string(); let agent_id = "agent1".to_string(); - let scope = JobScope::new_default(); + let scope = MinimalJobScope::default(); // Create new jobs create_new_job(&db, job1_id.clone(), agent_id.clone(), scope.clone()); - create_new_job(&db, job2_id.clone(), agent_id.clone(), scope); + create_new_job(&db, job2_id.clone(), agent_id.clone(), scope.clone()); // Check smart_inboxes let node1_identity_name = "@@node1.shinkai"; @@ -1654,4 +1079,57 @@ mod tests { assert_eq!(smart_inboxes.len(), 1); assert!(smart_inboxes[0].inbox_id != inbox1_name.to_string()); } + + #[tokio::test] + async fn test_get_job_with_messages() { + let db = setup_test_db(); + let job_id = "job_with_messages".to_string(); + let agent_id = "agent_test".to_string(); + let scope = MinimalJobScope::default(); + + // Create a new job + db.create_new_job(job_id.clone(), agent_id.clone(), scope.clone(), false, None, None) + .unwrap(); + + let (placeholder_signature_sk, _) = unsafe_deterministic_signature_keypair(0); + + // Create and add messages to the job's inbox + let mut messages = Vec::new(); + for i in 1..=3 { + let shinkai_message = ShinkaiMessageBuilder::job_message_from_llm_provider( + job_id.clone(), + format!("Test Message {}", i), + vec![], + None, + placeholder_signature_sk.clone(), + "@@node1.shinkai".to_string(), + "@@node1.shinkai".to_string(), + ) + .unwrap(); + messages.push(shinkai_message.clone()); + + db.unsafe_insert_inbox_message(&shinkai_message, None, None) + .await + .unwrap(); + + // Add 50 ms delay + tokio::time::sleep(Duration::from_millis(50)).await; + } + + // Fetch the job with messages + let job = db.get_job_with_options(&job_id, true).unwrap(); + + // Verify that the messages are retrieved + assert_eq!(job.forked_jobs.len(), 0); // No forked jobs expected + + // Check the messages + let job_messages = job.step_history; + eprintln!("Job Mesages: {:?}", job_messages); + + assert_eq!(job_messages.len(), 3); + for (i, message) in job_messages.iter().enumerate() { + let message_content: JobMessage = serde_json::from_str(&message.get_message_content().unwrap()).unwrap(); + assert_eq!(message_content.content, format!("Test Message {}", i + 1)); + } + } } diff --git a/shinkai-libs/shinkai-sqlite/src/job_queue_manager.rs b/shinkai-libs/shinkai-sqlite/src/job_queue_manager.rs index 9c1252c62..6f6f4aaaa 100644 --- a/shinkai-libs/shinkai-sqlite/src/job_queue_manager.rs +++ b/shinkai-libs/shinkai-sqlite/src/job_queue_manager.rs @@ -18,7 +18,7 @@ impl SqliteManager { }; let serialized_queue = - bincode::serialize(queue).map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?; + serde_json::to_string(queue).map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?; let conn = self.get_connection()?; conn.execute( @@ -45,8 +45,8 @@ impl SqliteManager { let rows = stmt.query_map(params![], |row| { let mut job_id: String = row.get(0)?; - let serialized_queue: Vec = row.get(1)?; - let queue: Vec = bincode::deserialize(&serialized_queue).map_err(|e| { + let serialized_queue: String = row.get(1)?; + let queue: Vec = serde_json::from_str(&serialized_queue).map_err(|e| { rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) })?; diff --git a/shinkai-libs/shinkai-sqlite/src/keys_manager.rs b/shinkai-libs/shinkai-sqlite/src/keys_manager.rs index 7dfb28dba..01dfed18a 100644 --- a/shinkai-libs/shinkai-sqlite/src/keys_manager.rs +++ b/shinkai-libs/shinkai-sqlite/src/keys_manager.rs @@ -33,7 +33,7 @@ impl SqliteManager { #[cfg(test)] mod tests { use super::*; - use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; + use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use std::path::PathBuf; use tempfile::NamedTempFile; diff --git a/shinkai-libs/shinkai-sqlite/src/lib.rs b/shinkai-libs/shinkai-sqlite/src/lib.rs index 65e5fc605..6b4fa861b 100644 --- a/shinkai-libs/shinkai-sqlite/src/lib.rs +++ b/shinkai-libs/shinkai-sqlite/src/lib.rs @@ -3,7 +3,7 @@ use errors::SqliteManagerError; use r2d2::Pool; use r2d2_sqlite::SqliteConnectionManager; use rusqlite::{ffi::sqlite3_auto_extension, Result, Row, ToSql}; -use shinkai_vector_resources::model_type::EmbeddingModelType; +use shinkai_embedding::model_type::EmbeddingModelType; use sqlite_vec::sqlite3_vec_init; use std::path::Path; use std::sync::Arc; @@ -14,6 +14,7 @@ pub mod cron_task_manager; pub mod embedding_function; pub mod errors; pub mod file_inbox_manager; +pub mod file_system; pub mod files; pub mod identity_manager; pub mod identity_registration; @@ -33,8 +34,6 @@ pub mod shinkai_tool_manager; pub mod source_file_manager; pub mod tool_payment_req_manager; pub mod tool_playground; -pub mod vector_fs_manager; -pub mod vector_resource_manager; pub mod wallet_manager; // Updated struct to manage SQLite connections using a connection pool @@ -144,6 +143,7 @@ impl SqliteManager { Self::initialize_cron_task_executions_table(conn)?; Self::initialize_device_identities_table(conn)?; Self::initialize_standard_identities_table(conn)?; + // TODO: remove this Self::initialize_file_inboxes_table(conn)?; Self::initialize_inboxes_table(conn)?; Self::initialize_inbox_messages_table(conn)?; @@ -163,19 +163,13 @@ impl SqliteManager { Self::initialize_retry_messages_table(conn)?; Self::initialize_settings_table(conn)?; Self::initialize_sheets_table(conn)?; - Self::initialize_source_file_maps_table(conn)?; - Self::initialize_step_history_table(conn)?; Self::initialize_tools_table(conn)?; Self::initialize_tool_micropayments_requirements_table(conn)?; Self::initialize_tool_playground_table(conn)?; Self::initialize_tool_playground_code_history_table(conn)?; - Self::initialize_vector_fs_internals_table(conn)?; - Self::initialize_vector_resources_table(conn)?; - Self::initialize_vector_resource_embeddings_tables(conn)?; - Self::initialize_vector_resource_nodes_table(conn)?; - Self::initialize_vector_resource_headers_table(conn)?; Self::initialize_version_table(conn)?; Self::initialize_wallets_table(conn)?; + Self::initialize_filesystem_tables(conn)?; Self::initialize_oauth_table(conn)?; // Vector tables Self::initialize_tools_vector_table(conn)?; @@ -202,7 +196,8 @@ impl SqliteManager { storage_path TEXT NOT NULL, tools TEXT NOT NULL, debug_mode INTEGER NOT NULL, - config TEXT -- Store as a JSON string + config TEXT, -- Store as a JSON string + scope TEXT NOT NULL -- Change this line to use TEXT instead of BLOB );", [], )?; @@ -325,25 +320,10 @@ impl SqliteManager { datetime_created TEXT NOT NULL, is_finished INTEGER NOT NULL, parent_agent_or_llm_provider_id TEXT NOT NULL, - scope BLOB NOT NULL, - scope_with_files BLOB, + scope TEXT NOT NULL, conversation_inbox_name TEXT NOT NULL, - execution_context BLOB, - associated_ui BLOB, - config BLOB - );", - [], - )?; - - Ok(()) - } - - fn initialize_step_history_table(conn: &rusqlite::Connection) -> Result<()> { - conn.execute( - "CREATE TABLE IF NOT EXISTS step_history ( - message_key TEXT NOT NULL, - job_id TEXT NOT NULL, - job_step_result BLOB NOT NULL + associated_ui TEXT, + config TEXT );", [], )?; @@ -368,7 +348,7 @@ impl SqliteManager { conn.execute( "CREATE TABLE IF NOT EXISTS job_queues ( job_id TEXT NOT NULL, - queue_data BLOB NOT NULL + queue_data TEXT NOT NULL );", [], )?; @@ -798,181 +778,34 @@ impl SqliteManager { Ok(()) } - fn initialize_source_file_maps_table(conn: &rusqlite::Connection) -> Result<()> { - conn.execute( - "CREATE TABLE IF NOT EXISTS source_file_maps ( - profile_name TEXT NOT NULL, - vector_resource_id TEXT NOT NULL, - vr_path TEXT NOT NULL, - source_file_type TEXT NOT NULL, - file_name TEXT NOT NULL, - file_type TEXT NOT NULL, - distribution_info BLOB - );", - [], - )?; - - // Create an index for the profile_name column - conn.execute( - "CREATE INDEX IF NOT EXISTS idx_source_file_maps_profile_name ON source_file_maps (profile_name);", - [], - )?; - - // Create an index for the vector_resource_id column - conn.execute( - "CREATE INDEX IF NOT EXISTS idx_source_file_maps_vector_resource_id ON source_file_maps (vector_resource_id);", - [], - )?; - - Ok(()) - } - - fn initialize_vector_fs_internals_table(conn: &rusqlite::Connection) -> Result<()> { - conn.execute( - "CREATE TABLE IF NOT EXISTS vector_fs_internals ( - profile_name TEXT NOT NULL UNIQUE, - core_resource_id TEXT NOT NULL, - permissions_index BLOB NOT NULL, - subscription_index BLOB NOT NULL, - supported_embedding_models BLOB NOT NULL, - last_read_index BLOB NOT NULL - );", - [], - )?; - - Ok(()) - } - - fn initialize_vector_resources_table(conn: &rusqlite::Connection) -> Result<()> { - conn.execute( - "CREATE TABLE IF NOT EXISTS vector_resources ( - profile_name TEXT NOT NULL, - vector_resource_id TEXT NOT NULL UNIQUE, - name TEXT NOT NULL, - description TEXT, - source TEXT NOT NULL, - resource_id TEXT NOT NULL, - resource_base_type TEXT NOT NULL, - embedding_model_used_string TEXT NOT NULL, - node_count INTEGER NOT NULL, - data_tag_index BLOB NOT NULL, - created_datetime TEXT NOT NULL, - last_written_datetime TEXT NOT NULL, - metadata_index BLOB NOT NULL, - merkle_root TEXT, - keywords BLOB NOT NULL, - distribution_info BLOB NOT NULL - );", - [], - )?; - - // Create an index for the profile_name column - conn.execute( - "CREATE INDEX IF NOT EXISTS idx_vector_resources_profile_name ON vector_resources (profile_name);", - [], - )?; - - // Create an index for the vector_resource_id column - conn.execute( - "CREATE INDEX IF NOT EXISTS idx_vector_resources_vector_resource_id ON vector_resources (vector_resource_id);", - [], - )?; + // fn initialize_source_file_maps_table(conn: &rusqlite::Connection) -> Result<()> { + // conn.execute( + // "CREATE TABLE IF NOT EXISTS source_file_maps ( + // profile_name TEXT NOT NULL, + // vector_resource_id TEXT NOT NULL, + // vr_path TEXT NOT NULL, + // source_file_type TEXT NOT NULL, + // file_name TEXT NOT NULL, + // file_type TEXT NOT NULL, + // distribution_info BLOB + // );", + // [], + // )?; + + // // Create an index for the profile_name column + // conn.execute( + // "CREATE INDEX IF NOT EXISTS idx_source_file_maps_profile_name ON source_file_maps (profile_name);", + // [], + // )?; + + // // Create an index for the vector_resource_id column + // conn.execute( + // "CREATE INDEX IF NOT EXISTS idx_source_file_maps_vector_resource_id ON source_file_maps (vector_resource_id);", + // [], + // )?; - Ok(()) - } - - fn initialize_vector_resource_embeddings_tables(conn: &rusqlite::Connection) -> Result<()> { - conn.execute( - "CREATE VIRTUAL TABLE IF NOT EXISTS vector_resource_embeddings_384 USING vec0 ( - profile_name text, - vector_resource_id text partition key, - is_resource_embedding integer, - id text, - embedding float[384] - );", - [], - )?; - - conn.execute( - "CREATE VIRTUAL TABLE IF NOT EXISTS vector_resource_embeddings_768 USING vec0 ( - profile_name text, - vector_resource_id text partition key, - is_resource_embedding integer, - id text, - embedding float[768] - );", - [], - )?; - - Ok(()) - } - - fn initialize_vector_resource_nodes_table(conn: &rusqlite::Connection) -> Result<()> { - conn.execute( - "CREATE TABLE IF NOT EXISTS vector_resource_nodes ( - profile_name TEXT NOT NULL, - vector_resource_id TEXT NOT NULL, - id TEXT NOT NULL, - content_type TEXT NOT NULL, - content_value TEXT NOT NULL, - metadata TEXT, - data_tag_names TEXT NOT NULL, - last_written_datetime TEXT NOT NULL, - merkle_hash TEXT - );", - [], - )?; - - // Create an index for the profile_name column - conn.execute( - "CREATE INDEX IF NOT EXISTS idx_vector_resource_nodes_profile_name ON vector_resource_nodes (profile_name);", - [], - )?; - - // Create an index for the vector_resource_id column - conn.execute( - "CREATE INDEX IF NOT EXISTS idx_vector_resource_nodes_vector_resource_id ON vector_resource_nodes (vector_resource_id);", - [], - )?; - - Ok(()) - } - - fn initialize_vector_resource_headers_table(conn: &rusqlite::Connection) -> Result<()> { - conn.execute( - "CREATE TABLE IF NOT EXISTS vector_resource_headers ( - profile_name TEXT NOT NULL, - vector_resource_id TEXT NOT NULL UNIQUE, - resource_name TEXT NOT NULL, - resource_id TEXT NOT NULL, - resource_base_type TEXT NOT NULL, - resource_source TEXT NOT NULL, - resource_created_datetime TEXT NOT NULL, - resource_last_written_datetime TEXT NOT NULL, - resource_embedding_model_used TEXT NOT NULL, - resource_merkle_root TEXT, - resource_keywords BLOB NOT NULL, - resource_distribution_info BLOB NOT NULL, - data_tag_names TEXT NOT NULL, - metadata_index_keys TEXT NOT NULL - );", - [], - )?; - - // Create an index for the profile_name column - conn.execute( - "CREATE INDEX IF NOT EXISTS idx_vector_resource_headers_profile_name ON vector_resource_headers (profile_name);", - [], - )?; - - // Create an index for the vector_resource_id column - conn.execute( - "CREATE INDEX IF NOT EXISTS idx_vector_resource_headers_vector_resource_id ON vector_resource_headers (vector_resource_id);", - [], - )?; - - Ok(()) - } + // Ok(()) + // } // New method to initialize the embedding model type table fn initialize_embedding_model_type_table(conn: &rusqlite::Connection) -> Result<()> { @@ -1056,7 +889,7 @@ impl SqliteManager { // Method to set the version and determine if a global reset is needed pub fn set_version(&self, version: &str) -> Result<()> { // Note: add breaking versions here as needed - let breaking_versions = ["0.9.0", "0.9.1", "0.9.2", "0.9.3"]; + let breaking_versions = ["0.9.0", "0.9.1", "0.9.2", "0.9.3", "0.9.4"]; let needs_global_reset = self.get_version().map_or(false, |(current_version, _)| { breaking_versions @@ -1092,10 +925,10 @@ impl SqliteManager { #[cfg(test)] mod tests { use super::*; - use shinkai_vector_resources::model_type::OllamaTextEmbeddingsInference; use std::path::PathBuf; use std::sync::{Arc, RwLock}; use std::thread; + use shinkai_embedding::model_type::OllamaTextEmbeddingsInference; use std::time::{Duration, Instant}; use tempfile::NamedTempFile; diff --git a/shinkai-libs/shinkai-sqlite/src/llm_provider_manager.rs b/shinkai-libs/shinkai-sqlite/src/llm_provider_manager.rs index 23996c05c..7c6b3856c 100644 --- a/shinkai-libs/shinkai-sqlite/src/llm_provider_manager.rs +++ b/shinkai-libs/shinkai-sqlite/src/llm_provider_manager.rs @@ -235,7 +235,7 @@ mod tests { llm_providers::serialized_llm_provider::{LLMProviderInterface, OpenAI}, shinkai_name::ShinkaiName, }; - use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; + use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use std::path::PathBuf; use tempfile::NamedTempFile; diff --git a/shinkai-libs/shinkai-sqlite/src/oauth_manager.rs b/shinkai-libs/shinkai-sqlite/src/oauth_manager.rs index 5143f0d70..5c90be2fd 100644 --- a/shinkai-libs/shinkai-sqlite/src/oauth_manager.rs +++ b/shinkai-libs/shinkai-sqlite/src/oauth_manager.rs @@ -302,7 +302,7 @@ impl SqliteManager { #[cfg(test)] mod tests { use super::*; - use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; + use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use std::path::PathBuf; use tempfile::NamedTempFile; diff --git a/shinkai-libs/shinkai-sqlite/src/prompt_manager.rs b/shinkai-libs/shinkai-sqlite/src/prompt_manager.rs index 8135a0d17..5ac8e80b8 100644 --- a/shinkai-libs/shinkai-sqlite/src/prompt_manager.rs +++ b/shinkai-libs/shinkai-sqlite/src/prompt_manager.rs @@ -447,7 +447,7 @@ mod tests { use super::*; use serde_json::Value; - use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; + use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use std::path::PathBuf; use tempfile::NamedTempFile; diff --git a/shinkai-libs/shinkai-sqlite/src/settings_manager.rs b/shinkai-libs/shinkai-sqlite/src/settings_manager.rs index a6c45eff8..b5868a954 100644 --- a/shinkai-libs/shinkai-sqlite/src/settings_manager.rs +++ b/shinkai-libs/shinkai-sqlite/src/settings_manager.rs @@ -1,4 +1,4 @@ -use shinkai_vector_resources::model_type::EmbeddingModelType; +use shinkai_embedding::model_type::EmbeddingModelType; use crate::{SqliteManager, SqliteManagerError}; @@ -63,7 +63,7 @@ impl SqliteManager { #[cfg(test)] mod tests { use super::*; - use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; + use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use std::path::PathBuf; use tempfile::NamedTempFile; diff --git a/shinkai-libs/shinkai-sqlite/src/sheet_manager.rs b/shinkai-libs/shinkai-sqlite/src/sheet_manager.rs index b4a6a6afb..40953ee0f 100644 --- a/shinkai-libs/shinkai-sqlite/src/sheet_manager.rs +++ b/shinkai-libs/shinkai-sqlite/src/sheet_manager.rs @@ -78,7 +78,7 @@ impl SqliteManager { #[cfg(test)] mod tests { use super::*; - use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; + use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use std::path::PathBuf; use tempfile::NamedTempFile; diff --git a/shinkai-libs/shinkai-sqlite/src/shinkai_tool_manager.rs b/shinkai-libs/shinkai-sqlite/src/shinkai_tool_manager.rs index f27e2676c..f935df4bd 100644 --- a/shinkai-libs/shinkai-sqlite/src/shinkai_tool_manager.rs +++ b/shinkai-libs/shinkai-sqlite/src/shinkai_tool_manager.rs @@ -4,7 +4,6 @@ use keyphrases::KeyPhraseExtractor; use rusqlite::{params, Result}; use shinkai_message_primitives::schemas::indexable_version::IndexableVersion; use shinkai_tools_primitives::tools::shinkai_tool::{ShinkaiTool, ShinkaiToolHeader}; -use shinkai_vector_resources::embeddings::Embedding; use std::collections::HashSet; impl SqliteManager { @@ -12,7 +11,7 @@ impl SqliteManager { pub async fn add_tool(&self, tool: ShinkaiTool) -> Result { // Generate or retrieve the embedding let embedding = match tool.get_embedding() { - Some(embedding) => embedding.vector, + Some(embedding) => embedding, None => self.generate_embeddings(&tool.format_embedding_string()).await?, }; @@ -47,7 +46,7 @@ impl SqliteManager { // Clone the tool to make it mutable let mut tool_clone = tool.clone(); - tool_clone.set_embedding(Embedding::new("", embedding.clone())); + tool_clone.set_embedding(embedding.clone()); // Determine if the tool can be enabled let is_enabled = tool_clone.is_enabled() && tool_clone.can_be_enabled(); @@ -376,7 +375,7 @@ impl SqliteManager { pub async fn update_tool(&self, tool: ShinkaiTool) -> Result { // Generate or retrieve the embedding let embedding = match tool.get_embedding() { - Some(embedding) => embedding.vector, + Some(embedding) => embedding, None => self.generate_embeddings(&tool.format_embedding_string()).await?, }; @@ -490,20 +489,27 @@ impl SqliteManager { } /// Checks if a tool exists in the shinkai_tools table by its tool_key - pub fn tool_exists(&self, tool_key: &str) -> Result { + pub fn tool_exists(&self, tool_key: &str, version: Option) -> Result { let conn = self.get_connection()?; - let exists: bool = conn - .query_row( + let exists = match version { + Some(version) => conn.query_row( + "SELECT EXISTS(SELECT 1 FROM shinkai_tools WHERE tool_key = ?1 AND version = ?2)", + params![tool_key.to_lowercase(), version.get_version_number()], + |row| row.get(0), + ), + None => conn.query_row( "SELECT EXISTS(SELECT 1 FROM shinkai_tools WHERE tool_key = ?1)", params![tool_key.to_lowercase()], |row| row.get(0), - ) - .map_err(|e| { + ), + }; + match exists { + Ok(exists) => Ok(exists), + Err(e) => { eprintln!("Database error: {}", e); - SqliteManagerError::DatabaseError(e) - })?; - - Ok(exists) + Err(SqliteManagerError::DatabaseError(e)) + } + } } /// Checks if there are any JS tools in the shinkai_tools table @@ -511,7 +517,7 @@ impl SqliteManager { let conn = self.get_connection()?; let exists: bool = conn .query_row( - "SELECT EXISTS(SELECT 1 FROM shinkai_tools WHERE tool_type = 'JS')", + "SELECT EXISTS(SELECT 1 FROM shinkai_tools WHERE tool_type = 'Deno')", [], |row| row.get(0), ) @@ -769,6 +775,8 @@ impl SqliteManager { #[cfg(test)] mod tests { use super::*; + use shinkai_embedding::model_type::EmbeddingModelType; + use shinkai_embedding::model_type::OllamaTextEmbeddingsInference; use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; use shinkai_message_primitives::schemas::shinkai_tool_offering::AssetPayment; use shinkai_message_primitives::schemas::shinkai_tool_offering::ToolPrice; @@ -780,8 +788,6 @@ mod tests { use shinkai_tools_primitives::tools::network_tool::NetworkTool; use shinkai_tools_primitives::tools::parameters::Parameters; use shinkai_tools_primitives::tools::tool_output_arg::ToolOutputArg; - use shinkai_vector_resources::embeddings::Embedding; - use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use std::path::PathBuf; use tempfile::NamedTempFile; @@ -1067,7 +1073,7 @@ mod tests { let mut updated_tool_2 = shinkai_tool_2.clone(); if let ShinkaiTool::Deno(ref mut deno_tool, _) = updated_tool_2 { deno_tool.description = "Updated second Deno tool".to_string(); - deno_tool.embedding = Some(Embedding::new("test", SqliteManager::generate_vector_for_testing(0.21))); + deno_tool.embedding = Some(SqliteManager::generate_vector_for_testing(0.21)); } eprintln!("Updating tool: {:?}", updated_tool_2); diff --git a/shinkai-libs/shinkai-sqlite/src/source_file_manager.rs b/shinkai-libs/shinkai-sqlite/src/source_file_manager.rs index 2a419cb21..284f8358c 100644 --- a/shinkai-libs/shinkai-sqlite/src/source_file_manager.rs +++ b/shinkai-libs/shinkai-sqlite/src/source_file_manager.rs @@ -1,210 +1,206 @@ -use rusqlite::params; -use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; -use shinkai_vector_resources::{ - source::{DistributionInfo, SourceFile, SourceFileMap, StandardSourceFile, TLSNotarizedSourceFile, TLSNotaryProof}, - vector_resource::VRPath, -}; - -use crate::{errors::SqliteManagerError, SqliteManager}; - -impl SqliteManager { - pub fn save_source_file_map( - &self, - source_file_map: &SourceFileMap, - resource_id: &str, - profile: &ShinkaiName, - ) -> Result<(), SqliteManagerError> { - let profile_name = profile - .get_profile_name_string() - .ok_or(SqliteManagerError::InvalidIdentityName(profile.to_string()))?; - let source_files_dir = Self::get_source_files_path().join(Self::get_root_directory_name(resource_id)); - - let mut conn = self.get_connection()?; - let tx = conn.transaction()?; - - // Store the source file contents in the source files directory - for (path, source_file) in &source_file_map.map { - let file_dir = source_files_dir.join(path.path_ids.join("/")); - std::fs::create_dir_all(&file_dir).map_err(|_| SqliteManagerError::FailedFetchingValue)?; - - match source_file { - SourceFile::Standard(sf) => { - let file_path = file_dir.join(sf.file_name.clone()); - std::fs::write(file_path, sf.file_content.clone()) - .map_err(|_| SqliteManagerError::FailedFetchingValue)?; - - // Store the source file metadata in the database - tx.execute( - "INSERT OR REPLACE INTO source_file_maps - (profile_name, vector_resource_id, vr_path, source_file_type, file_name, file_type, distribution_info) - VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)", - params![ - profile_name, - resource_id, - path.format_to_string(), - "standard", - sf.file_name.clone(), - serde_json::to_string(&sf.file_type).map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, - serde_json::to_vec(&sf.distribution_info).map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, - ], - )?; - } - SourceFile::TLSNotarized(sf) => { - let file_path = file_dir.join(sf.file_name.clone()); - std::fs::write(file_path, sf.file_content.clone()) - .map_err(|_| SqliteManagerError::FailedFetchingValue)?; - - // Store the source file metadata in the database - tx.execute( - "INSERT OR REPLACE INTO source_file_maps - (profile_name, vector_resource_id, vr_path, source_file_type, file_name, file_type, distribution_info) - VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)", - params![ - profile_name, - resource_id, - path.format_to_string(), - "tls_notarized", - sf.file_name.clone(), - serde_json::to_string(&sf.file_type).map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, - serde_json::to_vec(&sf.distribution_info).map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, - ], - )?; - } - }; - } - - tx.commit()?; - Ok(()) - } - - pub fn get_source_file_map( - &self, - resource_id: &str, - profile: &ShinkaiName, - ) -> Result { - let profile_name = profile - .get_profile_name_string() - .ok_or(SqliteManagerError::InvalidIdentityName(profile.to_string()))?; - let source_files_dir = Self::get_source_files_path().join(Self::get_root_directory_name(resource_id)); - - let conn = self.get_connection()?; - let mut stmt = conn.prepare( - "SELECT vr_path, source_file_type, file_name, file_type, distribution_info - FROM source_file_maps WHERE profile_name = ?1 AND vector_resource_id = ?2", - )?; - let source_files_iter = stmt.query_map(params![profile_name, resource_id], |row| { - let vr_path: String = row.get(0)?; - let source_file_type: String = row.get(1)?; - let file_name: String = row.get(2)?; - let file_type: String = row.get(3)?; - let distribution_info: Option> = row.get(4)?; - - let vr_path = VRPath::from_string(&vr_path) - .map_err(|e| rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::VRError(e))))?; - let file_dir = vr_path.path_ids.join("/"); - let file_path = source_files_dir.join(file_dir).join(&file_name); - - let file_type = serde_json::from_str(&file_type).map_err(|e| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) - })?; - let distribution_info = serde_json::from_slice(&distribution_info.unwrap_or_default()).map_err(|e| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) - })?; - - let source_file = match source_file_type.as_str() { - "standard" => SourceFile::Standard(StandardSourceFile { - file_name: file_name, - file_content: std::fs::read(file_path).map_err(|_| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::FailedFetchingValue)) - })?, - file_type, - distribution_info, - }), - "tls_notarized" => SourceFile::TLSNotarized(TLSNotarizedSourceFile { - file_name: file_name, - file_content: std::fs::read(file_path).map_err(|_| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::FailedFetchingValue)) - })?, - file_type, - distribution_info, - proof: TLSNotaryProof::new(), - }), - _ => { - return Err(rusqlite::Error::ToSqlConversionFailure(Box::new( - SqliteManagerError::SerializationError(format!( - "Invalid source file type: {}", - source_file_type - )), - ))) - } - }; - - Ok((vr_path, source_file)) - })?; - - let mut source_file_map = SourceFileMap::new(Default::default()); - for source_file in source_files_iter { - let (vr_path, source_file) = source_file?; - source_file_map.add_source_file(vr_path, source_file); - } - - Ok(source_file_map) - } - - fn get_source_files_path() -> std::path::PathBuf { - match std::env::var("NODE_STORAGE_PATH").ok() { - Some(path) => std::path::PathBuf::from(path).join("files"), - None => std::path::PathBuf::from("files"), - } - } - - fn get_root_directory_name(name: &str) -> String { - let sanitized_dir = name.replace(|c: char| !c.is_ascii_alphanumeric(), "_"); - format!("source_{}", sanitized_dir) - } -} - -#[cfg(test)] -mod tests { - use super::*; - use shinkai_vector_resources::{ - model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}, - source::{DocumentFileType, SourceFileType}, - }; - use std::path::PathBuf; - use tempfile::NamedTempFile; - - fn setup_test_db() -> SqliteManager { - let temp_file = NamedTempFile::new().unwrap(); - let db_path = PathBuf::from(temp_file.path()); - let api_url = String::new(); - let model_type = - EmbeddingModelType::OllamaTextEmbeddingsInference(OllamaTextEmbeddingsInference::SnowflakeArcticEmbed_M); - - std::env::set_var("NODE_STORAGE_PATH", db_path.parent().unwrap()); - - SqliteManager::new(db_path, api_url, model_type).unwrap() - } - - #[test] - fn test_save_source_file_map() { - let db = setup_test_db(); - let profile = ShinkaiName::new("@@test_user.shinkai/main".to_string()).unwrap(); - let resource_id = "test_resource"; - let mut source_file_map = SourceFileMap::new(Default::default()); - let vr_path = VRPath::new(); - let source_file = SourceFile::Standard(StandardSourceFile { - file_name: "test_file.txt".to_string(), - file_content: b"test_content".to_vec(), - file_type: SourceFileType::Document(DocumentFileType::Txt), - distribution_info: None, - }); - source_file_map.add_source_file(vr_path, source_file); - - db.save_source_file_map(&source_file_map, resource_id, &profile) - .unwrap(); - - let saved_source_file_map = db.get_source_file_map(resource_id, &profile).unwrap(); - assert_eq!(source_file_map, saved_source_file_map); - } -} +// use rusqlite::params; +// use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; + +// use crate::{errors::SqliteManagerError, SqliteManager}; + +// impl SqliteManager { +// pub fn save_source_file_map( +// &self, +// source_file_map: &SourceFileMap, +// resource_id: &str, +// profile: &ShinkaiName, +// ) -> Result<(), SqliteManagerError> { +// let profile_name = profile +// .get_profile_name_string() +// .ok_or(SqliteManagerError::InvalidIdentityName(profile.to_string()))?; +// let source_files_dir = Self::get_source_files_path().join(Self::get_root_directory_name(resource_id)); + +// let mut conn = self.get_connection()?; +// let tx = conn.transaction()?; + +// // Store the source file contents in the source files directory +// for (path, source_file) in &source_file_map.map { +// let file_dir = source_files_dir.join(path.path_ids.join("/")); +// std::fs::create_dir_all(&file_dir).map_err(|_| SqliteManagerError::FailedFetchingValue)?; + +// match source_file { +// SourceFile::Standard(sf) => { +// let file_path = file_dir.join(sf.file_name.clone()); +// std::fs::write(file_path, sf.file_content.clone()) +// .map_err(|_| SqliteManagerError::FailedFetchingValue)?; + +// // Store the source file metadata in the database +// tx.execute( +// "INSERT OR REPLACE INTO source_file_maps +// (profile_name, vector_resource_id, vr_path, source_file_type, file_name, file_type, distribution_info) +// VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)", +// params![ +// profile_name, +// resource_id, +// path.format_to_string(), +// "standard", +// sf.file_name.clone(), +// serde_json::to_string(&sf.file_type).map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, +// serde_json::to_vec(&sf.distribution_info).map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, +// ], +// )?; +// } +// SourceFile::TLSNotarized(sf) => { +// let file_path = file_dir.join(sf.file_name.clone()); +// std::fs::write(file_path, sf.file_content.clone()) +// .map_err(|_| SqliteManagerError::FailedFetchingValue)?; + +// // Store the source file metadata in the database +// tx.execute( +// "INSERT OR REPLACE INTO source_file_maps +// (profile_name, vector_resource_id, vr_path, source_file_type, file_name, file_type, distribution_info) +// VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)", +// params![ +// profile_name, +// resource_id, +// path.format_to_string(), +// "tls_notarized", +// sf.file_name.clone(), +// serde_json::to_string(&sf.file_type).map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, +// serde_json::to_vec(&sf.distribution_info).map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, +// ], +// )?; +// } +// }; +// } + +// tx.commit()?; +// Ok(()) +// } + +// pub fn get_source_file_map( +// &self, +// resource_id: &str, +// profile: &ShinkaiName, +// ) -> Result { +// let profile_name = profile +// .get_profile_name_string() +// .ok_or(SqliteManagerError::InvalidIdentityName(profile.to_string()))?; +// let source_files_dir = Self::get_source_files_path().join(Self::get_root_directory_name(resource_id)); + +// let conn = self.get_connection()?; +// let mut stmt = conn.prepare( +// "SELECT vr_path, source_file_type, file_name, file_type, distribution_info +// FROM source_file_maps WHERE profile_name = ?1 AND vector_resource_id = ?2", +// )?; +// let source_files_iter = stmt.query_map(params![profile_name, resource_id], |row| { +// let vr_path: String = row.get(0)?; +// let source_file_type: String = row.get(1)?; +// let file_name: String = row.get(2)?; +// let file_type: String = row.get(3)?; +// let distribution_info: Option> = row.get(4)?; + +// let vr_path = ShinkaiPath::from_string(&vr_path) +// .map_err(|e| rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::VRError(e))))?; +// let file_dir = vr_path.path_ids.join("/"); +// let file_path = source_files_dir.join(file_dir).join(&file_name); + +// let file_type = serde_json::from_str(&file_type).map_err(|e| { +// rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) +// })?; +// let distribution_info = serde_json::from_slice(&distribution_info.unwrap_or_default()).map_err(|e| { +// rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) +// })?; + +// let source_file = match source_file_type.as_str() { +// "standard" => SourceFile::Standard(StandardSourceFile { +// file_name: file_name, +// file_content: std::fs::read(file_path).map_err(|_| { +// rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::FailedFetchingValue)) +// })?, +// file_type, +// distribution_info, +// }), +// "tls_notarized" => SourceFile::TLSNotarized(TLSNotarizedSourceFile { +// file_name: file_name, +// file_content: std::fs::read(file_path).map_err(|_| { +// rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::FailedFetchingValue)) +// })?, +// file_type, +// distribution_info, +// proof: TLSNotaryProof::new(), +// }), +// _ => { +// return Err(rusqlite::Error::ToSqlConversionFailure(Box::new( +// SqliteManagerError::SerializationError(format!( +// "Invalid source file type: {}", +// source_file_type +// )), +// ))) +// } +// }; + +// Ok((vr_path, source_file)) +// })?; + +// let mut source_file_map = SourceFileMap::new(Default::default()); +// for source_file in source_files_iter { +// let (vr_path, source_file) = source_file?; +// source_file_map.add_source_file(vr_path, source_file); +// } + +// Ok(source_file_map) +// } + +// fn get_source_files_path() -> std::path::PathBuf { +// match std::env::var("NODE_STORAGE_PATH").ok() { +// Some(path) => std::path::PathBuf::from(path).join("files"), +// None => std::path::PathBuf::from("files"), +// } +// } + +// fn get_root_directory_name(name: &str) -> String { +// let sanitized_dir = name.replace(|c: char| !c.is_ascii_alphanumeric(), "_"); +// format!("source_{}", sanitized_dir) +// } +// } + +// #[cfg(test)] +// mod tests { +// use super::*; +// use shinkai_vector_resources::{ +// model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}, +// source::{DocumentFileType, SourceFileType}, +// }; +// use std::path::PathBuf; +// use tempfile::NamedTempFile; + +// fn setup_test_db() -> SqliteManager { +// let temp_file = NamedTempFile::new().unwrap(); +// let db_path = PathBuf::from(temp_file.path()); +// let api_url = String::new(); +// let model_type = +// EmbeddingModelType::OllamaTextEmbeddingsInference(OllamaTextEmbeddingsInference::SnowflakeArcticEmbed_M); + +// std::env::set_var("NODE_STORAGE_PATH", db_path.parent().unwrap()); + +// SqliteManager::new(db_path, api_url, model_type).unwrap() +// } + +// #[test] +// fn test_save_source_file_map() { +// let db = setup_test_db(); +// let profile = ShinkaiName::new("@@test_user.shinkai/main".to_string()).unwrap(); +// let resource_id = "test_resource"; +// let mut source_file_map = SourceFileMap::new(Default::default()); +// let vr_path = VRPath::new(); +// let source_file = SourceFile::Standard(StandardSourceFile { +// file_name: "test_file.txt".to_string(), +// file_content: b"test_content".to_vec(), +// file_type: SourceFileType::Document(DocumentFileType::Txt), +// distribution_info: None, +// }); +// source_file_map.add_source_file(vr_path, source_file); + +// db.save_source_file_map(&source_file_map, resource_id, &profile) +// .unwrap(); + +// let saved_source_file_map = db.get_source_file_map(resource_id, &profile).unwrap(); +// assert_eq!(source_file_map, saved_source_file_map); +// } +// } diff --git a/shinkai-libs/shinkai-sqlite/src/tool_payment_req_manager.rs b/shinkai-libs/shinkai-sqlite/src/tool_payment_req_manager.rs index 0f0580298..de4ead08b 100644 --- a/shinkai-libs/shinkai-sqlite/src/tool_payment_req_manager.rs +++ b/shinkai-libs/shinkai-sqlite/src/tool_payment_req_manager.rs @@ -102,7 +102,7 @@ mod tests { shinkai_tool_offering::{AssetPayment, ToolPrice}, wallet_mixed::{Asset, NetworkIdentifier}, }; - use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; + use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use std::path::PathBuf; use tempfile::NamedTempFile; diff --git a/shinkai-libs/shinkai-sqlite/src/tool_playground.rs b/shinkai-libs/shinkai-sqlite/src/tool_playground.rs index 933ee03b3..4c537acfc 100644 --- a/shinkai-libs/shinkai-sqlite/src/tool_playground.rs +++ b/shinkai-libs/shinkai-sqlite/src/tool_playground.rs @@ -165,9 +165,11 @@ impl SqliteManager { let mut stmt = conn.prepare( "SELECT name, description, author, keywords, configurations, parameters, - result, tool_router_key, job_id, job_id_history, code, language + result, tool_router_key, job_id, job_id_history, code, language, tool_version FROM tool_playground - WHERE tool_router_key = ?1", + WHERE tool_router_key = ?1 + ORDER BY tool_version DESC + LIMIT 1", )?; let tool = stmt @@ -178,6 +180,7 @@ impl SqliteManager { let result: String = row.get(6)?; let job_id_history: String = row.get(9)?; let language: String = row.get(11)?; + let version: IndexableVersion = IndexableVersion::from_number(row.get(12)?); let code_language = match language.as_str() { "typescript" => CodeLanguage::Typescript, @@ -205,7 +208,7 @@ impl SqliteManager { language: code_language, metadata: ToolPlaygroundMetadata { name: row.get(0)?, - version: "1.0.0".to_string(), + version: version.to_version_string(), description: row.get(1)?, author: row.get(2)?, keywords: keywords.split(',').map(String::from).collect(), @@ -241,7 +244,7 @@ impl SqliteManager { let mut stmt = conn.prepare( "SELECT name, description, author, keywords, configurations, parameters, - result, tool_router_key, job_id, job_id_history, code, language + result, tool_router_key, job_id, job_id_history, code, language, tool_version FROM tool_playground", )?; @@ -252,7 +255,7 @@ impl SqliteManager { let result: String = row.get(6)?; let job_id_history: String = row.get(9)?; let language: String = row.get(11)?; - + let version: IndexableVersion = IndexableVersion::from_number(row.get(12)?); let code_language = match language.as_str() { "typescript" => CodeLanguage::Typescript, "python" => CodeLanguage::Python, @@ -274,7 +277,7 @@ impl SqliteManager { language: code_language, metadata: ToolPlaygroundMetadata { name: row.get(0)?, - version: "1.0.0".to_string(), + version: version.to_version_string(), description: row.get(1)?, author: row.get(2)?, keywords: keywords.split(',').map(String::from).collect(), @@ -313,7 +316,7 @@ impl SqliteManager { // 1) Find the ID of the playground row let playground_id: i64 = conn .query_row( - "SELECT id FROM tool_playground WHERE tool_router_key = ?1", + "SELECT id FROM tool_playground WHERE tool_router_key = ?1 order by tool_version desc limit 1", params![tool_router_key], |row| row.get(0), ) @@ -348,7 +351,7 @@ mod tests { shinkai_tool::ShinkaiTool, tool_output_arg::ToolOutputArg, }; - use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; + use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use std::path::PathBuf; use tempfile::NamedTempFile; diff --git a/shinkai-libs/shinkai-sqlite/src/vector_fs_manager.rs b/shinkai-libs/shinkai-sqlite/src/vector_fs_manager.rs deleted file mode 100644 index c6d49df1c..000000000 --- a/shinkai-libs/shinkai-sqlite/src/vector_fs_manager.rs +++ /dev/null @@ -1,69 +0,0 @@ -use rusqlite::params; -use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; -use shinkai_vector_resources::{ - model_type::EmbeddingModelType, - vector_resource::{MapVectorResource, VectorResourceCore}, -}; - -use crate::{errors::SqliteManagerError, SqliteManager}; - -impl SqliteManager { - pub fn save_profile_fs_internals( - &self, - profile: &ShinkaiName, - fs_core_resource: MapVectorResource, - permissions_index: Vec, - subscription_index: Vec, - supported_embedding_models: Vec, - last_read_index: Vec, - ) -> Result<(), SqliteManagerError> { - let profile_name = profile - .get_profile_name_string() - .ok_or(SqliteManagerError::InvalidIdentityName(profile.to_string()))?; - let resource_id = fs_core_resource.reference_string(); - self.save_resource(&fs_core_resource.into(), &profile_name)?; - - let conn = self.get_connection()?; - conn.execute( - "INSERT OR REPLACE INTO vector_fs_internals - (profile_name, core_resource_id, permissions_index, subscription_index, supported_embedding_models, last_read_index) - VALUES (?1, ?2, ?3, ?4, ?5, ?6)", - params![profile_name, resource_id, permissions_index, subscription_index, serde_json::to_vec(&supported_embedding_models) - .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, last_read_index], - )?; - - Ok(()) - } - - pub fn get_profile_fs_internals( - &self, - profile: &ShinkaiName, - ) -> Result<(MapVectorResource, Vec, Vec, Vec, Vec), SqliteManagerError> { - let profile_name = profile - .get_profile_name_string() - .ok_or(SqliteManagerError::InvalidIdentityName(profile.to_string()))?; - - let conn = self.get_connection()?; - let mut stmt = conn.prepare("SELECT core_resource_id, permissions_index, subscription_index, supported_embedding_models, last_read_index FROM vector_fs_internals WHERE profile_name = ?1")?; - let mut rows = stmt.query(params![profile_name])?; - - let row = rows - .next()? - .ok_or(SqliteManagerError::ProfileNotFound(profile_name.to_string()))?; - let core_resource_id: String = row.get(0)?; - let permissions_index: Vec = row.get(1)?; - let subscription_index: Vec = row.get(2)?; - let supported_embedding_models: Vec = serde_json::from_slice(&row.get::<_, Vec>(3)?)?; - let last_read_index: Vec = row.get(4)?; - - let core_resource = self.get_resource(&core_resource_id, profile)?; - - Ok(( - core_resource.as_map_resource_cloned()?, - permissions_index, - subscription_index, - supported_embedding_models, - last_read_index, - )) - } -} diff --git a/shinkai-libs/shinkai-sqlite/src/vector_resource_manager.rs b/shinkai-libs/shinkai-sqlite/src/vector_resource_manager.rs index 8b3d0b02a..63b27c9e2 100644 --- a/shinkai-libs/shinkai-sqlite/src/vector_resource_manager.rs +++ b/shinkai-libs/shinkai-sqlite/src/vector_resource_manager.rs @@ -1,831 +1,831 @@ -use std::{collections::HashMap, vec}; - -use bytemuck::cast_slice; -use rusqlite::{params, Transaction}; -use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; -use shinkai_vector_resources::{ - data_tags::DataTagIndex, - embeddings::Embedding, - model_type::EmbeddingModelType, - resource_errors::VRError, - source::{DistributionInfo, VRSourceReference}, - vector_resource::{ - BaseVectorResource, DocumentVectorResource, MapVectorResource, Node, NodeContent, VRBaseType, VRHeader, - VRKeywords, - }, -}; - -use crate::{errors::SqliteManagerError, SqliteManager}; - -const SUPPORTED_EMBEDDING_LENGTHS: [usize; 2] = [384, 768]; - -impl SqliteManager { - pub fn save_resource(&self, resource: &BaseVectorResource, profile_name: &str) -> Result<(), SqliteManagerError> { - let mut conn = self.get_connection()?; - let tx = conn.transaction()?; - - self.save_resource_tx(&tx, resource, profile_name)?; - - tx.commit()?; - Ok(()) - } - - fn save_resource_tx( - &self, - tx: &Transaction, - resource: &BaseVectorResource, - profile_name: &str, - ) -> Result<(), SqliteManagerError> { - let vector_resource_id = &resource.as_trait_object().reference_string(); - let resource = resource.as_trait_object(); - - // Delete resource if it already exists - self.delete_resource_tx(&tx, vector_resource_id)?; - - // Insert into the vector_resources table - tx.execute( - "INSERT INTO vector_resources ( - profile_name, - vector_resource_id, - name, - description, - source, - resource_id, - resource_base_type, - embedding_model_used_string, - node_count, - data_tag_index, - created_datetime, - last_written_datetime, - metadata_index, - merkle_root, - keywords, - distribution_info - ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16)", - params![ - profile_name, - vector_resource_id, - resource.name(), - resource.description(), - serde_json::to_string(&resource.source()) - .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, - resource.resource_id(), - serde_json::to_string(&resource.resource_base_type()) - .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, - resource.embedding_model_used_string(), - resource.node_count(), - serde_json::to_vec(&resource.data_tag_index()) - .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, - resource.created_datetime().to_rfc3339(), - resource.last_written_datetime().to_rfc3339(), - serde_json::to_vec(&resource.metadata_index()) - .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, - resource.get_merkle_root().ok(), - serde_json::to_vec(&resource.keywords()) - .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, - serde_json::to_vec(&resource.distribution_info()) - .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, - ], - )?; - - // Insert resource_embedding into the vector_resource_embeddings table - let resource_embedding = resource.resource_embedding(); - let vector_len = if resource_embedding.vector.len() > 0 { - resource_embedding.vector.len() - } else { - SUPPORTED_EMBEDDING_LENGTHS[0] - }; - - if !SUPPORTED_EMBEDDING_LENGTHS.contains(&vector_len) { - return Err(SqliteManagerError::UnsupportedEmbeddingLength(vector_len)); - } - - let embedding_vector = if resource_embedding.vector.len() > 0 { - &resource_embedding.vector - } else { - &vec![0f32; vector_len] - }; - - tx.execute( - &format!( - "INSERT INTO vector_resource_embeddings_{} ( - profile_name, - vector_resource_id, - id, - embedding, - is_resource_embedding - ) VALUES (?1, ?2, ?3, ?4, ?5)", - vector_len - ), - params![ - profile_name, - vector_resource_id, - resource_embedding.id, - cast_slice(embedding_vector), - true, - ], - )?; - - // Insert embeddings into the vector_resource_embeddings table - for embedding in resource.get_root_embeddings() { - let vector_len = if embedding.vector.len() > 0 { - embedding.vector.len() - } else { - SUPPORTED_EMBEDDING_LENGTHS[0] - }; - - if !SUPPORTED_EMBEDDING_LENGTHS.contains(&vector_len) { - return Err(SqliteManagerError::UnsupportedEmbeddingLength(vector_len)); - } - - let embedding_vector = if embedding.vector.len() > 0 { - &embedding.vector - } else { - &vec![0f32; vector_len] - }; - - tx.execute( - &format!( - "INSERT INTO vector_resource_embeddings_{} ( - profile_name, - vector_resource_id, - id, - embedding, - is_resource_embedding - ) VALUES (?1, ?2, ?3, ?4, ?5)", - vector_len - ), - params![ - profile_name, - vector_resource_id, - embedding.id, - cast_slice(embedding_vector), - false, - ], - )?; - } - - // Insert nodes into the vector_resource_nodes table - for node in resource.get_root_nodes() { - let content_type = match node.content { - NodeContent::ExternalContent(_) => "external", - NodeContent::Resource(_) => "resource", - NodeContent::VRHeader(_) => "header", - NodeContent::Text(_) => "text", - }; - - let content_value = match &node.content { - NodeContent::ExternalContent(external_content) => serde_json::to_string(&external_content) - .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, - NodeContent::Resource(resource) => resource.as_trait_object().reference_string(), - NodeContent::VRHeader(header) => header.reference_string(), - NodeContent::Text(text) => text.to_string(), - }; - - // Save resource or VRHeader - if let NodeContent::Resource(resource) = &node.content { - self.save_resource_tx(tx, resource, profile_name)?; - } else if let NodeContent::VRHeader(header) = &node.content { - self.save_vr_header_tx(tx, header, profile_name)?; - } - - tx.execute( - "INSERT INTO vector_resource_nodes ( - profile_name, - vector_resource_id, - id, - content_type, - content_value, - metadata, - data_tag_names, - last_written_datetime, - merkle_hash - ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)", - params![ - profile_name, - vector_resource_id, - node.id, - content_type, - content_value, - serde_json::to_string(&node.metadata) - .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, - serde_json::to_string(&node.data_tag_names) - .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, - node.last_written_datetime.to_rfc3339(), - node.merkle_hash, - ], - )?; - } - - Ok(()) - } - - pub fn delete_resource(&self, reference_string: &str) -> Result<(), SqliteManagerError> { - let mut conn = self.get_connection()?; - let tx = conn.transaction()?; - - self.delete_resource_tx(&tx, reference_string)?; - - tx.commit()?; - Ok(()) - } - - fn delete_resource_tx(&self, tx: &Transaction, reference_string: &str) -> Result<(), SqliteManagerError> { - tx.execute( - "DELETE FROM vector_resources WHERE vector_resource_id = ?", - params![reference_string], - )?; - SUPPORTED_EMBEDDING_LENGTHS.iter().for_each(|&len| { - tx.execute( - &format!( - "DELETE FROM vector_resource_embeddings_{} WHERE vector_resource_id = ?", - len - ), - params![reference_string], - ) - .unwrap(); - }); - tx.execute( - "DELETE FROM vector_resource_nodes WHERE vector_resource_id = ?", - params![reference_string], - )?; - tx.execute( - "DELETE FROM vector_resource_headers WHERE vector_resource_id = ?", - params![reference_string], - )?; - - Ok(()) - } - - pub fn get_resource( - &self, - vector_resource_id: &str, - profile: &ShinkaiName, - ) -> Result { - let profile_name = profile - .get_profile_name_string() - .ok_or(SqliteManagerError::InvalidIdentityName(profile.to_string()))?; - - // Fetch the vector resource - let conn = self.get_connection()?; - let mut stmt = - conn.prepare("SELECT * FROM vector_resources WHERE vector_resource_id = ?1 AND profile_name = ?2")?; - let resource = stmt.query_row(params![vector_resource_id, profile_name], |row| { - let name: String = row.get(2)?; - let description: Option = row.get(3)?; - let source: String = row.get(4)?; - let resource_id: String = row.get(5)?; - let resource_base_type: String = row.get(6)?; - let embedding_model_used_string: String = row.get(7)?; - let node_count: u64 = row.get(8)?; - let data_tag_index: Vec = row.get(9)?; - let created_datetime: String = row.get(10)?; - let last_written_datetime: String = row.get(11)?; - let metadata_index: Vec = row.get(12)?; - let merkle_root: Option = row.get(13)?; - let keywords: Vec = row.get(14)?; - let distribution_info: Vec = row.get(15)?; - - let source: VRSourceReference = serde_json::from_str(&source).map_err(|e| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) - })?; - let resource_base_type: VRBaseType = serde_json::from_str(&resource_base_type).map_err(|e| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) - })?; - let data_tag_index: DataTagIndex = serde_json::from_slice(&data_tag_index).map_err(|e| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) - })?; - let created_datetime = created_datetime.parse::>().map_err(|e| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::DateTimeParseError(e.to_string()))) - })?; - let last_written_datetime = - last_written_datetime - .parse::>() - .map_err(|e| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::DateTimeParseError( - e.to_string(), - ))) - })?; - let metadata_index = serde_json::from_slice(&metadata_index).map_err(|e| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) - })?; - let keywords: VRKeywords = serde_json::from_slice(&keywords).map_err(|e| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) - })?; - let distribution_info: DistributionInfo = serde_json::from_slice(&distribution_info).map_err(|e| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) - })?; - - let resource_embedding = self - .get_embeddings(vector_resource_id, profile, true) - .map_err(|e| rusqlite::Error::ToSqlConversionFailure(Box::new(e)))? - .pop() - .unwrap_or(Embedding::new_empty()); - - match resource_base_type { - VRBaseType::Document => { - let document_resource = BaseVectorResource::Document(DocumentVectorResource { - resource_base_type, - embeddings: vec![], - nodes: vec![], - name, - description, - source, - resource_id, - embedding_model_used_string, - node_count, - data_tag_index, - created_datetime, - last_written_datetime, - metadata_index, - merkle_root, - keywords, - distribution_info, - resource_embedding, - }); - - Ok(document_resource) - } - VRBaseType::Map => { - let map_resource = BaseVectorResource::Map(MapVectorResource { - resource_base_type, - embeddings: HashMap::new(), - nodes: HashMap::new(), - name, - description, - source, - resource_id, - embedding_model_used_string, - node_count, - data_tag_index, - created_datetime, - last_written_datetime, - metadata_index, - merkle_root, - keywords, - distribution_info, - resource_embedding, - }); - - Ok(map_resource) - } - _ => Err(rusqlite::Error::ToSqlConversionFailure(Box::new( - SqliteManagerError::VRError(VRError::InvalidVRBaseType), - ))), - } - }); - - let mut resource = match resource { - Ok(resource) => Ok(resource), - Err(rusqlite::Error::QueryReturnedNoRows) => Err(SqliteManagerError::DataNotFound), - Err(e) => Err(SqliteManagerError::DatabaseError(e)), - }?; - - // Fetch the embeddings - let embeddings = self.get_embeddings(vector_resource_id, profile, false)?; - - // Fetch the nodes - let nodes = self.get_nodes(vector_resource_id, profile)?; - - match resource { - BaseVectorResource::Document(ref mut document_resource) => { - document_resource.embeddings = embeddings; - document_resource.nodes = nodes; - } - BaseVectorResource::Map(ref mut map_resource) => { - map_resource.embeddings = embeddings.into_iter().map(|e| (e.id.clone(), e)).collect(); - map_resource.nodes = nodes.into_iter().map(|n| (n.id.clone(), n)).collect(); - } - } - - Ok(resource) - } - - fn get_embeddings( - &self, - vector_resource_id: &str, - profile: &ShinkaiName, - is_resource_embedding: bool, - ) -> Result, SqliteManagerError> { - let profile_name = profile - .get_profile_name_string() - .ok_or(SqliteManagerError::InvalidIdentityName(profile.to_string()))?; - - let conn = self.get_connection()?; - let mut embeddings = vec![]; - - for &len in SUPPORTED_EMBEDDING_LENGTHS.iter() { - let mut stmt = conn.prepare(&format!( - "SELECT id, embedding FROM vector_resource_embeddings_{} WHERE vector_resource_id = ? AND profile_name = ? AND is_resource_embedding = ?", - len - ))?; - let result = stmt.query_map( - params![vector_resource_id, profile_name, is_resource_embedding], - |row| { - let id: String = row.get(0)?; - let embedding_bytes: Vec = row.get(1)?; - let embedding: &[f32] = cast_slice(&embedding_bytes); - - Ok(Embedding { - id, - vector: embedding.to_vec(), - }) - }, - )?; - - let result = result.collect::, _>>()?; - - embeddings.extend(result); - } - - Ok(embeddings) - } - - fn get_nodes(&self, vector_resource_id: &str, profile: &ShinkaiName) -> Result, SqliteManagerError> { - let profile_name = profile - .get_profile_name_string() - .ok_or(SqliteManagerError::InvalidIdentityName(profile.to_string()))?; - - let conn = self.get_connection()?; - let mut stmt = - conn.prepare("SELECT * FROM vector_resource_nodes WHERE vector_resource_id = ? AND profile_name = ?")?; - let nodes = stmt.query_map(params![vector_resource_id, profile_name], |row| { - let id: String = row.get(2)?; - let content_type: String = row.get(3)?; - let content_value: String = row.get(4)?; - let metadata: Option = row.get(5)?; - let data_tag_names: String = row.get(6)?; - let last_written_datetime: String = row.get(7)?; - let merkle_hash: Option = row.get(8)?; - - let metadata: Option> = match metadata { - Some(metadata) => serde_json::from_str(&metadata).map_err(|e| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError( - e.to_string(), - ))) - })?, - None => None, - }; - - let content = match content_type.as_str() { - "external" => NodeContent::ExternalContent(serde_json::from_str(&content_value).map_err(|e| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError( - e.to_string(), - ))) - })?), - "resource" => NodeContent::Resource( - self.get_resource(&content_value, profile) - .map_err(|e| rusqlite::Error::ToSqlConversionFailure(Box::new(e)))?, - ), - "header" => NodeContent::VRHeader( - self.get_vr_header(&content_value, profile) - .map_err(|e| rusqlite::Error::ToSqlConversionFailure(Box::new(e)))?, - ), - "text" | _ => NodeContent::Text(content_value), - }; - - Ok(Node { - id, - content, - metadata, - data_tag_names: serde_json::from_str(&data_tag_names).map_err(|e| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError( - e.to_string(), - ))) - })?, - last_written_datetime: last_written_datetime - .parse::>() - .map_err(|e| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::DateTimeParseError( - e.to_string(), - ))) - })?, - merkle_hash, - }) - })?; - - let nodes = nodes.collect::, _>>()?; - - Ok(nodes) - } - - fn get_vr_header(&self, vector_resource_id: &str, profile: &ShinkaiName) -> Result { - let profile_name = profile - .get_profile_name_string() - .ok_or(SqliteManagerError::InvalidIdentityName(profile.to_string()))?; - - let conn = self.get_connection()?; - let mut stmt = - conn.prepare("SELECT * FROM vector_resource_headers WHERE vector_resource_id = ? AND profile_name = ?")?; - let vr_header = stmt.query_row(params![vector_resource_id, profile_name], |row| { - let resource_name: String = row.get(2)?; - let resource_id: String = row.get(3)?; - let resource_base_type: String = row.get(4)?; - let resource_source: String = row.get(5)?; - let resource_created_datetime: String = row.get(6)?; - let resource_last_written_datetime: String = row.get(7)?; - let resource_embedding_model_used: String = row.get(8)?; - let resource_merkle_root: Option = row.get(9)?; - let resource_keywords: Vec = row.get(10)?; - let resource_distribution_info: Vec = row.get(11)?; - let data_tag_names: String = row.get(12)?; - let metadata_index_keys: String = row.get(13)?; - - let resource_base_type: VRBaseType = serde_json::from_str(&resource_base_type).map_err(|e| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) - })?; - let resource_source: VRSourceReference = serde_json::from_str(&resource_source).map_err(|e| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) - })?; - let resource_embedding_model_used: EmbeddingModelType = - serde_json::from_str(&resource_embedding_model_used).map_err(|e| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError( - e.to_string(), - ))) - })?; - let resource_distribution_info: DistributionInfo = serde_json::from_slice(&resource_distribution_info) - .map_err(|e| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError( - e.to_string(), - ))) - })?; - let data_tag_names: Vec = serde_json::from_str(&data_tag_names).map_err(|e| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) - })?; - let metadata_index_keys: Vec = serde_json::from_str(&metadata_index_keys).map_err(|e| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) - })?; - - let resource_embedding = self - .get_embeddings(vector_resource_id, profile, true) - .map_err(|e| rusqlite::Error::ToSqlConversionFailure(Box::new(e)))? - .pop(); - - Ok(VRHeader { - resource_name, - resource_id, - resource_base_type, - resource_source, - resource_created_datetime: resource_created_datetime - .parse::>() - .map_err(|e| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::DateTimeParseError( - e.to_string(), - ))) - })?, - resource_last_written_datetime: resource_last_written_datetime - .parse::>() - .map_err(|e| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::DateTimeParseError( - e.to_string(), - ))) - })?, - resource_embedding_model_used, - resource_merkle_root, - resource_keywords: serde_json::from_slice(&resource_keywords).map_err(|e| { - rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError( - e.to_string(), - ))) - })?, - resource_distribution_info, - data_tag_names, - metadata_index_keys, - resource_embedding, - }) - }); - - let vr_header = match vr_header { - Ok(vr_header) => Ok(vr_header), - Err(rusqlite::Error::QueryReturnedNoRows) => Err(SqliteManagerError::DataNotFound), - Err(e) => Err(SqliteManagerError::DatabaseError(e)), - }?; - - Ok(vr_header) - } - - fn save_vr_header_tx( - &self, - tx: &Transaction, - vr_header: &VRHeader, - profile_name: &str, - ) -> Result<(), SqliteManagerError> { - tx.execute( - "INSERT OR REPLACE INTO vector_resource_headers ( - profile_name, - vector_resource_id, - resource_name, - resource_id, - resource_base_type, - resource_source, - resource_created_datetime, - resource_last_written_datetime, - resource_embedding_model_used, - resource_merkle_root, - resource_keywords, - resource_distribution_info, - data_tag_names, - metadata_index_keys - ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14)", - params![ - profile_name, - vr_header.reference_string(), - vr_header.resource_name, - vr_header.resource_id, - serde_json::to_string(&vr_header.resource_base_type) - .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, - serde_json::to_string(&vr_header.resource_source) - .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, - vr_header.resource_created_datetime.to_rfc3339(), - vr_header.resource_last_written_datetime.to_rfc3339(), - serde_json::to_string(&vr_header.resource_embedding_model_used) - .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, - vr_header.resource_merkle_root, - serde_json::to_vec(&vr_header.resource_keywords) - .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, - serde_json::to_vec(&vr_header.resource_distribution_info) - .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, - serde_json::to_string(&vr_header.data_tag_names) - .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, - serde_json::to_string(&vr_header.metadata_index_keys) - .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, - ], - )?; - - // Insert resource_embedding into the vector_resource_embeddings table - if let Some(resource_embedding) = &vr_header.resource_embedding { - let vector_len = if resource_embedding.vector.len() > 0 { - resource_embedding.vector.len() - } else { - SUPPORTED_EMBEDDING_LENGTHS[0] - }; - - if !SUPPORTED_EMBEDDING_LENGTHS.contains(&vector_len) { - return Err(SqliteManagerError::UnsupportedEmbeddingLength(vector_len)); - } - - let embedding_vector = if resource_embedding.vector.len() > 0 { - &resource_embedding.vector - } else { - &vec![0f32; vector_len] - }; - tx.execute( - &format!( - "INSERT INTO vector_resource_embeddings_{} ( - profile_name, - vector_resource_id, - id, - embedding, - is_resource_embedding - ) VALUES (?1, ?2, ?3, ?4, ?5)", - vector_len - ), - params![ - profile_name, - vr_header.reference_string(), - resource_embedding.id, - cast_slice(embedding_vector), - true, - ], - )?; - } - - Ok(()) - } -} - -#[cfg(test)] -mod tests { - use super::*; - use shinkai_vector_resources::{ - embedding_generator::{EmbeddingGenerator, RemoteEmbeddingGenerator}, - model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}, - vector_resource::VectorResourceCore, - }; - use std::path::PathBuf; - use tempfile::NamedTempFile; - - fn setup_test_db() -> SqliteManager { - let temp_file = NamedTempFile::new().unwrap(); - let db_path = PathBuf::from(temp_file.path()); - let api_url = String::new(); - let model_type = - EmbeddingModelType::OllamaTextEmbeddingsInference(OllamaTextEmbeddingsInference::SnowflakeArcticEmbed_M); - - SqliteManager::new(db_path, api_url, model_type).unwrap() - } - - #[tokio::test] - async fn test_document_vector_resources() { - let manager = setup_test_db(); - - let generator = RemoteEmbeddingGenerator::new_default(); - let mut doc = DocumentVectorResource::new_empty( - "Test VR", - Some("Test VR Description"), - VRSourceReference::new_uri_ref("https://example.com"), - true, - ); - - doc.set_embedding_model_used(generator.model_type()); - doc.update_resource_embedding(&generator, Some(vec!["test".to_string(), "document".to_string()])) - .await - .unwrap(); - - let profile = ShinkaiName::new("@@test_user.shinkai/main".to_string()).unwrap(); - - let vr = BaseVectorResource::Document(doc.clone()); - - manager - .save_resource(&vr, &profile.get_profile_name_string().unwrap()) - .unwrap(); - - let vr2 = manager.get_resource(&doc.reference_string(), &profile).unwrap(); - - assert_eq!(vr, vr2); - } - - #[tokio::test] - async fn test_nested_vr_with_nodes() { - let manager = setup_test_db(); - - let generator = RemoteEmbeddingGenerator::new_default(); - let mut map_resource = MapVectorResource::new_empty( - "Tech Facts", - Some("A collection of facts about technology"), - VRSourceReference::new_uri_ref("veryrealtechfacts.com"), - true, - ); - - map_resource.set_embedding_model_used(generator.model_type()); // Not required, but good practice - map_resource - .update_resource_embedding(&generator, Some(vec!["technology".to_string(), "phones".to_string()])) - .await - .unwrap(); - - let mut doc_resource = DocumentVectorResource::new_empty( - "Test VR", - Some("Test VR Description"), - VRSourceReference::new_uri_ref("https://example.com"), - true, - ); - - doc_resource.set_embedding_model_used(generator.model_type()); - doc_resource - .update_resource_embedding(&generator, Some(vec!["test".to_string(), "document".to_string()])) - .await - .unwrap(); - - let doc_name = doc_resource.name.clone(); - let node = Node::new_vector_resource(doc_name.clone(), &BaseVectorResource::Document(doc_resource), None); - let embedding = generator.generate_embedding_default("test node").await.unwrap(); - map_resource - .insert_node_dt_specified(doc_name, node, embedding.clone(), None, true) - .unwrap(); - - let profile = ShinkaiName::new("@@test_user.shinkai/main".to_string()).unwrap(); - - let vr = BaseVectorResource::Map(map_resource.clone()); - - manager - .save_resource(&vr, &profile.get_profile_name_string().unwrap()) - .unwrap(); - - let vr2 = manager - .get_resource(&map_resource.reference_string(), &profile) - .unwrap(); - - assert_eq!(vr, vr2); - } - - #[tokio::test] - async fn test_delete_resource() { - let manager = setup_test_db(); - - let generator = RemoteEmbeddingGenerator::new_default(); - let mut doc = DocumentVectorResource::new_empty( - "Test VR", - Some("Test VR Description"), - VRSourceReference::new_uri_ref("https://example.com"), - true, - ); - - doc.set_embedding_model_used(generator.model_type()); - doc.update_resource_embedding(&generator, Some(vec!["test".to_string(), "document".to_string()])) - .await - .unwrap(); - - let profile = ShinkaiName::new("@@test_user.shinkai/main".to_string()).unwrap(); - - let vr = BaseVectorResource::Document(doc.clone()); - - manager - .save_resource(&vr, &profile.get_profile_name_string().unwrap()) - .unwrap(); - - manager.delete_resource(&doc.reference_string()).unwrap(); +// use std::{collections::HashMap, vec}; + +// use bytemuck::cast_slice; +// use rusqlite::{params, Transaction}; +// use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; +// use shinkai_vector_resources::{ +// data_tags::DataTagIndex, +// embeddings::Embedding, +// model_type::EmbeddingModelType, +// resource_errors::VRError, +// source::{DistributionInfo, VRSourceReference}, +// vector_resource::{ +// BaseVectorResource, DocumentVectorResource, MapVectorResource, Node, NodeContent, VRBaseType, VRHeader, +// VRKeywords, +// }, +// }; + +// use crate::{errors::SqliteManagerError, SqliteManager}; + +// const SUPPORTED_EMBEDDING_LENGTHS: [usize; 2] = [384, 768]; + +// impl SqliteManager { +// pub fn save_resource(&self, resource: &BaseVectorResource, profile_name: &str) -> Result<(), SqliteManagerError> { +// let mut conn = self.get_connection()?; +// let tx = conn.transaction()?; + +// self.save_resource_tx(&tx, resource, profile_name)?; + +// tx.commit()?; +// Ok(()) +// } + +// fn save_resource_tx( +// &self, +// tx: &Transaction, +// resource: &BaseVectorResource, +// profile_name: &str, +// ) -> Result<(), SqliteManagerError> { +// let vector_resource_id = &resource.as_trait_object().reference_string(); +// let resource = resource.as_trait_object(); + +// // Delete resource if it already exists +// self.delete_resource_tx(&tx, vector_resource_id)?; + +// // Insert into the vector_resources table +// tx.execute( +// "INSERT INTO vector_resources ( +// profile_name, +// vector_resource_id, +// name, +// description, +// source, +// resource_id, +// resource_base_type, +// embedding_model_used_string, +// node_count, +// data_tag_index, +// created_datetime, +// last_written_datetime, +// metadata_index, +// merkle_root, +// keywords, +// distribution_info +// ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16)", +// params![ +// profile_name, +// vector_resource_id, +// resource.name(), +// resource.description(), +// serde_json::to_string(&resource.source()) +// .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, +// resource.resource_id(), +// serde_json::to_string(&resource.resource_base_type()) +// .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, +// resource.embedding_model_used_string(), +// resource.node_count(), +// serde_json::to_vec(&resource.data_tag_index()) +// .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, +// resource.created_datetime().to_rfc3339(), +// resource.last_written_datetime().to_rfc3339(), +// serde_json::to_vec(&resource.metadata_index()) +// .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, +// resource.get_merkle_root().ok(), +// serde_json::to_vec(&resource.keywords()) +// .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, +// serde_json::to_vec(&resource.distribution_info()) +// .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, +// ], +// )?; + +// // Insert resource_embedding into the vector_resource_embeddings table +// let resource_embedding = resource.resource_embedding(); +// let vector_len = if resource_embedding.vector.len() > 0 { +// resource_embedding.vector.len() +// } else { +// SUPPORTED_EMBEDDING_LENGTHS[0] +// }; + +// if !SUPPORTED_EMBEDDING_LENGTHS.contains(&vector_len) { +// return Err(SqliteManagerError::UnsupportedEmbeddingLength(vector_len)); +// } + +// let embedding_vector = if resource_embedding.vector.len() > 0 { +// &resource_embedding.vector +// } else { +// &vec![0f32; vector_len] +// }; + +// tx.execute( +// &format!( +// "INSERT INTO vector_resource_embeddings_{} ( +// profile_name, +// vector_resource_id, +// id, +// embedding, +// is_resource_embedding +// ) VALUES (?1, ?2, ?3, ?4, ?5)", +// vector_len +// ), +// params![ +// profile_name, +// vector_resource_id, +// resource_embedding.id, +// cast_slice(embedding_vector), +// true, +// ], +// )?; + +// // Insert embeddings into the vector_resource_embeddings table +// for embedding in resource.get_root_embeddings() { +// let vector_len = if embedding.vector.len() > 0 { +// embedding.vector.len() +// } else { +// SUPPORTED_EMBEDDING_LENGTHS[0] +// }; + +// if !SUPPORTED_EMBEDDING_LENGTHS.contains(&vector_len) { +// return Err(SqliteManagerError::UnsupportedEmbeddingLength(vector_len)); +// } + +// let embedding_vector = if embedding.vector.len() > 0 { +// &embedding.vector +// } else { +// &vec![0f32; vector_len] +// }; + +// tx.execute( +// &format!( +// "INSERT INTO vector_resource_embeddings_{} ( +// profile_name, +// vector_resource_id, +// id, +// embedding, +// is_resource_embedding +// ) VALUES (?1, ?2, ?3, ?4, ?5)", +// vector_len +// ), +// params![ +// profile_name, +// vector_resource_id, +// embedding.id, +// cast_slice(embedding_vector), +// false, +// ], +// )?; +// } + +// // Insert nodes into the vector_resource_nodes table +// for node in resource.get_root_nodes() { +// let content_type = match node.content { +// NodeContent::ExternalContent(_) => "external", +// NodeContent::Resource(_) => "resource", +// NodeContent::VRHeader(_) => "header", +// NodeContent::Text(_) => "text", +// }; + +// let content_value = match &node.content { +// NodeContent::ExternalContent(external_content) => serde_json::to_string(&external_content) +// .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, +// NodeContent::Resource(resource) => resource.as_trait_object().reference_string(), +// NodeContent::VRHeader(header) => header.reference_string(), +// NodeContent::Text(text) => text.to_string(), +// }; + +// // Save resource or VRHeader +// if let NodeContent::Resource(resource) = &node.content { +// self.save_resource_tx(tx, resource, profile_name)?; +// } else if let NodeContent::VRHeader(header) = &node.content { +// self.save_vr_header_tx(tx, header, profile_name)?; +// } + +// tx.execute( +// "INSERT INTO vector_resource_nodes ( +// profile_name, +// vector_resource_id, +// id, +// content_type, +// content_value, +// metadata, +// data_tag_names, +// last_written_datetime, +// merkle_hash +// ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)", +// params![ +// profile_name, +// vector_resource_id, +// node.id, +// content_type, +// content_value, +// serde_json::to_string(&node.metadata) +// .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, +// serde_json::to_string(&node.data_tag_names) +// .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, +// node.last_written_datetime.to_rfc3339(), +// node.merkle_hash, +// ], +// )?; +// } + +// Ok(()) +// } + +// pub fn delete_resource(&self, reference_string: &str) -> Result<(), SqliteManagerError> { +// let mut conn = self.get_connection()?; +// let tx = conn.transaction()?; + +// self.delete_resource_tx(&tx, reference_string)?; + +// tx.commit()?; +// Ok(()) +// } + +// fn delete_resource_tx(&self, tx: &Transaction, reference_string: &str) -> Result<(), SqliteManagerError> { +// tx.execute( +// "DELETE FROM vector_resources WHERE vector_resource_id = ?", +// params![reference_string], +// )?; +// SUPPORTED_EMBEDDING_LENGTHS.iter().for_each(|&len| { +// tx.execute( +// &format!( +// "DELETE FROM vector_resource_embeddings_{} WHERE vector_resource_id = ?", +// len +// ), +// params![reference_string], +// ) +// .unwrap(); +// }); +// tx.execute( +// "DELETE FROM vector_resource_nodes WHERE vector_resource_id = ?", +// params![reference_string], +// )?; +// tx.execute( +// "DELETE FROM vector_resource_headers WHERE vector_resource_id = ?", +// params![reference_string], +// )?; + +// Ok(()) +// } + +// pub fn get_resource( +// &self, +// vector_resource_id: &str, +// profile: &ShinkaiName, +// ) -> Result { +// let profile_name = profile +// .get_profile_name_string() +// .ok_or(SqliteManagerError::InvalidIdentityName(profile.to_string()))?; + +// // Fetch the vector resource +// let conn = self.get_connection()?; +// let mut stmt = +// conn.prepare("SELECT * FROM vector_resources WHERE vector_resource_id = ?1 AND profile_name = ?2")?; +// let resource = stmt.query_row(params![vector_resource_id, profile_name], |row| { +// let name: String = row.get(2)?; +// let description: Option = row.get(3)?; +// let source: String = row.get(4)?; +// let resource_id: String = row.get(5)?; +// let resource_base_type: String = row.get(6)?; +// let embedding_model_used_string: String = row.get(7)?; +// let node_count: u64 = row.get(8)?; +// let data_tag_index: Vec = row.get(9)?; +// let created_datetime: String = row.get(10)?; +// let last_written_datetime: String = row.get(11)?; +// let metadata_index: Vec = row.get(12)?; +// let merkle_root: Option = row.get(13)?; +// let keywords: Vec = row.get(14)?; +// let distribution_info: Vec = row.get(15)?; + +// let source: VRSourceReference = serde_json::from_str(&source).map_err(|e| { +// rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) +// })?; +// let resource_base_type: VRBaseType = serde_json::from_str(&resource_base_type).map_err(|e| { +// rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) +// })?; +// let data_tag_index: DataTagIndex = serde_json::from_slice(&data_tag_index).map_err(|e| { +// rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) +// })?; +// let created_datetime = created_datetime.parse::>().map_err(|e| { +// rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::DateTimeParseError(e.to_string()))) +// })?; +// let last_written_datetime = +// last_written_datetime +// .parse::>() +// .map_err(|e| { +// rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::DateTimeParseError( +// e.to_string(), +// ))) +// })?; +// let metadata_index = serde_json::from_slice(&metadata_index).map_err(|e| { +// rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) +// })?; +// let keywords: VRKeywords = serde_json::from_slice(&keywords).map_err(|e| { +// rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) +// })?; +// let distribution_info: DistributionInfo = serde_json::from_slice(&distribution_info).map_err(|e| { +// rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) +// })?; + +// let resource_embedding = self +// .get_embeddings(vector_resource_id, profile, true) +// .map_err(|e| rusqlite::Error::ToSqlConversionFailure(Box::new(e)))? +// .pop() +// .unwrap_or(Embedding::new_empty()); + +// match resource_base_type { +// VRBaseType::Document => { +// let document_resource = BaseVectorResource::Document(DocumentVectorResource { +// resource_base_type, +// embeddings: vec![], +// nodes: vec![], +// name, +// description, +// source, +// resource_id, +// embedding_model_used_string, +// node_count, +// data_tag_index, +// created_datetime, +// last_written_datetime, +// metadata_index, +// merkle_root, +// keywords, +// distribution_info, +// resource_embedding, +// }); + +// Ok(document_resource) +// } +// VRBaseType::Map => { +// let map_resource = BaseVectorResource::Map(MapVectorResource { +// resource_base_type, +// embeddings: HashMap::new(), +// nodes: HashMap::new(), +// name, +// description, +// source, +// resource_id, +// embedding_model_used_string, +// node_count, +// data_tag_index, +// created_datetime, +// last_written_datetime, +// metadata_index, +// merkle_root, +// keywords, +// distribution_info, +// resource_embedding, +// }); + +// Ok(map_resource) +// } +// _ => Err(rusqlite::Error::ToSqlConversionFailure(Box::new( +// SqliteManagerError::VRError(VRError::InvalidVRBaseType), +// ))), +// } +// }); + +// let mut resource = match resource { +// Ok(resource) => Ok(resource), +// Err(rusqlite::Error::QueryReturnedNoRows) => Err(SqliteManagerError::DataNotFound), +// Err(e) => Err(SqliteManagerError::DatabaseError(e)), +// }?; + +// // Fetch the embeddings +// let embeddings = self.get_embeddings(vector_resource_id, profile, false)?; + +// // Fetch the nodes +// let nodes = self.get_nodes(vector_resource_id, profile)?; + +// match resource { +// BaseVectorResource::Document(ref mut document_resource) => { +// document_resource.embeddings = embeddings; +// document_resource.nodes = nodes; +// } +// BaseVectorResource::Map(ref mut map_resource) => { +// map_resource.embeddings = embeddings.into_iter().map(|e| (e.id.clone(), e)).collect(); +// map_resource.nodes = nodes.into_iter().map(|n| (n.id.clone(), n)).collect(); +// } +// } + +// Ok(resource) +// } + +// fn get_embeddings( +// &self, +// vector_resource_id: &str, +// profile: &ShinkaiName, +// is_resource_embedding: bool, +// ) -> Result, SqliteManagerError> { +// let profile_name = profile +// .get_profile_name_string() +// .ok_or(SqliteManagerError::InvalidIdentityName(profile.to_string()))?; + +// let conn = self.get_connection()?; +// let mut embeddings = vec![]; + +// for &len in SUPPORTED_EMBEDDING_LENGTHS.iter() { +// let mut stmt = conn.prepare(&format!( +// "SELECT id, embedding FROM vector_resource_embeddings_{} WHERE vector_resource_id = ? AND profile_name = ? AND is_resource_embedding = ?", +// len +// ))?; +// let result = stmt.query_map( +// params![vector_resource_id, profile_name, is_resource_embedding], +// |row| { +// let id: String = row.get(0)?; +// let embedding_bytes: Vec = row.get(1)?; +// let embedding: &[f32] = cast_slice(&embedding_bytes); + +// Ok(Embedding { +// id, +// vector: embedding.to_vec(), +// }) +// }, +// )?; + +// let result = result.collect::, _>>()?; + +// embeddings.extend(result); +// } + +// Ok(embeddings) +// } + +// fn get_nodes(&self, vector_resource_id: &str, profile: &ShinkaiName) -> Result, SqliteManagerError> { +// let profile_name = profile +// .get_profile_name_string() +// .ok_or(SqliteManagerError::InvalidIdentityName(profile.to_string()))?; + +// let conn = self.get_connection()?; +// let mut stmt = +// conn.prepare("SELECT * FROM vector_resource_nodes WHERE vector_resource_id = ? AND profile_name = ?")?; +// let nodes = stmt.query_map(params![vector_resource_id, profile_name], |row| { +// let id: String = row.get(2)?; +// let content_type: String = row.get(3)?; +// let content_value: String = row.get(4)?; +// let metadata: Option = row.get(5)?; +// let data_tag_names: String = row.get(6)?; +// let last_written_datetime: String = row.get(7)?; +// let merkle_hash: Option = row.get(8)?; + +// let metadata: Option> = match metadata { +// Some(metadata) => serde_json::from_str(&metadata).map_err(|e| { +// rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError( +// e.to_string(), +// ))) +// })?, +// None => None, +// }; + +// let content = match content_type.as_str() { +// "external" => NodeContent::ExternalContent(serde_json::from_str(&content_value).map_err(|e| { +// rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError( +// e.to_string(), +// ))) +// })?), +// "resource" => NodeContent::Resource( +// self.get_resource(&content_value, profile) +// .map_err(|e| rusqlite::Error::ToSqlConversionFailure(Box::new(e)))?, +// ), +// "header" => NodeContent::VRHeader( +// self.get_vr_header(&content_value, profile) +// .map_err(|e| rusqlite::Error::ToSqlConversionFailure(Box::new(e)))?, +// ), +// "text" | _ => NodeContent::Text(content_value), +// }; + +// Ok(Node { +// id, +// content, +// metadata, +// data_tag_names: serde_json::from_str(&data_tag_names).map_err(|e| { +// rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError( +// e.to_string(), +// ))) +// })?, +// last_written_datetime: last_written_datetime +// .parse::>() +// .map_err(|e| { +// rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::DateTimeParseError( +// e.to_string(), +// ))) +// })?, +// merkle_hash, +// }) +// })?; + +// let nodes = nodes.collect::, _>>()?; + +// Ok(nodes) +// } + +// fn get_vr_header(&self, vector_resource_id: &str, profile: &ShinkaiName) -> Result { +// let profile_name = profile +// .get_profile_name_string() +// .ok_or(SqliteManagerError::InvalidIdentityName(profile.to_string()))?; + +// let conn = self.get_connection()?; +// let mut stmt = +// conn.prepare("SELECT * FROM vector_resource_headers WHERE vector_resource_id = ? AND profile_name = ?")?; +// let vr_header = stmt.query_row(params![vector_resource_id, profile_name], |row| { +// let resource_name: String = row.get(2)?; +// let resource_id: String = row.get(3)?; +// let resource_base_type: String = row.get(4)?; +// let resource_source: String = row.get(5)?; +// let resource_created_datetime: String = row.get(6)?; +// let resource_last_written_datetime: String = row.get(7)?; +// let resource_embedding_model_used: String = row.get(8)?; +// let resource_merkle_root: Option = row.get(9)?; +// let resource_keywords: Vec = row.get(10)?; +// let resource_distribution_info: Vec = row.get(11)?; +// let data_tag_names: String = row.get(12)?; +// let metadata_index_keys: String = row.get(13)?; + +// let resource_base_type: VRBaseType = serde_json::from_str(&resource_base_type).map_err(|e| { +// rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) +// })?; +// let resource_source: VRSourceReference = serde_json::from_str(&resource_source).map_err(|e| { +// rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) +// })?; +// let resource_embedding_model_used: EmbeddingModelType = +// serde_json::from_str(&resource_embedding_model_used).map_err(|e| { +// rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError( +// e.to_string(), +// ))) +// })?; +// let resource_distribution_info: DistributionInfo = serde_json::from_slice(&resource_distribution_info) +// .map_err(|e| { +// rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError( +// e.to_string(), +// ))) +// })?; +// let data_tag_names: Vec = serde_json::from_str(&data_tag_names).map_err(|e| { +// rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) +// })?; +// let metadata_index_keys: Vec = serde_json::from_str(&metadata_index_keys).map_err(|e| { +// rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError(e.to_string()))) +// })?; + +// let resource_embedding = self +// .get_embeddings(vector_resource_id, profile, true) +// .map_err(|e| rusqlite::Error::ToSqlConversionFailure(Box::new(e)))? +// .pop(); + +// Ok(VRHeader { +// resource_name, +// resource_id, +// resource_base_type, +// resource_source, +// resource_created_datetime: resource_created_datetime +// .parse::>() +// .map_err(|e| { +// rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::DateTimeParseError( +// e.to_string(), +// ))) +// })?, +// resource_last_written_datetime: resource_last_written_datetime +// .parse::>() +// .map_err(|e| { +// rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::DateTimeParseError( +// e.to_string(), +// ))) +// })?, +// resource_embedding_model_used, +// resource_merkle_root, +// resource_keywords: serde_json::from_slice(&resource_keywords).map_err(|e| { +// rusqlite::Error::ToSqlConversionFailure(Box::new(SqliteManagerError::SerializationError( +// e.to_string(), +// ))) +// })?, +// resource_distribution_info, +// data_tag_names, +// metadata_index_keys, +// resource_embedding, +// }) +// }); + +// let vr_header = match vr_header { +// Ok(vr_header) => Ok(vr_header), +// Err(rusqlite::Error::QueryReturnedNoRows) => Err(SqliteManagerError::DataNotFound), +// Err(e) => Err(SqliteManagerError::DatabaseError(e)), +// }?; + +// Ok(vr_header) +// } + +// fn save_vr_header_tx( +// &self, +// tx: &Transaction, +// vr_header: &VRHeader, +// profile_name: &str, +// ) -> Result<(), SqliteManagerError> { +// tx.execute( +// "INSERT OR REPLACE INTO vector_resource_headers ( +// profile_name, +// vector_resource_id, +// resource_name, +// resource_id, +// resource_base_type, +// resource_source, +// resource_created_datetime, +// resource_last_written_datetime, +// resource_embedding_model_used, +// resource_merkle_root, +// resource_keywords, +// resource_distribution_info, +// data_tag_names, +// metadata_index_keys +// ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14)", +// params![ +// profile_name, +// vr_header.reference_string(), +// vr_header.resource_name, +// vr_header.resource_id, +// serde_json::to_string(&vr_header.resource_base_type) +// .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, +// serde_json::to_string(&vr_header.resource_source) +// .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, +// vr_header.resource_created_datetime.to_rfc3339(), +// vr_header.resource_last_written_datetime.to_rfc3339(), +// serde_json::to_string(&vr_header.resource_embedding_model_used) +// .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, +// vr_header.resource_merkle_root, +// serde_json::to_vec(&vr_header.resource_keywords) +// .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, +// serde_json::to_vec(&vr_header.resource_distribution_info) +// .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, +// serde_json::to_string(&vr_header.data_tag_names) +// .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, +// serde_json::to_string(&vr_header.metadata_index_keys) +// .map_err(|e| SqliteManagerError::SerializationError(e.to_string()))?, +// ], +// )?; + +// // Insert resource_embedding into the vector_resource_embeddings table +// if let Some(resource_embedding) = &vr_header.resource_embedding { +// let vector_len = if resource_embedding.vector.len() > 0 { +// resource_embedding.vector.len() +// } else { +// SUPPORTED_EMBEDDING_LENGTHS[0] +// }; + +// if !SUPPORTED_EMBEDDING_LENGTHS.contains(&vector_len) { +// return Err(SqliteManagerError::UnsupportedEmbeddingLength(vector_len)); +// } + +// let embedding_vector = if resource_embedding.vector.len() > 0 { +// &resource_embedding.vector +// } else { +// &vec![0f32; vector_len] +// }; +// tx.execute( +// &format!( +// "INSERT INTO vector_resource_embeddings_{} ( +// profile_name, +// vector_resource_id, +// id, +// embedding, +// is_resource_embedding +// ) VALUES (?1, ?2, ?3, ?4, ?5)", +// vector_len +// ), +// params![ +// profile_name, +// vr_header.reference_string(), +// resource_embedding.id, +// cast_slice(embedding_vector), +// true, +// ], +// )?; +// } + +// Ok(()) +// } +// } + +// #[cfg(test)] +// mod tests { +// use super::*; +// use shinkai_vector_resources::{ +// embedding_generator::{EmbeddingGenerator, RemoteEmbeddingGenerator}, +// model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}, +// vector_resource::VectorResourceCore, +// }; +// use std::path::PathBuf; +// use tempfile::NamedTempFile; + +// fn setup_test_db() -> SqliteManager { +// let temp_file = NamedTempFile::new().unwrap(); +// let db_path = PathBuf::from(temp_file.path()); +// let api_url = String::new(); +// let model_type = +// EmbeddingModelType::OllamaTextEmbeddingsInference(OllamaTextEmbeddingsInference::SnowflakeArcticEmbed_M); + +// SqliteManager::new(db_path, api_url, model_type).unwrap() +// } + +// #[tokio::test] +// async fn test_document_vector_resources() { +// let manager = setup_test_db(); + +// let generator = RemoteEmbeddingGenerator::new_default(); +// let mut doc = DocumentVectorResource::new_empty( +// "Test VR", +// Some("Test VR Description"), +// VRSourceReference::new_uri_ref("https://example.com"), +// true, +// ); + +// doc.set_embedding_model_used(generator.model_type()); +// doc.update_resource_embedding(&generator, Some(vec!["test".to_string(), "document".to_string()])) +// .await +// .unwrap(); + +// let profile = ShinkaiName::new("@@test_user.shinkai/main".to_string()).unwrap(); + +// let vr = BaseVectorResource::Document(doc.clone()); + +// manager +// .save_resource(&vr, &profile.get_profile_name_string().unwrap()) +// .unwrap(); + +// let vr2 = manager.get_resource(&doc.reference_string(), &profile).unwrap(); + +// assert_eq!(vr, vr2); +// } + +// #[tokio::test] +// async fn test_nested_vr_with_nodes() { +// let manager = setup_test_db(); + +// let generator = RemoteEmbeddingGenerator::new_default(); +// let mut map_resource = MapVectorResource::new_empty( +// "Tech Facts", +// Some("A collection of facts about technology"), +// VRSourceReference::new_uri_ref("veryrealtechfacts.com"), +// true, +// ); + +// map_resource.set_embedding_model_used(generator.model_type()); // Not required, but good practice +// map_resource +// .update_resource_embedding(&generator, Some(vec!["technology".to_string(), "phones".to_string()])) +// .await +// .unwrap(); + +// let mut doc_resource = DocumentVectorResource::new_empty( +// "Test VR", +// Some("Test VR Description"), +// VRSourceReference::new_uri_ref("https://example.com"), +// true, +// ); + +// doc_resource.set_embedding_model_used(generator.model_type()); +// doc_resource +// .update_resource_embedding(&generator, Some(vec!["test".to_string(), "document".to_string()])) +// .await +// .unwrap(); + +// let doc_name = doc_resource.name.clone(); +// let node = Node::new_vector_resource(doc_name.clone(), &BaseVectorResource::Document(doc_resource), None); +// let embedding = generator.generate_embedding_default("test node").await.unwrap(); +// map_resource +// .insert_node_dt_specified(doc_name, node, embedding.clone(), None, true) +// .unwrap(); + +// let profile = ShinkaiName::new("@@test_user.shinkai/main".to_string()).unwrap(); + +// let vr = BaseVectorResource::Map(map_resource.clone()); + +// manager +// .save_resource(&vr, &profile.get_profile_name_string().unwrap()) +// .unwrap(); + +// let vr2 = manager +// .get_resource(&map_resource.reference_string(), &profile) +// .unwrap(); + +// assert_eq!(vr, vr2); +// } + +// #[tokio::test] +// async fn test_delete_resource() { +// let manager = setup_test_db(); + +// let generator = RemoteEmbeddingGenerator::new_default(); +// let mut doc = DocumentVectorResource::new_empty( +// "Test VR", +// Some("Test VR Description"), +// VRSourceReference::new_uri_ref("https://example.com"), +// true, +// ); + +// doc.set_embedding_model_used(generator.model_type()); +// doc.update_resource_embedding(&generator, Some(vec!["test".to_string(), "document".to_string()])) +// .await +// .unwrap(); + +// let profile = ShinkaiName::new("@@test_user.shinkai/main".to_string()).unwrap(); + +// let vr = BaseVectorResource::Document(doc.clone()); + +// manager +// .save_resource(&vr, &profile.get_profile_name_string().unwrap()) +// .unwrap(); + +// manager.delete_resource(&doc.reference_string()).unwrap(); - let vr2 = manager.get_resource(&doc.reference_string(), &profile); +// let vr2 = manager.get_resource(&doc.reference_string(), &profile); - assert!(vr2.is_err()); - } -} +// assert!(vr2.is_err()); +// } +// } diff --git a/shinkai-libs/shinkai-sqlite/src/wallet_manager.rs b/shinkai-libs/shinkai-sqlite/src/wallet_manager.rs index ab05ebea8..a64514adc 100644 --- a/shinkai-libs/shinkai-sqlite/src/wallet_manager.rs +++ b/shinkai-libs/shinkai-sqlite/src/wallet_manager.rs @@ -48,7 +48,7 @@ impl SqliteManager { #[cfg(test)] mod tests { use super::*; - use shinkai_vector_resources::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; + use shinkai_embedding::model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}; use std::path::PathBuf; use tempfile::NamedTempFile; diff --git a/shinkai-libs/shinkai-tools-primitives/Cargo.toml b/shinkai-libs/shinkai-tools-primitives/Cargo.toml index 102d701f8..5628df97b 100644 --- a/shinkai-libs/shinkai-tools-primitives/Cargo.toml +++ b/shinkai-libs/shinkai-tools-primitives/Cargo.toml @@ -9,7 +9,7 @@ serde_json = { workspace = true } tokio = { workspace = true, features = ["full"] } regex = { workspace = true } shinkai_message_primitives = { workspace = true } -shinkai_vector_resources = { workspace = true } +# shinkai_vector_resources = { workspace = true } reqwest = { workspace = true, features = [ "json", "tokio-native-tls", diff --git a/shinkai-libs/shinkai-tools-primitives/src/tools/deno_tools.rs b/shinkai-libs/shinkai-tools-primitives/src/tools/deno_tools.rs index 9af694fd8..90b363424 100644 --- a/shinkai-libs/shinkai-tools-primitives/src/tools/deno_tools.rs +++ b/shinkai-libs/shinkai-tools-primitives/src/tools/deno_tools.rs @@ -20,7 +20,6 @@ use shinkai_tools_runner::tools::deno_runner_options::DenoRunnerOptions; use shinkai_tools_runner::tools::execution_context::ExecutionContext; use shinkai_tools_runner::tools::run_result::RunResult; use shinkai_tools_runner::tools::shinkai_node_location::ShinkaiNodeLocation; -use shinkai_vector_resources::embeddings::Embedding; use tokio::runtime::Runtime; #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] @@ -31,7 +30,8 @@ pub struct DenoTool { pub version: String, pub js_code: String, #[serde(default)] - #[serde(deserialize_with = "deserialize_tool_router_keys")] + #[serde(deserialize_with = "ToolRouterKey::deserialize_tool_router_keys")] + #[serde(serialize_with = "ToolRouterKey::serialize_tool_router_keys")] pub tools: Option>, pub config: Vec, pub description: String, @@ -39,7 +39,7 @@ pub struct DenoTool { pub input_args: Parameters, pub output_arg: ToolOutputArg, pub activated: bool, - pub embedding: Option, + pub embedding: Option>, pub result: ToolResult, pub sql_tables: Option>, pub sql_queries: Option>, @@ -48,24 +48,6 @@ pub struct DenoTool { pub assets: Option>, } -fn deserialize_tool_router_keys<'de, D>(deserializer: D) -> Result>, D::Error> -where - D: Deserializer<'de>, -{ - let string_vec: Option> = Option::deserialize(deserializer)?; - - match string_vec { - Some(vec) => { - let router_keys = vec - .into_iter() - .filter_map(|s| ToolRouterKey::from_string(&s).ok()) - .collect(); - Ok(Some(router_keys)) - } - None => Ok(None), - } -} - impl DenoTool { /// Default name of the rust toolkit pub fn toolkit_name(&self) -> String { diff --git a/shinkai-libs/shinkai-tools-primitives/src/tools/error.rs b/shinkai-libs/shinkai-tools-primitives/src/tools/error.rs index 6458d6e27..7903290ae 100644 --- a/shinkai-libs/shinkai-tools-primitives/src/tools/error.rs +++ b/shinkai-libs/shinkai-tools-primitives/src/tools/error.rs @@ -1,6 +1,5 @@ use reqwest::Error as ReqwestError; use serde_json::Error as SerdeError; -use shinkai_vector_resources::resource_errors::VRError; use std::error::Error; use std::fmt::{self}; @@ -13,7 +12,6 @@ pub enum ToolError { ToolkitVersionAlreadyInstalled(String, String), RequestError(ReqwestError), ToolNotFound(String), - VRError(VRError), ToolAlreadyInstalled(String), ToolkitAlreadyActivated(String), ToolkitAlreadyDeactivated(String), @@ -44,7 +42,6 @@ impl fmt::Display for ToolError { } ToolError::RequestError(ref e) => write!(f, "Request error: {}", e), ToolError::ToolNotFound(ref t) => write!(f, "Tool not found: {}", t), - ToolError::VRError(ref e) => write!(f, "{}", e), ToolError::ToolAlreadyInstalled(ref t) => write!(f, "Tool already installed: {}", t), ToolError::ToolkitAlreadyActivated(ref t) => write!(f, "Toolkit is already activated: {}", t), ToolError::ToolkitAlreadyDeactivated(ref t) => write!(f, "Toolkit is already deactivated: {}", t), @@ -67,12 +64,6 @@ impl fmt::Display for ToolError { impl Error for ToolError {} -impl From for ToolError { - fn from(err: VRError) -> ToolError { - ToolError::VRError(err) - } -} - impl From for ToolError { fn from(err: ReqwestError) -> ToolError { ToolError::RequestError(err) diff --git a/shinkai-libs/shinkai-tools-primitives/src/tools/js_toolkit.rs b/shinkai-libs/shinkai-tools-primitives/src/tools/js_toolkit.rs index 70153d253..c7caf9b1e 100644 --- a/shinkai-libs/shinkai-tools-primitives/src/tools/js_toolkit.rs +++ b/shinkai-libs/shinkai-tools-primitives/src/tools/js_toolkit.rs @@ -2,7 +2,6 @@ use crate::tools::deno_tools::DenoTool; use regex::Regex; use serde::{Deserialize, Serialize}; use shinkai_tools_runner::tools::tool_definition::ToolDefinition; -use shinkai_vector_resources::embeddings::Embedding; use super::{ deno_tools::ToolResult, @@ -66,10 +65,7 @@ impl JSToolkit { input_args: input_args.clone(), output_arg, activated: false, - embedding: definition.embedding_metadata.clone().map(|meta| Embedding { - id: "".to_string(), - vector: meta.embeddings, - }), + embedding: definition.embedding_metadata.clone().map(|meta| meta.embeddings), result, sql_tables: None, sql_queries: None, diff --git a/shinkai-libs/shinkai-tools-primitives/src/tools/network_tool.rs b/shinkai-libs/shinkai-tools-primitives/src/tools/network_tool.rs index 70f49c8c6..3792ebf82 100644 --- a/shinkai-libs/shinkai-tools-primitives/src/tools/network_tool.rs +++ b/shinkai-libs/shinkai-tools-primitives/src/tools/network_tool.rs @@ -1,5 +1,4 @@ use shinkai_message_primitives::schemas::{shinkai_name::ShinkaiName, shinkai_tool_offering::UsageType}; -use shinkai_vector_resources::embeddings::Embedding; use super::{tool_output_arg::ToolOutputArg, error::ToolError, parameters::Parameters, shinkai_tool::ShinkaiTool, tool_config::ToolConfig}; @@ -15,7 +14,7 @@ pub struct NetworkTool { pub config: Vec, pub input_args: Parameters, pub output_arg: ToolOutputArg, - pub embedding: Option, + pub embedding: Option>, pub restrictions: Option, // Could be a JSON string or a more structured type // ^ What was this for? I think it was *internal* user restrictions (e.g. max_requests_per_day, max_total_budget etc.) } @@ -34,7 +33,7 @@ impl NetworkTool { config: Vec, input_args: Parameters, output_arg: ToolOutputArg, - embedding: Option, + embedding: Option>, restrictions: Option, ) -> Self { Self { diff --git a/shinkai-libs/shinkai-tools-primitives/src/tools/python_tools.rs b/shinkai-libs/shinkai-tools-primitives/src/tools/python_tools.rs index 04ec4feb5..8043acfa5 100644 --- a/shinkai-libs/shinkai-tools-primitives/src/tools/python_tools.rs +++ b/shinkai-libs/shinkai-tools-primitives/src/tools/python_tools.rs @@ -4,7 +4,6 @@ use std::time::{SystemTime, UNIX_EPOCH}; use std::{env, thread}; use crate::tools::error::ToolError; -use serde::Deserialize; use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; use shinkai_message_primitives::schemas::tool_router_key::ToolRouterKey; use shinkai_tools_runner::tools::code_files::CodeFiles; @@ -13,7 +12,6 @@ use shinkai_tools_runner::tools::python_runner::PythonRunner; use shinkai_tools_runner::tools::python_runner_options::PythonRunnerOptions; use shinkai_tools_runner::tools::run_result::RunResult; use shinkai_tools_runner::tools::shinkai_node_location::ShinkaiNodeLocation; -use shinkai_vector_resources::embeddings::Embedding; use tokio::runtime::Runtime; use super::deno_tools::ToolResult; @@ -30,7 +28,9 @@ pub struct PythonTool { pub name: String, pub author: String, pub py_code: String, - #[serde(deserialize_with = "deserialize_tool_router_keys")] + #[serde(default)] + #[serde(deserialize_with = "ToolRouterKey::deserialize_tool_router_keys")] + #[serde(serialize_with = "ToolRouterKey::serialize_tool_router_keys")] pub tools: Option>, pub config: Vec, pub description: String, @@ -38,7 +38,7 @@ pub struct PythonTool { pub input_args: Parameters, pub output_arg: ToolOutputArg, pub activated: bool, - pub embedding: Option, + pub embedding: Option>, pub result: ToolResult, pub sql_tables: Option>, pub sql_queries: Option>, @@ -47,25 +47,6 @@ pub struct PythonTool { pub assets: Option>, } -fn deserialize_tool_router_keys<'de, D>(deserializer: D) -> Result>, D::Error> -where - D: serde::Deserializer<'de>, -{ - let string_vec: Option> = Option::deserialize(deserializer)?; - - match string_vec { - Some(vec) => { - let router_keys = vec - .into_iter() - .map(|s| ToolRouterKey::from_string(&s)) - .collect::, _>>() - .map_err(serde::de::Error::custom)?; - Ok(Some(router_keys)) - } - None => Ok(None), - } -} - impl PythonTool { /// Default name of the rust toolkit pub fn toolkit_name(&self) -> String { diff --git a/shinkai-libs/shinkai-tools-primitives/src/tools/rust_tools.rs b/shinkai-libs/shinkai-tools-primitives/src/tools/rust_tools.rs index 8d48352fe..9876fde1f 100644 --- a/shinkai-libs/shinkai-tools-primitives/src/tools/rust_tools.rs +++ b/shinkai-libs/shinkai-tools-primitives/src/tools/rust_tools.rs @@ -1,8 +1,8 @@ use std::fmt; +use shinkai_message_primitives::shinkai_utils::utils; + use crate::tools::error::ToolError; -use shinkai_vector_resources::embeddings::Embedding; -use shinkai_vector_resources::vector_resource::VRPath; use super::parameters::Parameters; use super::shinkai_tool::ShinkaiToolHeader; @@ -31,7 +31,7 @@ pub struct RustTool { pub description: String, pub input_args: Parameters, pub output_arg: ToolOutputArg, - pub tool_embedding: Option, + pub tool_embedding: Option>, pub tool_router_key: String, } @@ -41,11 +41,11 @@ impl RustTool { description: String, input_args: Parameters, output_arg: ToolOutputArg, - tool_embedding: Option, + tool_embedding: Option>, tool_router_key: String, ) -> Self { Self { - name: VRPath::clean_string(&name), + name: utils::clean_string(&name), description, input_args, output_arg, diff --git a/shinkai-libs/shinkai-tools-primitives/src/tools/shinkai_tool.rs b/shinkai-libs/shinkai-tools-primitives/src/tools/shinkai_tool.rs index f9d9891b8..96a05de79 100644 --- a/shinkai-libs/shinkai-tools-primitives/src/tools/shinkai_tool.rs +++ b/shinkai-libs/shinkai-tools-primitives/src/tools/shinkai_tool.rs @@ -3,13 +3,14 @@ use std::env; use crate::tools::error::ToolError; use crate::tools::rust_tools::RustTool; use serde_json::{self, Value}; + use shinkai_message_primitives::schemas::tool_router_key::ToolRouterKey; use shinkai_message_primitives::schemas::{ indexable_version::IndexableVersion, shinkai_tool_offering::{ShinkaiToolOffering, UsageType}, }; -use shinkai_vector_resources::embeddings::Embedding; +use super::tool_playground::{SqlQuery, SqlTable}; use super::{ deno_tools::DenoTool, network_tool::NetworkTool, parameters::Parameters, python_tools::PythonTool, tool_config::ToolConfig, tool_output_arg::ToolOutputArg, @@ -100,6 +101,19 @@ impl ShinkaiTool { } } + /// Sanitize the config by removing key-values from BasicConfig + pub fn sanitize_config(&mut self) { + match self { + ShinkaiTool::Deno(d, _) => { + d.config = d.config.clone().iter().map(|config| config.sanitize()).collect(); + } + ShinkaiTool::Python(p, _) => { + p.config = p.config.clone().iter().map(|config| config.sanitize()).collect(); + } + _ => (), + } + } + /// Generate the key that this tool will be stored under in the tool router pub fn gen_router_key(source: String, toolkit_name: String, name: String) -> String { let tool_router_key = ToolRouterKey::new(source, toolkit_name, name, None); @@ -165,6 +179,24 @@ impl ShinkaiTool { } } + /// Returns the SQL queries of the tool + pub fn sql_queries(&self) -> Vec { + match self { + ShinkaiTool::Deno(d, _) => d.sql_queries.clone().unwrap_or_default(), + ShinkaiTool::Python(p, _) => p.sql_queries.clone().unwrap_or_default(), + _ => vec![], + } + } + + /// Returns the SQL tables of the tool + pub fn sql_tables(&self) -> Vec { + match self { + ShinkaiTool::Deno(d, _) => d.sql_tables.clone().unwrap_or_default(), + ShinkaiTool::Python(p, _) => p.sql_tables.clone().unwrap_or_default(), + _ => vec![], + } + } + /// Returns a formatted summary of the tool pub fn formatted_tool_summary_for_ui(&self) -> String { format!( @@ -176,7 +208,7 @@ impl ShinkaiTool { } /// Sets the embedding for the tool - pub fn set_embedding(&mut self, embedding: Embedding) { + pub fn set_embedding(&mut self, embedding: Vec) { match self { ShinkaiTool::Rust(r, _) => r.tool_embedding = Some(embedding), ShinkaiTool::Network(n, _) => n.embedding = Some(embedding), @@ -218,7 +250,7 @@ impl ShinkaiTool { } /// Returns the embedding if it exists - pub fn get_embedding(&self) -> Option { + pub fn get_embedding(&self) -> Option> { match self { ShinkaiTool::Rust(r, _) => r.tool_embedding.clone(), ShinkaiTool::Network(n, _) => n.embedding.clone(), @@ -348,11 +380,13 @@ impl ShinkaiTool { matches!(self, ShinkaiTool::Network(_, _)) } + pub fn version_indexable(&self) -> Result { + IndexableVersion::from_string(&self.version()) + } + /// Returns the version number using IndexableVersion pub fn version_number(&self) -> Result { - let version_str = self.version(); - - let indexable_version = IndexableVersion::from_string(&version_str)?; + let indexable_version = self.version_indexable()?; Ok(indexable_version.get_version_number()) } } @@ -522,10 +556,7 @@ mod tests { "toolkit_name": "shinkai-tool-coinbase-get-my-address", "sql_tables": [], "sql_queries": [], - "embedding": { - "id": "", - "vector": [] - }, + "embedding": [], "oauth": null, "config": [], "keywords": [ diff --git a/shinkai-libs/shinkai-vector-fs/Cargo.toml b/shinkai-libs/shinkai-vector-fs/Cargo.toml deleted file mode 100644 index 646dffb69..000000000 --- a/shinkai-libs/shinkai-vector-fs/Cargo.toml +++ /dev/null @@ -1,20 +0,0 @@ -[package] -name = "shinkai_vector_fs" -version = { workspace = true } -edition = { workspace = true } -authors = { workspace = true } - -[dependencies] -shinkai_message_primitives = { path = "../shinkai-message-primitives" } -shinkai_sqlite = { workspace = true } -shinkai_vector_resources = { workspace = true } -bincode = { workspace = true } -serde_json = { workspace = true } -rand = { workspace = true } -blake3 = { workspace = true } -tokio = { workspace = true, features = ["full"] } -chrono = { workspace = true } - -[dependencies.serde] -workspace = true -features = ["derive"] diff --git a/shinkai-libs/shinkai-vector-fs/src/lib.rs b/shinkai-libs/shinkai-vector-fs/src/lib.rs deleted file mode 100644 index b9b47d6f2..000000000 --- a/shinkai-libs/shinkai-vector-fs/src/lib.rs +++ /dev/null @@ -1,2 +0,0 @@ -pub mod vector_fs; -pub mod welcome_files; \ No newline at end of file diff --git a/shinkai-libs/shinkai-vector-fs/src/vector_fs/mod.rs b/shinkai-libs/shinkai-vector-fs/src/vector_fs/mod.rs deleted file mode 100644 index 7d1e665f3..000000000 --- a/shinkai-libs/shinkai-vector-fs/src/vector_fs/mod.rs +++ /dev/null @@ -1,8 +0,0 @@ -pub mod vector_fs; -pub mod vector_fs_error; -pub mod vector_fs_internals; -pub mod vector_fs_permissions; -pub mod vector_fs_reader; -pub mod vector_fs_search; -pub mod vector_fs_types; -pub mod vector_fs_writer; diff --git a/shinkai-libs/shinkai-vector-fs/src/vector_fs/vector_fs.rs b/shinkai-libs/shinkai-vector-fs/src/vector_fs/vector_fs.rs deleted file mode 100644 index 806db17a6..000000000 --- a/shinkai-libs/shinkai-vector-fs/src/vector_fs/vector_fs.rs +++ /dev/null @@ -1,387 +0,0 @@ -use super::vector_fs_internals::VectorFSInternals; - -use crate::welcome_files::shinkai_faq::SHINKAI_FAQ_VRKAI; -use crate::welcome_files::shinkai_whitepaper::SHINKAI_WHITEPAPER_VRKAI; - -use super::vector_fs_error::VectorFSError; -use super::vector_fs_reader::VFSReader; -use super::vector_fs_writer::VFSWriter; -use chrono::{DateTime, Utc}; -use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; -use shinkai_sqlite::SqliteManager; -use shinkai_vector_resources::embedding_generator::{EmbeddingGenerator, RemoteEmbeddingGenerator}; -use shinkai_vector_resources::model_type::EmbeddingModelType; -use shinkai_vector_resources::vector_resource::{VRKai, VRPath, VectorResourceCore, VectorResourceSearch}; -use std::collections::HashMap; -use std::sync::Arc; -use tokio::sync::RwLock; - -/// Struct that wraps all functionality of the VectorFS. -/// Of note, internals_map holds a hashmap of the VectorFSInternals -/// for all profiles on the node. -#[derive(Debug)] -pub struct VectorFS { - pub node_name: ShinkaiName, - pub internals_map: RwLock>, - pub db: Arc, - /// Intended to be used only for generating query embeddings for Vector Search - /// Processing content into Vector Resources should always be done outside of the VectorFS - /// to prevent locking for long periods of time. (If VR with unsupported model is tried to be added to FS, should error, and regeneration happens externally) - pub embedding_generator: RemoteEmbeddingGenerator, -} - -impl VectorFS { - /// Initializes the VectorFS struct. If no existing VectorFS exists in the VectorFSDB, then initializes from scratch. - /// Otherwise reads from the FSDB. Requires supplying list of profiles setup in the node. - /// Auto-initializes new profiles, setting their default embedding model to be based on the supplied embedding_generator. - pub async fn new( - embedding_generator: RemoteEmbeddingGenerator, - supported_embedding_models: Vec, - profile_list: Vec, - db: Arc, - node_name: ShinkaiName, - ) -> Result { - // Read each existing profile's fs internals from fsdb - let mut internals_map = HashMap::new(); - for profile in &profile_list { - match db.get_profile_fs_internals(profile) { - Ok(internals) => { - let internals = VectorFSInternals { - fs_core_resource: internals.0, - permissions_index: serde_json::from_slice(&internals.1) - .map_err(|e| VectorFSError::DataConversionError(e.to_string()))?, - subscription_index: serde_json::from_slice(&internals.2) - .map_err(|e| VectorFSError::DataConversionError(e.to_string()))?, - supported_embedding_models: internals.3, - last_read_index: serde_json::from_slice(&internals.4) - .map_err(|e| VectorFSError::DataConversionError(e.to_string()))?, - }; - internals_map.insert(profile.clone(), internals); - } - _ => continue, - } - } - - let internals_map = RwLock::new(internals_map); - - // Initialize the VectorFS - let default_embedding_model = embedding_generator.model_type().clone(); - let vector_fs = Self { - internals_map, - db, - embedding_generator, - node_name: node_name.clone(), - }; - - // Initialize any new profiles which don't already exist in the VectorFS - vector_fs - .initialize_new_profiles( - &node_name, - profile_list, - default_embedding_model, - supported_embedding_models, - false, - ) - .await?; - - Ok(vector_fs) - } - - /// Creates a new VFSReader if the `requester_name` passes read permission validation check. - /// VFSReader can then be used to perform read actions at the specified path. - pub async fn new_reader( - &self, - requester_name: ShinkaiName, - path: VRPath, - profile: ShinkaiName, - ) -> Result { - VFSReader::new(requester_name, path, self, profile).await - } - - /// Creates a new VFSWriter if the `requester_name` passes write permission validation check. - /// VFSWriter can then be used to perform write actions at the specified path. - pub async fn new_writer( - &self, - requester_name: ShinkaiName, - path: VRPath, - profile: ShinkaiName, - ) -> Result { - VFSWriter::new(requester_name, path, self, profile).await - } - - /// Initializes a new profile and inserts it into the internals_map - pub async fn initialize_profile( - &self, - requester_name: &ShinkaiName, - profile: ShinkaiName, - default_embedding_model: EmbeddingModelType, - supported_embedding_models: Vec, - ) -> Result<(), VectorFSError> { - self._validate_node_action_permission(requester_name, &format!("Failed initializing profile {}.", profile))?; - - if let Err(_) = self.get_profile_fs_internals(&profile).await { - // Extract just the node name from the profile name - let fs_internals = - VectorFSInternals::new(profile.clone(), default_embedding_model, supported_embedding_models).await; - - self.save_profile_fs_internals(fs_internals, &profile).await?; - } - - let internals = self.get_profile_fs_internals(&profile).await?; - - // Acquire a write lock to modify internals_map - let mut internals_map = self.internals_map.write().await; - internals_map.insert(profile, internals); - Ok(()) - } - - /// Checks the input profile_list and initializes a new profile for any which are not already set up in the VectorFS. - pub async fn initialize_new_profiles( - &self, - requester_name: &ShinkaiName, - profile_list: Vec, - default_embedding_model: EmbeddingModelType, - supported_embedding_models: Vec, - create_default_folders: bool, - ) -> Result<(), VectorFSError> { - // Acquire a read lock for checking existing profiles - let mut internals_map_read = self.internals_map.read().await; - - for profile in profile_list { - if !internals_map_read.contains_key(&profile) { - // Drop the read lock before awaiting on the async initialize_profile - drop(internals_map_read); - - // Since initialize_profile is async, await on it - self.initialize_profile( - requester_name, - profile.clone(), // Assuming clone is cheap for ShinkaiName - default_embedding_model.clone(), - supported_embedding_models.clone(), - ) - .await?; - - // Creates default folders and files if create_default_folders is true - if create_default_folders { - let writer = self - .new_writer(profile.clone(), VRPath::root(), profile.clone()) - .await?; - self.create_new_folder(&writer, "My Files (Private)").await?; - self.create_new_folder(&writer, "My Subscriptions").await?; - self.create_new_folder(&writer, "For Sharing").await?; - - let my_files = VRPath::from_string("/My Files (Private)").unwrap(); - let writer = self - .new_writer(profile.clone(), my_files.clone(), profile.clone()) - .await?; - self.create_new_folder(&writer, "Shinkai").await?; - - // Create a default file in the "My Files (Private)" folder - let shinkai_folder = my_files.push_cloned("Shinkai".to_string()); - let writer = self - .new_writer(profile.clone(), shinkai_folder, profile.clone()) - .await?; - let shinkai_faq = VRKai::from_base64(SHINKAI_FAQ_VRKAI).unwrap(); - let shinkai_whitepaper = VRKai::from_base64(SHINKAI_WHITEPAPER_VRKAI).unwrap(); - let _save_result = self.save_vrkai_in_folder(&writer, shinkai_faq).await; - let _save_result = self.save_vrkai_in_folder(&writer, shinkai_whitepaper).await; - } - - // Re-acquire the read lock for the next iteration - internals_map_read = self.internals_map.read().await; - } - } - Ok(()) - } - - /// Reverts the internals of a profile to the last saved state in the database. - pub async fn revert_internals_to_last_db_save( - &self, - requester_name: &ShinkaiName, - profile: &ShinkaiName, - ) -> Result<(), VectorFSError> { - // Validate the requester's permission to perform this action - self._validate_profile_action_permission( - requester_name, - profile, - &format!("Failed reverting fs internals to last DB save for profile: {}", profile), - ) - .await?; - - // Fetch the last saved state of the profile fs internals from the database - let internals = self.get_profile_fs_internals(profile).await?; - - // Acquire a write lock asynchronously to modify internals_map - let mut internals_map = self.internals_map.write().await; - - // Overwrite the current state of the profile internals in the map with the fetched state - internals_map.insert(profile.clone(), internals); - - Ok(()) - } - - /// Sets the supported embedding models for a specific profile - pub async fn set_profile_supported_models( - &self, - requester_name: &ShinkaiName, - profile: &ShinkaiName, - supported_models: Vec, - ) -> Result<(), VectorFSError> { - self._validate_node_action_permission(requester_name, "Failed setting all profile supported models.")?; - - // Acquire a write lock asynchronously to modify internals_map - let mut internals_map = self.internals_map.write().await; - - if let Some(fs_internals) = internals_map.get_mut(profile) { - fs_internals.supported_embedding_models = supported_models; - // Assuming save_profile_fs_internals is async, you need to await it - self.save_profile_fs_internals(fs_internals.clone(), profile).await?; - } - Ok(()) - } - - /// Get a prepared Embedding Generator that is setup with the correct default EmbeddingModelType - /// for the profile's VectorFS. - pub async fn _get_embedding_generator( - &self, - profile: &ShinkaiName, - ) -> Result { - let internals = self.get_profile_fs_internals_cloned(profile).await?; - let generator = internals.fs_core_resource.initialize_compatible_embeddings_generator( - &self.embedding_generator.api_url, - self.embedding_generator.api_key.clone(), - ); - Ok(generator) - } - - /// Validates the permission for a node action for a given requester ShinkaiName. Internal method. - /// In case of error, includes requester_name automatically together with your error message - pub fn _validate_node_action_permission( - &self, - requester_name: &ShinkaiName, - error_message: &str, - ) -> Result<(), VectorFSError> { - if self.node_name.node_name == requester_name.node_name { - return Ok(()); - } - Err(VectorFSError::InvalidNodeActionPermission( - requester_name.clone(), - error_message.to_string(), - )) - } - - /// Validates the permission for a profile action for a given requester ShinkaiName. Internal method. - /// In case of error, includes requester_name automatically together with your error message - pub async fn _validate_profile_action_permission( - &self, - requester_name: &ShinkaiName, - profile: &ShinkaiName, - error_message: &str, - ) -> Result<(), VectorFSError> { - if let Ok(_) = self.get_profile_fs_internals_cloned(profile).await { - if profile.profile_name == requester_name.profile_name { - return Ok(()); - } - } - Err(VectorFSError::InvalidProfileActionPermission( - requester_name.clone(), - error_message.to_string(), - )) - } - - /// Attempts to fetch a copy of the profile VectorFSInternals (from memory) - /// in the internals_map. ANY MUTATION DOESN'T PROPAGATE. - pub async fn get_profile_fs_internals_cloned( - &self, - profile: &ShinkaiName, - ) -> Result { - let internals_map = self.internals_map.read().await; - let internals = internals_map - .get(profile) - .ok_or_else(|| VectorFSError::ProfileNameNonExistent(profile.to_string()))? - .clone(); - - Ok(internals) - } - - /// Updates the fs_internals for a specific profile. Applies only in memory. - /// This function should be used with caution as it directly modifies the internals. - pub async fn _update_fs_internals( - &self, - profile: ShinkaiName, - new_internals: VectorFSInternals, - ) -> Result<(), VectorFSError> { - // Acquire a write lock to modify internals_map - let mut internals_map = self.internals_map.write().await; - - // Update the internals for the specified profile - internals_map.insert(profile, new_internals); - - Ok(()) - } - - /// Updates the last read path and time for a given profile. - pub async fn update_last_read_path( - &self, - profile: &ShinkaiName, - path: VRPath, - current_datetime: DateTime, - requester_name: ShinkaiName, - ) -> Result<(), VectorFSError> { - let mut internals_map = self.internals_map.write().await; - let internals = internals_map - .get_mut(profile) - .ok_or_else(|| VectorFSError::ProfileNameNonExistent(profile.to_string()))?; - - internals - .last_read_index - .update_path_last_read(path, current_datetime, requester_name); - Ok(()) - } - - /// Prints the internal nodes (of the core VR) of a Profile's VectorFS - pub async fn print_profile_vector_fs_resource(&self, profile: ShinkaiName) { - let internals = self.get_profile_fs_internals_cloned(&profile).await.unwrap(); - println!( - "\n\n{}'s VectorFS Internal Resource Representation\n------------------------------------------------", - profile.clone() - ); - internals.fs_core_resource.print_all_nodes_exhaustive(None, true, false); - } - - pub async fn save_profile_fs_internals( - &self, - fs_internals: VectorFSInternals, - profile: &ShinkaiName, - ) -> Result<(), VectorFSError> { - self.db - .save_profile_fs_internals( - profile, - fs_internals.fs_core_resource, - serde_json::to_vec(&fs_internals.permissions_index) - .map_err(|e| VectorFSError::DataConversionError(e.to_string()))?, - serde_json::to_vec(&fs_internals.subscription_index) - .map_err(|e| VectorFSError::DataConversionError(e.to_string()))?, - fs_internals.supported_embedding_models, - serde_json::to_vec(&fs_internals.last_read_index) - .map_err(|e| VectorFSError::DataConversionError(e.to_string()))?, - ) - .map_err(|e| VectorFSError::SqliteManagerError(e)) - } - - pub async fn get_profile_fs_internals(&self, profile: &ShinkaiName) -> Result { - let (core_resource, permissions_index, subscription_index, supported_embedding_models, last_read_index) = - self.db.get_profile_fs_internals(profile)?; - - Ok(VectorFSInternals { - fs_core_resource: core_resource, - permissions_index: serde_json::from_slice(&permissions_index) - .map_err(|e| VectorFSError::DataConversionError(e.to_string()))?, - subscription_index: serde_json::from_slice(&subscription_index) - .map_err(|e| VectorFSError::DataConversionError(e.to_string()))?, - supported_embedding_models, - last_read_index: serde_json::from_slice(&last_read_index) - .map_err(|e| VectorFSError::DataConversionError(e.to_string()))?, - }) - } -} diff --git a/shinkai-libs/shinkai-vector-fs/src/vector_fs/vector_fs_error.rs b/shinkai-libs/shinkai-vector-fs/src/vector_fs/vector_fs_error.rs deleted file mode 100644 index 168bc1e89..000000000 --- a/shinkai-libs/shinkai-vector-fs/src/vector_fs/vector_fs_error.rs +++ /dev/null @@ -1,256 +0,0 @@ -use core::fmt; -use shinkai_message_primitives::{ - schemas::shinkai_name::{ShinkaiName, ShinkaiNameError}, - shinkai_message::shinkai_message_error::ShinkaiMessageError, -}; -use shinkai_sqlite::errors::SqliteManagerError; -use shinkai_vector_resources::{model_type::EmbeddingModelType, resource_errors::VRError, vector_resource::VRPath}; -use std::{io, str::Utf8Error}; - -#[derive(Debug)] -pub enum VectorFSError { - ShinkaiNameError(ShinkaiNameError), - SqliteManagerError(SqliteManagerError), - IOError(io::Error), - InvalidIdentityType(String), - Utf8ConversionError, - SomeError(String), - ProfileNameNonExistent(String), - InvalidData, - JsonSerializationError(serde_json::Error), - DataConversionError(String), - DataNotFound, - VRError(VRError), - FailedFetchingCF, - FailedFetchingValue, - ShinkaiMessageError(String), - BincodeError(bincode::Error), - MissingValue(String), - ColumnFamilyNotFound(String), - ShinkaiNameLacksProfile, - InvalidNodeActionPermission(ShinkaiName, String), - InvalidProfileActionPermission(ShinkaiName, String), - InvalidReaderPermission(ShinkaiName, ShinkaiName, VRPath), - InvalidWriterPermission(ShinkaiName, ShinkaiName, VRPath), - InvalidReadPermission(ShinkaiName, VRPath), - InvalidWritePermission(ShinkaiName, VRPath), - NoSourceFileAvailable(String), - InvalidFSEntryType(String), - EmbeddingModelTypeMismatch(EmbeddingModelType, EmbeddingModelType), - EmbeddingMissingInResource(String), - InvalidMetadata(String), - FailedCreatingProfileBoundWriteBatch(String), - CannotOverwriteFolder(VRPath), - CannotOverwriteFSEntry(VRPath), - PathDoesNotPointAtItem(VRPath), - PathDoesNotPointAtFolder(VRPath), - NoEntryAtPath(VRPath), - NoPermissionEntryAtPath(VRPath), - EntryAlreadyExistsAtPath(VRPath), - DateTimeParseError(String), - FailedGettingFSPathOfRetrievedNode(String), - CannotMoveFolderIntoItself(VRPath), - LockAcquisitionFailed, -} - -impl fmt::Display for VectorFSError { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match self { - VectorFSError::SqliteManagerError(e) => write!(f, "SqliteManager error: {}", e), - VectorFSError::SomeError(e) => write!(f, "Some error: {}", e), - VectorFSError::ShinkaiNameLacksProfile => write!( - f, - "Provided ShinkaiName does not specify a profile which is required for DB action.", - ), - - VectorFSError::ProfileNameNonExistent(e) => { - write!(f, "Profile name does not exist: {}", e) - } - VectorFSError::IOError(e) => write!(f, "IO Error: {}", e), - VectorFSError::InvalidData => write!(f, "Invalid data"), - VectorFSError::ShinkaiMessageError(e) => write!(f, "ShinkaiMessage error: {}", e), - VectorFSError::InvalidIdentityType(e) => write!(f, "Invalid identity type: {}", e), - VectorFSError::ShinkaiNameError(e) => write!(f, "Shinkai name error: {}", e), - VectorFSError::MissingValue(e) => write!(f, "Missing value: {}", e), - VectorFSError::ColumnFamilyNotFound(e) => write!(f, "Column family not found: {}", e), - VectorFSError::DataConversionError(e) => write!(f, "Data conversion error: {}", e), - VectorFSError::Utf8ConversionError => write!(f, "UTF8 conversion error"), - VectorFSError::JsonSerializationError(e) => write!(f, "Json Serialization Error: {}", e), - VectorFSError::DataNotFound => write!(f, "Data not found"), - VectorFSError::FailedFetchingCF => write!(f, "Failed fetching Column Family"), - VectorFSError::FailedFetchingValue => write!(f, "Failed fetching value. Likely invalid CF or key."), - VectorFSError::VRError(e) => write!(f, "{}", e), - VectorFSError::BincodeError(e) => write!(f, "Bincode error: {}", e), - VectorFSError::InvalidNodeActionPermission(name, error_message) => write!( - f, - "{} has no permission to perform a VectorFS Node action: {}", - name, error_message - ), - VectorFSError::InvalidProfileActionPermission(name, error_message) => write!( - f, - "{} has no permission to perform a VectorFS Profile action: {}", - name, error_message - ), - VectorFSError::InvalidReaderPermission(name, profile, path) => write!( - f, - "{} has no permission to read {}'s VectorFS at path: {}", - name, - profile, - path.format_to_string() - ), - VectorFSError::InvalidWriterPermission(name, profile, path) => write!( - f, - "{} has no permission to write in {}'s VectorFS at path: {}", - name, - profile, - path.format_to_string() - ), - VectorFSError::NoSourceFileAvailable(s) => write!(f, "No SourceFile available for: {}", s), - VectorFSError::InvalidFSEntryType(s) => { - write!(f, "Parsing FSEntry into specific type failed at path: {}", s) - } - VectorFSError::EmbeddingModelTypeMismatch(a, b) => { - write!(f, "Embedding model mismatch: {} vs. {}", a, b) - } - VectorFSError::EmbeddingMissingInResource(s) => { - write!(f, "Embedding is not defined in resource: {} ", s) - } - VectorFSError::InvalidMetadata(e) => write!(f, "Invalid metadata at key: {}", e), - VectorFSError::FailedCreatingProfileBoundWriteBatch(e) => { - write!(f, "Failed parsing profile and creating a write batch for: {}", e) - } - VectorFSError::CannotOverwriteFolder(e) => write!(f, "Cannot write over existing folder at: {}", e), - VectorFSError::CannotOverwriteFSEntry(e) => write!(f, "Cannot write over existing filesystem entry at: {}", e), - VectorFSError::PathDoesNotPointAtFolder(e) => { - write!(f, "Entry at supplied path does not hold a Filesystem Folder: {}", e) - } - VectorFSError::PathDoesNotPointAtItem(e) => { - write!(f, "Entry at supplied path does not hold a Filesystem Item: {}", e) - } - VectorFSError::NoEntryAtPath(e) => { - write!( - f, - "Supplied path does not exist in the VectorFS: {}", - e - ) - } - VectorFSError::NoPermissionEntryAtPath(e) => { - write!( - f, - "Path does not have a path permission specified in the VectorFS: {}", - e - ) - } - VectorFSError::EntryAlreadyExistsAtPath(p) => { - write!(f, "FSEntry already exists at path, and cannot overwrite: {}", p) - } - - VectorFSError::DateTimeParseError(e) => write!(f, "Datetime Parse Error: {}", e), - VectorFSError::InvalidReadPermission(n, p) => { - write!(f, "{} does not have read permissions for path: {}", n, p) - } - VectorFSError::InvalidWritePermission(n, p) => { - write!(f, "{} does not have write permissions for path: {}", n, p) - } - VectorFSError::FailedGettingFSPathOfRetrievedNode(s) => write!(f, "While performing 2-tier 'deep' vector search, unable to get VectorFS path of the VR the retrieved node was from: {}", s), - VectorFSError::CannotMoveFolderIntoItself(e) => write!(f, "Cannot move folder into itself at a deeper level: {}", e), - VectorFSError::LockAcquisitionFailed => write!(f, "Failed to acquire lock"), - } - } -} - -impl std::error::Error for VectorFSError { - fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { - match self { - VectorFSError::SqliteManagerError(e) => Some(e), - VectorFSError::JsonSerializationError(e) => Some(e), - VectorFSError::IOError(e) => Some(e), - VectorFSError::VRError(e) => Some(e), - VectorFSError::BincodeError(e) => Some(e), - _ => None, - } - } -} - -impl PartialEq for VectorFSError { - fn eq(&self, other: &Self) -> bool { - match (self, other) { - (VectorFSError::InvalidIdentityType(msg1), VectorFSError::InvalidIdentityType(msg2)) => msg1 == msg2, - (VectorFSError::SomeError(msg1), VectorFSError::SomeError(msg2)) => msg1 == msg2, - (VectorFSError::ProfileNameNonExistent(msg1), VectorFSError::ProfileNameNonExistent(msg2)) => msg1 == msg2, - (VectorFSError::MissingValue(msg1), VectorFSError::MissingValue(msg2)) => msg1 == msg2, - (VectorFSError::ColumnFamilyNotFound(msg1), VectorFSError::ColumnFamilyNotFound(msg2)) => msg1 == msg2, - (VectorFSError::DataConversionError(msg1), VectorFSError::DataConversionError(msg2)) => msg1 == msg2, - (VectorFSError::IOError(e1), VectorFSError::IOError(e2)) => e1.to_string() == e2.to_string(), - (VectorFSError::SqliteManagerError(e1), VectorFSError::SqliteManagerError(e2)) => { - e1.to_string() == e2.to_string() - } - (VectorFSError::Utf8ConversionError, VectorFSError::Utf8ConversionError) => true, - (VectorFSError::JsonSerializationError(e1), VectorFSError::JsonSerializationError(e2)) => { - e1.to_string() == e2.to_string() - } - (VectorFSError::DataNotFound, VectorFSError::DataNotFound) => true, - (VectorFSError::FailedFetchingCF, VectorFSError::FailedFetchingCF) => true, - (VectorFSError::FailedFetchingValue, VectorFSError::FailedFetchingValue) => true, - (VectorFSError::VRError(e1), VectorFSError::VRError(e2)) => e1 == e2, // assuming VRError implements PartialEq - (VectorFSError::BincodeError(e1), VectorFSError::BincodeError(e2)) => e1.to_string() == e2.to_string(), - _ => false, - } - } -} - -impl From for VectorFSError { - fn from(err: VRError) -> VectorFSError { - VectorFSError::VRError(err) - } -} - -impl From for VectorFSError { - fn from(error: SqliteManagerError) -> Self { - VectorFSError::SqliteManagerError(error) - } -} - -impl From for VectorFSError { - fn from(error: io::Error) -> Self { - VectorFSError::IOError(error) - } -} - -impl From for VectorFSError { - fn from(error: serde_json::Error) -> Self { - VectorFSError::JsonSerializationError(error) - } -} - -impl From for VectorFSError { - fn from(_: Utf8Error) -> Self { - VectorFSError::Utf8ConversionError - } -} - -impl From for VectorFSError { - fn from(error: bincode::Error) -> Self { - VectorFSError::BincodeError(error) - } -} - -impl From for VectorFSError { - fn from(error: ShinkaiNameError) -> Self { - VectorFSError::ShinkaiNameError(error) - } -} - -impl From for VectorFSError { - fn from(err: ShinkaiMessageError) -> VectorFSError { - // Convert the ShinkaiMessageError into a VectorFSError - // You might want to add a new variant to VectorFSError for this - VectorFSError::ShinkaiMessageError(err.to_string()) - } -} - -impl From for VectorFSError { - fn from(err: chrono::ParseError) -> VectorFSError { - VectorFSError::DateTimeParseError(err.to_string()) - } -} diff --git a/shinkai-libs/shinkai-vector-fs/src/vector_fs/vector_fs_internals.rs b/shinkai-libs/shinkai-vector-fs/src/vector_fs/vector_fs_internals.rs deleted file mode 100644 index e9549c876..000000000 --- a/shinkai-libs/shinkai-vector-fs/src/vector_fs/vector_fs_internals.rs +++ /dev/null @@ -1,77 +0,0 @@ -use super::{ - vector_fs_permissions::PermissionsIndex, - vector_fs_types::{LastReadIndex, SubscriptionsIndex}, -}; -use serde_json; -use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; -use shinkai_vector_resources::{ - embeddings::Embedding, - model_type::{EmbeddingModelType, OllamaTextEmbeddingsInference}, - source::DistributionInfo, - vector_resource::{MapVectorResource, VRSourceReference, VectorResourceCore}, -}; -use std::collections::HashMap; - -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct VectorFSInternals { - pub fs_core_resource: MapVectorResource, - pub permissions_index: PermissionsIndex, - pub subscription_index: SubscriptionsIndex, - pub supported_embedding_models: Vec, - pub last_read_index: LastReadIndex, -} - -impl VectorFSInternals { - pub async fn new( - node_name: ShinkaiName, - default_embedding_model_used: EmbeddingModelType, - supported_embedding_models: Vec, - ) -> Self { - let core_resource = MapVectorResource::new( - "VecFS Core Resource", - None, - VRSourceReference::None, - Embedding::new("", vec![]), - HashMap::new(), - HashMap::new(), - default_embedding_model_used, - true, - DistributionInfo::new_empty(), - ); - Self { - fs_core_resource: core_resource, - permissions_index: PermissionsIndex::new(node_name).await, - subscription_index: SubscriptionsIndex::new_empty(), - supported_embedding_models, - last_read_index: LastReadIndex::new_empty(), - } - } - - /// IMPORTANT: This creates a barebones empty struct, intended to be used for tests - /// that do not require a real filled out internals struct. - pub async fn new_empty() -> Self { - let node_name = ShinkaiName::from_node_name("@@node1_test.shinkai".to_string()).unwrap(); - let default_embedding_model = - EmbeddingModelType::OllamaTextEmbeddingsInference(OllamaTextEmbeddingsInference::SnowflakeArcticEmbed_M); - let supported_embedding_models = vec![default_embedding_model.clone()]; - Self::new(node_name, default_embedding_model, supported_embedding_models).await - } - - /// Returns the default Embedding model used by the profile's VecFS. - pub fn default_embedding_model(&self) -> EmbeddingModelType { - self.fs_core_resource.embedding_model_used() - } - - /// A hard-coded DB key for the profile-wide VectorFSInternals. - pub fn profile_fs_internals_shinkai_db_key() -> String { - "profile_vector_fs_internals".to_string() - } - - pub fn to_json(&self) -> serde_json::Result { - serde_json::to_string(self) - } - - pub fn from_json(s: &str) -> serde_json::Result { - serde_json::from_str(s) - } -} diff --git a/shinkai-libs/shinkai-vector-fs/src/vector_fs/vector_fs_permissions.rs b/shinkai-libs/shinkai-vector-fs/src/vector_fs/vector_fs_permissions.rs deleted file mode 100644 index 79e5b8058..000000000 --- a/shinkai-libs/shinkai-vector-fs/src/vector_fs/vector_fs_permissions.rs +++ /dev/null @@ -1,856 +0,0 @@ -use serde::{Deserialize, Deserializer, Serialize, Serializer}; -use serde_json::json; -use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; -use shinkai_vector_resources::vector_resource::{VRPath, VectorResourceSearch}; -use std::{collections::HashMap, thread, time::Duration}; -use tokio::sync::{RwLock, RwLockReadGuard}; - -use super::{ - vector_fs::VectorFS, vector_fs_error::VectorFSError, vector_fs_reader::VFSReader, vector_fs_writer::VFSWriter, -}; - -/// Struct that holds the read/write permissions specified for a specific path in the VectorFS -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct PathPermission { - pub read_permission: ReadPermission, - pub write_permission: WritePermission, - /// Whitelist which specifies per ShinkaiName which perms they have. Checked - /// if either read or write perms are set to Whitelist, respectively. - pub whitelist: HashMap, -} - -impl PathPermission { - /// Get the whitelist permission for a given ShinkaiName. - /// If the ShinkaiName is not found (ie. profile's name), checks if permission exists for its node/global name instead. - pub fn get_whitelist_permission(&self, requester_name: &ShinkaiName) -> Option<&WhitelistPermission> { - let node_name = ShinkaiName::from_node_name(requester_name.node_name.clone()).ok()?; - self.whitelist - .get(requester_name) - .or_else(|| self.whitelist.get(&node_name)) - } - - /// Serialize the PathPermission struct into a JSON string - pub fn to_json(&self) -> Result { - serde_json::to_string(self) - } - - /// Deserialize a JSON string into a PathPermission struct - pub fn from_json(json: &str) -> Result { - serde_json::from_str(json) - } -} - -/// Enum representing the different types of read permissions a VRPath can have. -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub enum ReadPermission { - /// Only your profile has access - Private, - /// One or more specific profiles on your node - NodeProfiles(Vec), - /// Specific identities on the Shinkai Network have access - Whitelist, - /// Anybody on the Shinkai Network has access - Public, -} - -/// Enum representing the different types of write permissions a VRPath can have. -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub enum WritePermission { - /// Only your profile has access - Private, - /// One or more specific profiles on your node - NodeProfiles(Vec), - /// Specific identities on the Shinkai Network have access - Whitelist, -} - -/// Enum describing what kind of permission for a specific path that a user has -/// on the whitelist -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub enum WhitelistPermission { - Read, - Write, - ReadWrite, -} - -/// Struct holding the VectorFS' permissions for a given profile. -/// Note we store the PathPermissions as json strings internally to support efficient -/// permission checking during VectorFS vector searches. -#[derive(Debug)] -pub struct PermissionsIndex { - /// Map which defines the kind of read and write permission per path in the VectorFS - pub fs_permissions: RwLock>, - /// ShinkaiName of the profile this permissions index is for. - pub profile_name: ShinkaiName, -} - -impl Clone for PermissionsIndex { - fn clone(&self) -> Self { - loop { - match self.fs_permissions.try_read() { - Ok(fs_permissions_guard) => { - let cloned_fs_permissions = fs_permissions_guard.clone(); - drop(fs_permissions_guard); // Explicitly drop the guard to release the lock - return PermissionsIndex { - fs_permissions: RwLock::new(cloned_fs_permissions), - profile_name: self.profile_name.clone(), - }; - } - Err(_) => { - std::thread::sleep(std::time::Duration::from_millis(2)); - } - } - } - } -} - -impl Serialize for PermissionsIndex { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - loop { - match self.fs_permissions.try_read() { - Ok(fs_permissions_guard) => { - let data = json!({ - "fs_permissions": *fs_permissions_guard, - "profile_name": self.profile_name, - }); - return data.serialize(serializer); - } - Err(_) => { - std::thread::sleep(std::time::Duration::from_millis(2)); - } - } - } - } -} - -#[derive(Deserialize)] -struct PermissionsIndexHelper { - fs_permissions: HashMap, - profile_name: ShinkaiName, -} - -impl<'de> Deserialize<'de> for PermissionsIndex { - fn deserialize(deserializer: D) -> Result - where - D: Deserializer<'de>, - { - // Deserialize into the helper struct - let helper = PermissionsIndexHelper::deserialize(deserializer)?; - // Construct PermissionsIndex from the helper - Ok(PermissionsIndex { - fs_permissions: RwLock::new(helper.fs_permissions), - profile_name: helper.profile_name, - }) - } -} - -impl PartialEq for PermissionsIndex { - fn eq(&self, other: &Self) -> bool { - // First, check if the profile names are equal. If not, return false immediately. - if self.profile_name != other.profile_name { - return false; - } - - // Attempt to acquire read locks on both self and other fs_permissions. - // Use a loop for retrying every 2ms indefinitely until successful. - let self_fs_permissions = loop { - match self.fs_permissions.try_read() { - Ok(lock) => break lock, - Err(_) => std::thread::sleep(std::time::Duration::from_millis(2)), - } - }; - - let other_fs_permissions = loop { - match other.fs_permissions.try_read() { - Ok(lock) => break lock, - Err(_) => std::thread::sleep(std::time::Duration::from_millis(2)), - } - }; - - // Now that we have both locks, we can compare the HashMaps directly. - *self_fs_permissions == *other_fs_permissions - } -} - -impl PermissionsIndex { - /// Creates a new PermissionsIndex struct - pub async fn new(profile_name: ShinkaiName) -> Self { - let index = Self { - fs_permissions: RwLock::new(HashMap::new()), - profile_name, - }; - // Set permissions for the FS root to be private by default (only for profile owner). - // This unwrap is safe due to hard coded values. - index - .insert_path_permission(VRPath::new(), ReadPermission::Private, WritePermission::Private) - .await - .unwrap(); - index - } - - /// Creates a new PermissionsIndex using an input hashmap and profile. - pub fn from_hashmap(profile_name: ShinkaiName, json_permissions: HashMap) -> Self { - Self { - fs_permissions: RwLock::new(json_permissions), - profile_name, - } - } - - // /// We can't use serde:Serialize because of the RwLock, so we need to manually serialize the struct. - // pub async fn serialize_async(&self) -> JsonResult { - // // Acquire the lock asynchronously - // let fs_permissions = self.fs_permissions.read().await; - - // // Directly construct a serde_json::Value that represents the PermissionsIndex data - // let to_serialize = json!({ - // "fs_permissions": *fs_permissions, - // "profile_name": self.profile_name, - // }); - - // // Serialize the serde_json::Value to a String - // serde_json::to_string(&to_serialize) - // } - - /// Prepares a copy of the internal permissions hashmap to be used in a Vector Search, by appending - /// a json serialized reader at a hardcoded key. which is very unlikely to be used normally. - pub async fn export_permissions_hashmap_with_reader(&self, reader: &VFSReader) -> HashMap { - // Asynchronously acquire a read lock and then clone the HashMap - let mut hashmap = self.fs_permissions.read().await.clone(); - - // Add reader at a hard-coded path that can't be used by the VecFS normally - if let Ok(json) = reader.to_json() { - hashmap.insert(Self::vfs_reader_unique_path(), json); - } - - hashmap - } - - /// A hard-coded path that isn't likely to be used by the VecFS normally for permissions ever. - pub fn vfs_reader_unique_path() -> VRPath { - let mut path = VRPath::new(); - path.push("9529".to_string()); - path.push("|do-not_use".to_string()); - path.push("7482".to_string()); - path - } - - /// Retrieves the PathPermission for a given path. - pub async fn get_path_permission(&self, path: &VRPath) -> Result { - let permissions_map: RwLockReadGuard> = self.fs_permissions.read().await; - - permissions_map - .get(path) - .map(|json| PathPermission::from_json(json)) - .transpose()? - .ok_or_else(|| VectorFSError::NoPermissionEntryAtPath(path.clone())) - } - - /// Inserts a path permission into the fs_permissions map. Note, this will overwrite the old read/write permissions - /// for the path if they exist. The Whitelist for the path are preserved always in this method, - /// even when neither read/write are still set as Whitelist. - pub async fn insert_path_permission( - &self, - path: VRPath, - read_permission: ReadPermission, - write_permission: WritePermission, - ) -> Result<(), VectorFSError> { - // Acquire a read lock to access the current permissions - let mut fs_permissions = self.fs_permissions.write().await; - let whitelist = fs_permissions - .get(&path) - .and_then(|json| PathPermission::from_json(json).ok()) - .map_or_else(HashMap::new, |perm| perm.whitelist); - - let path_perm = PathPermission { - read_permission, - write_permission, - whitelist, - }; - fs_permissions.insert(path.clone(), path_perm.to_json()?); - Ok(()) - } - - /// Copies the path permissions from the origin_path to the destination_path. - /// Note, this will overwrite any old permission at the destination_path. - pub async fn copy_path_permission( - &self, - origin_path: VRPath, - destination_path: VRPath, - ) -> Result<(), VectorFSError> { - // Clone the origin permission JSON string while holding a read lock - let origin_permission_json = { - let fs_permissions = self.fs_permissions.read().await; - fs_permissions.get(&origin_path).cloned() - }; - - // Now that the read lock is dropped, proceed with acquiring a write lock - if let Some(origin_permission_json) = origin_permission_json { - let origin_permission = PathPermission::from_json(&origin_permission_json)?; - let mut fs_permissions_write = self.fs_permissions.write().await; - fs_permissions_write.insert(destination_path, origin_permission.to_json()?); - Ok(()) - } else { - Err(VectorFSError::NoPermissionEntryAtPath(origin_path)) - } - } - - /// Internal method which removes a permission from the fs_permissions map. - /// Should only be used by VectorFS when deleting FSEntries entirely. - pub async fn remove_path_permission(&self, path: VRPath) { - let mut fs_permissions = self.fs_permissions.write().await; - fs_permissions.remove(&path); - } - - /// Inserts the WhitelistPermission for a ShinkaiName to the whitelist for a given path. - pub async fn insert_to_whitelist( - &self, - path: VRPath, - name: ShinkaiName, - whitelist_perm: WhitelistPermission, - ) -> Result<(), VectorFSError> { - // Acquire a write lock to modify the permissions - let mut fs_permissions = self.fs_permissions.write().await; - - // Check if the path exists and clone the JSON string if it does - if let Some(path_permission_json) = fs_permissions.get(&path).cloned() { - // Deserialize the JSON string into a PathPermission object - let mut path_permission = PathPermission::from_json(&path_permission_json)?; - - // Insert the new whitelist permission - path_permission.whitelist.insert(name, whitelist_perm); - - // Serialize the updated PathPermission object back into a JSON string - let updated_json = path_permission.to_json()?; - - // Update the entry in the map - fs_permissions.insert(path, updated_json); - } - Ok(()) - } - - /// Removes a ShinkaiName from the whitelist for a given path. - pub async fn remove_from_whitelist(&self, path: VRPath, name: ShinkaiName) -> Result<(), VectorFSError> { - // Acquire a write lock to modify the permissions - let mut fs_permissions = self.fs_permissions.write().await; - - // Check if the path exists and clone the JSON string if it does - if let Some(path_permission_json) = fs_permissions.get(&path).cloned() { - // Deserialize the JSON string into a PathPermission object - let mut path_permission = PathPermission::from_json(&path_permission_json)?; - - // Remove the ShinkaiName from the whitelist - path_permission.whitelist.remove(&name); - - // Serialize the updated PathPermission object back into a JSON string - let updated_json = path_permission.to_json()?; - - // Update the entry in the map - fs_permissions.insert(path, updated_json); - } - Ok(()) - } - - /// Validates the permission for a given requester ShinkaiName + Path in the node's VectorFS. - /// If it returns Ok(()), then permission has passed. - pub fn validate_read_access(&self, requester_name: &ShinkaiName, path: &VRPath) -> Result<(), VectorFSError> { - let mut path = path.clone(); - - loop { - // Acquire a read lock to access the permissions - match self.fs_permissions.try_read() { - Ok(fs_permissions) => { - { - let path_permission_json = fs_permissions.get(&path).cloned(); - // Explicitly drop the lock here - drop(fs_permissions); - - if let Some(json) = path_permission_json { - let path_permission = PathPermission::from_json(&json)?; - - // Global profile owner check - if requester_name.get_profile_name_string() == self.profile_name.get_profile_name_string() { - return Ok(()); - } - - // Otherwise check specific permission - match &path_permission.read_permission { - // If Public, then reading is always allowed - ReadPermission::Public => return Ok(()), - // If private, then reading is allowed for the specific profile that owns the VectorFS - ReadPermission::Private => { - if requester_name.get_profile_name_string() - == self.profile_name.get_profile_name_string() - { - return Ok(()); - } else { - return Err(VectorFSError::InvalidReadPermission( - requester_name.clone(), - path.clone(), - )); - } - } - // If node profiles permission, then reading is allowed to specified profiles in the same node - ReadPermission::NodeProfiles(profiles) => { - if profiles.iter().any(|profile| { - profile.node_name == self.profile_name.node_name - && requester_name.profile_name == profile.profile_name - }) { - return Ok(()); - } else { - return Err(VectorFSError::InvalidReadPermission( - requester_name.clone(), - path.clone(), - )); - } - } - // If Whitelist, checks if the current path permission has the WhitelistPermission for the user. If not, then recursively checks above - // directories (if they are also whitelisted) to see if the WhitelistPermission can be found there, until a non-whitelisted - // directory is found (returns false), or the WhitelistPermission is found for the requester. - ReadPermission::Whitelist => { - if let Some(whitelist_permission) = - path_permission.get_whitelist_permission(requester_name) - { - if matches!( - whitelist_permission, - WhitelistPermission::Read | WhitelistPermission::ReadWrite - ) { - return Ok(()); - } else { - return Err(VectorFSError::InvalidReadPermission( - requester_name.clone(), - path.clone(), - )); - } - } - } - } - } - // If we've gone through the whole path and no WhitelistPermission is found, then return false - if path.pop().is_none() { - return Err(VectorFSError::InvalidReadPermission( - requester_name.clone(), - path.clone(), - )); - } - } - } - Err(_) => { - eprintln!("Failed to acquire read lock for permissions index"); - // Sleep for 2ms before retrying - thread::sleep(Duration::from_millis(2)); - } - } - } - } - - /// Validates the permission for a given requester ShinkaiName + Path in the node's VectorFS. - /// If it returns Ok(()), then permission has passed. - pub fn validate_write_access(&self, requester_name: &ShinkaiName, path: &VRPath) -> Result<(), VectorFSError> { - let mut path = path.clone(); - - loop { - // Attempt to acquire a read lock to access the permissions - match self.fs_permissions.try_read() { - Ok(fs_permissions) => { - { - let path_permission_json = fs_permissions.get(&path).cloned(); - // Explicitly drop the lock here - drop(fs_permissions); - - if let Some(path_permission_json) = path_permission_json { - let path_permission = PathPermission::from_json(&path_permission_json.clone())?; - - // Global profile owner check - if requester_name.get_profile_name_string() == self.profile_name.get_profile_name_string() { - return Ok(()); - } - - // Otherwise check specific permission - match &path_permission.write_permission { - // If private, then writing is allowed for the specific profile that owns the VectorFS - WritePermission::Private => { - if requester_name.get_profile_name_string() - == self.profile_name.get_profile_name_string() - { - return Ok(()); - } else { - return Err(VectorFSError::InvalidWritePermission( - requester_name.clone(), - path.clone(), - )); - } - } - // If node profiles permission, then writing is allowed to specified profiles in the same node - WritePermission::NodeProfiles(profiles) => { - if profiles.iter().any(|profile| { - profile.node_name == self.profile_name.node_name - && requester_name.profile_name == profile.profile_name - }) { - } else { - return Err(VectorFSError::InvalidWritePermission( - requester_name.clone(), - path.clone(), - )); - } - } - // If Whitelist, checks if the current path permission has the WhitelistPermission for the user. If not, then recursively checks above - // directories (if they are also whitelisted) to see if the WhitelistPermission can be found there, until a non-whitelisted - // directory is found (returns false), or the WhitelistPermission is found for the requester. - WritePermission::Whitelist => { - if let Some(whitelist_permission) = path_permission.whitelist.get(requester_name) { - if matches!( - whitelist_permission, - WhitelistPermission::Write | WhitelistPermission::ReadWrite - ) { - } else { - return Err(VectorFSError::InvalidWritePermission( - requester_name.clone(), - path.clone(), - )); - } - } - } - } - } - // If we've gone through the whole path and no WhitelistPermission is found, then return false - if path.pop().is_none() { - return Err(VectorFSError::InvalidWritePermission( - requester_name.clone(), - path.clone(), - )); - } - } - } - Err(_) => { - // Sleep for 2ms before retrying - thread::sleep(Duration::from_millis(2)); - } - } - } - } - - /// Finds all paths that have one of the specified type of read permissions, starting from a given path, and returns them as a Vec. - #[allow(dead_code)] - async fn find_paths_with_read_permissions_as_vec( - &self, - starting_path: VRPath, - read_permissions_to_find: Vec, - ) -> Result, VectorFSError> { - let hashmap_result = self - .find_paths_with_read_permissions_as_hashmap(starting_path, read_permissions_to_find) - .await?; - Ok(hashmap_result.into_iter().collect()) - } - - /// Finds all paths that have one of the specified type of read permissions, starting from a given path, and returns them as a HashMap. - async fn find_paths_with_read_permissions_as_hashmap( - &self, - starting_path: VRPath, - read_permissions_to_find: Vec, - ) -> Result, VectorFSError> { - let mut paths_with_permissions = HashMap::new(); - - // Acquire a read lock to access the fs_permissions hashmap - let fs_permissions = self.fs_permissions.read().await; - - // Iterate through the fs_permissions hashmap - for (path, permission_json) in fs_permissions.iter() { - // Check if the current path is a descendant of the starting path - if starting_path.is_descendant_path(path) { - match PathPermission::from_json(permission_json) { - Ok(path_permission) => { - if read_permissions_to_find.contains(&path_permission.read_permission) { - paths_with_permissions.insert(path.clone(), path_permission.read_permission.clone()); - } - } - Err(_) => {} - } - } - } - - Ok(paths_with_permissions) - } - - /// Finds all paths that have one of the specified type of write permissions, starting from a given path, and returns them as a Vec. - pub async fn find_paths_with_write_permissions_as_vec( - &self, - starting_path: VRPath, - write_permissions_to_find: Vec, - ) -> Result, VectorFSError> { - let hashmap_result = self - .find_paths_with_write_permissions_as_hashmap(starting_path, write_permissions_to_find) - .await?; - Ok(hashmap_result.into_iter().collect()) - } - - /// Finds all paths that have one of the specified type of write permissions, starting from a given path, and returns them as a HashMap. - pub async fn find_paths_with_write_permissions_as_hashmap( - &self, - starting_path: VRPath, - write_permissions_to_find: Vec, - ) -> Result, VectorFSError> { - let mut paths_with_permissions = HashMap::new(); - - // Acquire a read lock to access the fs_permissions hashmap - let fs_permissions = self.fs_permissions.read().await; - - // Iterate through the fs_permissions hashmap - for (path, permission_json) in fs_permissions.iter() { - // Check if the current path is a descendant of the starting path - if starting_path.is_ancestor_path(path) { - match PathPermission::from_json(permission_json) { - Ok(path_permission) => { - if write_permissions_to_find.contains(&path_permission.write_permission) { - paths_with_permissions.insert(path.clone(), path_permission.write_permission.clone()); - } - } - Err(_) => (), - } - } - } - - Ok(paths_with_permissions) - } -} - -impl VectorFS { - /// Validates read access for a given `ShinkaiName` across multiple `VRPath`s in a profile's VectorFS. - /// Returns `Ok(())` if all paths are valid for reading by the given name, or an error indicating the first one that it found which did not pass. - pub async fn validate_read_access_for_paths( - &self, - profile_name: ShinkaiName, - name_to_check: ShinkaiName, - paths: Vec, - ) -> Result<(), VectorFSError> { - for path in paths { - let fs_internals = self.get_profile_fs_internals_cloned(&profile_name).await?; - if fs_internals - .permissions_index - .validate_read_access(&name_to_check, &path) - .is_err() - { - return Err(VectorFSError::InvalidReadPermission(name_to_check, path)); - } - } - Ok(()) - } - - /// Validates write access for a given `ShinkaiName` across multiple `VRPath`s in a profile's VectorFS. - /// Returns `Ok(())` if all paths are valid for writing by the given name, or an error indicating the first one that it found which did not pass. - pub async fn validate_write_access_for_paths( - &self, - profile_name: ShinkaiName, - name_to_check: ShinkaiName, - paths: Vec, - ) -> Result<(), VectorFSError> { - for path in paths { - let fs_internals = self.get_profile_fs_internals_cloned(&profile_name).await?; - if fs_internals - .permissions_index - .validate_write_access(&name_to_check, &path) - .is_err() - { - return Err(VectorFSError::InvalidWritePermission(name_to_check, path)); - } - } - Ok(()) - } - - /// Retrieves the PathPermission for each path in a list, returning a list of tuples containing the VRPath and its corresponding PathPermission. - pub async fn get_path_permission_for_paths( - &self, - profile_name: ShinkaiName, - paths: Vec, - ) -> Result, VectorFSError> { - let mut path_permissions = Vec::new(); - - for path in paths { - let fs_internals = self.get_profile_fs_internals_cloned(&profile_name).await?; - match fs_internals.permissions_index.get_path_permission(&path).await { - Ok(permission) => path_permissions.push((path, permission)), - Err(e) => return Err(e), - } - } - - Ok(path_permissions) - } - - /// Finds all paths that have one of the specified types of read permissions, starting from the path in the given VFSReader. - /// Includes folders, sub-folders and items. - pub async fn find_paths_with_read_permissions_as_vec( - &self, - reader: &VFSReader, - read_permissions_to_find: Vec, - ) -> Result, VectorFSError> { - let hashmap_result = self - .find_paths_with_read_permissions_as_hashmap(reader, read_permissions_to_find) - .await?; - - Ok(hashmap_result.into_iter().collect()) - } - - /// Finds all paths that have one of the specified types of read permissions, starting from the path in the given VFSReader. - /// TODO: Remove the logic to fetch the actual available paths in the FS, and just make perms match the reality (find the bug). - pub async fn find_paths_with_read_permissions_as_hashmap( - &self, - reader: &VFSReader, - read_permissions_to_find: Vec, - ) -> Result, VectorFSError> { - let fs_internals = self.get_profile_fs_internals_cloned(&reader.profile).await?; - - // Fetches the actual available paths in the FS. // TODO: Remove this and make sure perms are actually accurate. - let ret_nodes = fs_internals.fs_core_resource.retrieve_nodes_exhaustive_unordered(None); - let mut all_internals_paths = HashMap::new(); - ret_nodes.iter().for_each(|p| { - all_internals_paths.insert(p.retrieval_path.clone(), true); - }); - - let hashmap_result = fs_internals - .permissions_index - .find_paths_with_read_permissions_as_hashmap(reader.path.clone(), read_permissions_to_find) - .await?; - - let final_result = hashmap_result - .into_iter() - .filter(|(path, _)| all_internals_paths.contains_key(path)) - .collect(); - - Ok(final_result) - } - - /// Finds all paths that have one of the specified types of write permissions, starting from the path in the given VFSReader. - /// TODO: Remove the logic to fetch the actual available paths in the FS, and just make perms match the reality (find the bug). - pub async fn find_paths_with_write_permissions_as_vec( - &self, - reader: &VFSReader, - write_permissions_to_find: Vec, - ) -> Result, VectorFSError> { - let hashmap_result = self - .find_paths_with_write_permissions_as_hashmap(reader, write_permissions_to_find) - .await?; - - Ok(hashmap_result.into_iter().collect()) - } - - /// Finds all paths that have one of the specified types of write permissions, starting from the path in the given VFSReader. - pub async fn find_paths_with_write_permissions_as_hashmap( - &self, - reader: &VFSReader, - write_permissions_to_find: Vec, - ) -> Result, VectorFSError> { - let fs_internals = self.get_profile_fs_internals_cloned(&reader.profile).await?; - - // Fetches the actual available paths in the FS. // TODO: Remove this and make sure perms are actually accurate. - let ret_nodes = fs_internals.fs_core_resource.retrieve_nodes_exhaustive_unordered(None); - let mut all_internals_paths = HashMap::new(); - ret_nodes.iter().for_each(|p| { - all_internals_paths.insert(p.retrieval_path.clone(), true); - }); - - let hashmap_result = fs_internals - .permissions_index - .find_paths_with_write_permissions_as_hashmap(reader.path.clone(), write_permissions_to_find) - .await?; - - let final_result = hashmap_result - .into_iter() - .filter(|(path, _)| all_internals_paths.contains_key(path)) - .collect(); - - Ok(final_result) - } - - /// Sets the read/write permissions for the FSEntry at the writer's path (overwrites). - /// This action is only allowed to be performed by the profile owner. - /// No remove_path_permission is implemented, as all FSEntries must have a path permission. - pub async fn set_path_permission( - &self, - writer: &VFSWriter, - read_permission: ReadPermission, - write_permission: WritePermission, - ) -> Result<(), VectorFSError> { - // Example of acquiring a write lock if internals_map is wrapped in an RwLock - let internals_map = self.internals_map.write().await; - - if let Some(fs_internals) = internals_map.get(&writer.profile) { - if writer.requester_name == writer.profile { - fs_internals - .permissions_index - .insert_path_permission(writer.path.clone(), read_permission, write_permission) - .await?; - self.save_profile_fs_internals(fs_internals.clone(), &writer.profile) - .await?; - } else { - return Err(VectorFSError::InvalidWritePermission( - writer.requester_name.clone(), - writer.path.clone(), - )); - } - } - Ok(()) - } - - /// Inserts a ShinkaiName into the Whitelist permissions list for the FSEntry at the writer's path (overwrites). - /// This action is only allowed to be performed by the profile owner. - pub async fn set_whitelist_permission( - &self, - writer: &VFSWriter, - name_to_whitelist: ShinkaiName, - whitelist_perm: WhitelistPermission, - ) -> Result<(), VectorFSError> { - // Acquire a write lock on internals_map to ensure thread-safe access - let internals_map = self.internals_map.write().await; - - if let Some(fs_internals) = internals_map.get(&writer.profile) { - if writer.requester_name == writer.profile { - // Ensure the operation on permissions_index is awaited if it's an async operation - fs_internals - .permissions_index - .insert_to_whitelist(writer.path.clone(), name_to_whitelist, whitelist_perm) - .await?; - // Assuming save_profile_fs_internals is an async operation, ensure it's awaited - self.save_profile_fs_internals(fs_internals.clone(), &writer.profile) - .await?; - } else { - return Err(VectorFSError::InvalidWritePermission( - writer.requester_name.clone(), - writer.path.clone(), - )); - } - } - Ok(()) - } - - /// Removes a ShinkaiName from the Whitelist permissions list for the FSEntry at the writer's path. - /// This action is only allowed to be performed by the profile owner. - pub async fn remove_whitelist_permission( - &self, - writer: &VFSWriter, - name_to_remove: ShinkaiName, - ) -> Result<(), VectorFSError> { - // Acquire a write lock on internals_map to ensure thread-safe access - let mut internals_map = self.internals_map.write().await; - - if let Some(fs_internals) = internals_map.get_mut(&writer.profile) { - if writer.requester_name == writer.profile { - // Perform the removal operation, ensuring it's awaited if it's an async operation - fs_internals - .permissions_index - .remove_from_whitelist(writer.path.clone(), name_to_remove) - .await?; - // Assuming save_profile_fs_internals is an async operation, ensure it's awaited - self.save_profile_fs_internals(fs_internals.clone(), &writer.profile) - .await?; - } else { - return Err(VectorFSError::InvalidWritePermission( - writer.requester_name.clone(), - writer.path.clone(), - )); - } - } - Ok(()) - } -} diff --git a/shinkai-libs/shinkai-vector-fs/src/vector_fs/vector_fs_reader.rs b/shinkai-libs/shinkai-vector-fs/src/vector_fs/vector_fs_reader.rs deleted file mode 100644 index 463a3dc29..000000000 --- a/shinkai-libs/shinkai-vector-fs/src/vector_fs/vector_fs_reader.rs +++ /dev/null @@ -1,463 +0,0 @@ -use std::future::Future; -use std::pin::Pin; - -use super::vector_fs::VectorFS; -use super::vector_fs_error::VectorFSError; -use super::vector_fs_types::{FSEntry, FSFolder, FSItem, FSRoot}; -use super::vector_fs_writer::VFSWriter; -use serde::{Deserialize, Serialize}; -use serde_json::Value; -use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; -use shinkai_vector_resources::resource_errors::VRError; -use shinkai_vector_resources::shinkai_time::ShinkaiTime; -use shinkai_vector_resources::source::SourceFileMap; -use shinkai_vector_resources::vector_resource::{ - BaseVectorResource, NodeContent, RetrievedNode, VRKai, VRPack, VectorResourceCore, -}; -use shinkai_vector_resources::vector_resource::{VRPath, VectorResourceSearch}; - -/// A struct that represents having access rights to read the VectorFS under a profile/at a specific path. -/// If a VFSReader struct is constructed, that means the `requester_name` has passed -/// permissions validation and is thus allowed to read `path`. -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)] -pub struct VFSReader { - pub requester_name: ShinkaiName, - pub path: VRPath, - pub profile: ShinkaiName, -} - -impl VFSReader { - /// Creates a new VFSReader if the `requester_name` passes read permission validation check. - pub async fn new( - requester_name: ShinkaiName, - path: VRPath, - vector_fs: &VectorFS, - profile: ShinkaiName, - ) -> Result { - let reader = VFSReader { - requester_name: requester_name.clone(), - path: path.clone(), - profile: profile.clone(), - }; - - // Validate profile ShinkaiName has an actual profile inside - if profile.extract_profile().is_err() { - return Err(VectorFSError::ProfileNameNonExistent(profile.to_string())); - } - - // Validate that the path exists - if vector_fs - .validate_path_points_to_entry(path.clone(), &profile) - .await - .is_err() - { - return Err(VectorFSError::NoEntryAtPath(path)); - } - - // Validate read permissions to ensure requester_name has rights - vector_fs - .validate_read_access_for_paths(profile.clone(), requester_name.clone(), vec![path.clone()]) - .await - .map_err(|_| { - VectorFSError::InvalidReaderPermission(requester_name.clone(), profile.clone(), path.clone()) - })?; - - // Once permission verified, saves the datatime both into memory (last_read_index) - // and into the FSDB as stored logs. - let current_datetime = ShinkaiTime::generate_time_now(); - // Update the last read path and time - vector_fs - .update_last_read_path(&profile, path.clone(), current_datetime, requester_name.clone()) - .await?; - - Ok(reader) - } - - /// Generates a VFSReader using the same requester_name/profile held in self. - /// Read permissions are verified before the VFSReader is produced. - pub async fn new_reader_copied_data(&self, path: VRPath, vector_fs: &VectorFS) -> Result { - VFSReader::new(self.requester_name.clone(), path, vector_fs, self.profile.clone()).await - } - - /// Generates a VFSWriter using the same requester_name/profile held in self. - /// Write permissions are verified before the VFSWriter is produced. - pub async fn new_writer_copied_data(&self, path: VRPath, vector_fs: &VectorFS) -> Result { - VFSWriter::new(self.requester_name.clone(), path, vector_fs, self.profile.clone()).await - } - - /// Serialize the PathPermission struct into a JSON string - pub fn to_json(&self) -> Result { - serde_json::to_string(self) - } - - /// Deserialize a JSON string into a PathPermission struct - pub fn from_json(json: &str) -> Result { - serde_json::from_str(json) - } -} - -impl VectorFS { - /// Retrieves a simplified JSON String representation of the FSEntry at the reader's path in the VectorFS. - /// This is the representation that should be sent to frontends to visualize the VectorFS. - pub async fn retrieve_fs_path_simplified_json(&self, reader: &VFSReader) -> Result { - let entry = self.retrieve_fs_entry(reader).await?; - entry.to_json_simplified() - } - - /// Retrieves a simplified JSON Value representation of the FSEntry at the reader's path in the VectorFS. - /// This is the representation that should be sent to frontends to visualize the VectorFS. - pub async fn retrieve_fs_path_simplified_json_value(&self, reader: &VFSReader) -> Result { - let entry = self.retrieve_fs_entry(reader).await?; - entry.to_json_simplified_value() - } - - /// Retrieves a minimal JSON Value representation of the FSEntry at the reader's path in the VectorFS. - /// This is a very minimalistic representation that should be sent to frontends to visualize the VectorFS. - pub async fn retrieve_fs_path_minimal_json_value(&self, reader: &VFSReader) -> Result { - let entry = self.retrieve_fs_entry(reader).await?; - entry.to_json_minimal_value() - } - - /// Retrieves the FSEntry for the reader's path in the VectorFS. - pub async fn retrieve_fs_entry(&self, reader: &VFSReader) -> Result { - let internals = self.get_profile_fs_internals_cloned(&reader.profile).await?; - - // Create FSRoot directly if path is root - if reader.path.is_empty() { - let fs_root = - FSRoot::from_core_vector_resource(internals.fs_core_resource.clone(), &internals.last_read_index)?; - return Ok(FSEntry::Root(fs_root)); - } - - // Otherwise retrieve the node and process it - let ret_node = internals - .fs_core_resource - .retrieve_node_at_path(reader.path.clone(), None)?; - match ret_node.node.content { - NodeContent::Resource(_) => { - let fs_folder = FSFolder::from_vector_resource_node( - ret_node.node.clone(), - reader.path.clone(), - &internals.last_read_index, - )?; - Ok(FSEntry::Folder(fs_folder)) - } - NodeContent::VRHeader(_) => { - let fs_item = - FSItem::from_vr_header_node(ret_node.node, reader.path.clone(), &internals.last_read_index)?; - Ok(FSEntry::Item(fs_item)) - } - _ => Ok(Err(VRError::InvalidNodeType(ret_node.node.id))?), - } - } - - /// Attempts to retrieve a VectorResource from inside an FSItem at the path specified in reader. If an FSItem/VectorResource is not saved - /// at this path, an error will be returned. - pub async fn retrieve_vector_resource(&self, reader: &VFSReader) -> Result { - let fs_item = self.retrieve_fs_entry(reader).await?.as_item()?; - self.db - .get_resource(&fs_item.resource_db_key(), &reader.profile) - .map_err(VectorFSError::from) - } - - /// Attempts to retrieve the SourceFileMap from inside an FSItem at the path specified in reader. If this path does not currently exist, or - /// a source_file is not saved at this path, then an error is returned. - pub async fn retrieve_source_file_map(&self, reader: &VFSReader) -> Result { - let fs_item = self.retrieve_fs_entry(reader).await?.as_item()?; - self.db - .get_source_file_map(&fs_item.source_file_map_db_key()?, &reader.profile) - .map_err(VectorFSError::from) - } - - /// Attempts to retrieve a VRKai from the path specified in reader (errors if entry at path is not an item). - pub async fn retrieve_vrkai(&self, reader: &VFSReader) -> Result { - let fs_item = self.retrieve_fs_entry(reader).await?.as_item()?; - let resource = self.db.get_resource(&fs_item.resource_db_key(), &reader.profile)?; - let sfm = self.retrieve_source_file_map(reader).await.ok(); - - Ok(VRKai::new(resource, sfm)) - } - - /// Attempts to retrieve a VRPack from the path specified in reader (errors if entry at path is not a folder or root). - pub async fn retrieve_vrpack(&self, reader: &VFSReader) -> Result { - let fs_entry = self.retrieve_fs_entry(reader).await?; - let vec_fs_base_path_parent = reader.path.pop_cloned(); - let default_root_name = format!("{}-root", reader.profile); - let folder_name = &reader.path.last_path_id().unwrap_or(default_root_name); - let mut vrpack = VRPack::new_empty(folder_name); - let mut folder_merkle_hash_map = std::collections::HashMap::new(); - - // Recursive function to process each entry and populate the VRPack - fn process_entry<'a>( - entry: &'a FSEntry, - vrpack: &'a mut VRPack, - current_path: VRPath, - vector_fs: &'a VectorFS, - reader: &'a VFSReader, - vec_fs_base_path: VRPath, - folder_merkle_hash_map: &'a mut std::collections::HashMap, - ) -> Pin> + Send + 'a>> { - Box::pin(async move { - match entry { - FSEntry::Root(folder) => { - for child in &folder.child_folders { - let entry = FSEntry::Folder(child.clone()); - process_entry( - &entry, - vrpack, - current_path.clone(), - vector_fs, - reader, - vec_fs_base_path.clone(), - folder_merkle_hash_map, - ) - .await?; - } - } - FSEntry::Folder(folder) => { - let inner_path = current_path.push_cloned(folder.name.clone()); - vrpack.create_folder(&folder.name, current_path.clone())?; - for child in &folder.child_folders { - let entry = FSEntry::Folder(child.clone()); - process_entry( - &entry, - vrpack, - inner_path.clone(), - vector_fs, - reader, - vec_fs_base_path.clone(), - folder_merkle_hash_map, - ) - .await?; - } - for child in &folder.child_items { - let entry = FSEntry::Item(child.clone()); - process_entry( - &entry, - vrpack, - inner_path.clone(), - vector_fs, - reader, - vec_fs_base_path.clone(), - folder_merkle_hash_map, - ) - .await?; - } - - folder_merkle_hash_map.insert(inner_path.clone(), folder.merkle_hash.to_string()); - } - FSEntry::Item(item) => { - // For each item, use retrieve_vrkai to get the VRKai object - let item_path = - vec_fs_base_path.append_path_cloned(¤t_path.push_cloned(item.name.clone())); - let item_reader = reader.new_reader_copied_data(item_path, vector_fs).await?; - match vector_fs.retrieve_vrkai(&item_reader).await { - Ok(vrkai) => vrpack.insert_vrkai(&vrkai, current_path.clone(), false)?, - Err(e) => return Err(e), - } - } - } - Ok(()) - }) - } - - // Start processing from the root or folder of the FSEntry - process_entry( - &fs_entry, - &mut vrpack, - VRPath::root(), - self, - reader, - vec_fs_base_path_parent, - &mut folder_merkle_hash_map, - ) - .await?; - - // Traverse through the sorted list and call the set merkle hash method on all - let mut kv_pairs: Vec<(&VRPath, &String)> = folder_merkle_hash_map.iter().collect(); - kv_pairs.sort_by(|a, b| b.0.path_ids.len().cmp(&a.0.path_ids.len())); - for (path, merkle_hash) in kv_pairs { - vrpack._set_folder_merkle_hash(path.clone(), merkle_hash.clone())?; - } - - vrpack.resource.as_trait_object_mut().update_merkle_root()?; - - Ok(vrpack) - } - - /// Attempts to retrieve a VectorResource from inside an FSItem within the folder specified at reader path. - /// If a VectorResource is not saved at this path, an error will be returned. - pub async fn retrieve_vector_resource_in_folder( - &self, - reader: &VFSReader, - item_name: String, - ) -> Result { - let new_reader = reader - .new_reader_copied_data(reader.path.push_cloned(item_name), self) - .await?; - self.retrieve_vector_resource(&new_reader).await - } - - /// Attempts to retrieve a SourceFileMap from inside an FSItem within the folder specified at reader path. - /// If this path does not currently exist, or a source_file is not saved at this path, - /// then an error is returned. - pub async fn retrieve_source_file_map_in_folder( - &self, - reader: &VFSReader, - item_name: String, - ) -> Result { - let new_reader = reader - .new_reader_copied_data(reader.path.push_cloned(item_name), self) - .await?; - self.retrieve_source_file_map(&new_reader).await - } - - /// Attempts to retrieve a VRKai from inside an FSItem within the folder specified at reader path. - /// If a VectorResource is not saved at this path, an error will be returned. - pub async fn retrieve_vrkai_in_folder( - &self, - reader: &VFSReader, - item_name: String, - ) -> Result { - let new_reader = reader - .new_reader_copied_data(reader.path.push_cloned(item_name), self) - .await?; - self.retrieve_vrkai(&new_reader).await - } - - /// Retrieves a node at a given path from the VectorFS core resource under a profile - pub async fn _retrieve_core_resource_node_at_path( - &self, - path: VRPath, - profile: &ShinkaiName, - ) -> Result { - let internals = self.get_profile_fs_internals_cloned(profile).await?; - internals - .fs_core_resource - .retrieve_node_at_path(path.clone(), None) - .map_err(|_| VectorFSError::NoEntryAtPath(path.clone())) - } - - /// Validates that the path points to a FSFolder - pub async fn validate_path_points_to_folder( - &self, - path: VRPath, - profile: &ShinkaiName, - ) -> Result<(), VectorFSError> { - let ret_node = self._retrieve_core_resource_node_at_path(path.clone(), profile).await?; - - match ret_node.node.content { - NodeContent::Resource(_) => Ok(()), - _ => Err(VectorFSError::PathDoesNotPointAtFolder(path)), - } - } - - /// Validates that the path points to a FSItem - pub async fn validate_path_points_to_item(&self, path: VRPath, profile: &ShinkaiName) -> Result<(), VectorFSError> { - let ret_node = self._retrieve_core_resource_node_at_path(path.clone(), profile).await?; - - match ret_node.node.content { - NodeContent::VRHeader(_) => Ok(()), - _ => Err(VectorFSError::PathDoesNotPointAtItem(path.clone())), - } - } - - /// Validates that the path points to any FSEntry, meaning that something exists at that path. Also returns `Ok()` for root `/`. - pub async fn validate_path_points_to_entry( - &self, - path: VRPath, - profile: &ShinkaiName, - ) -> Result<(), VectorFSError> { - if path == VRPath::root() { - return Ok(()); - } - self._retrieve_core_resource_node_at_path(path, profile) - .await - .map(|_| ()) - } - - /// Generates 2 RetrievedNodes which contain either the description + 2nd node, or the first two nodes if no description is available. - /// Sets their score to `1.0` with empty retrieval path & id. This is intended for job vector searches to prepend the intro text about relevant VRs. - /// Only works on OrderedVectorResources, errors otherwise. - pub async fn _internal_get_vr_intro_ret_nodes( - &self, - reader: &VFSReader, - ) -> Result, VectorFSError> { - let vr = self.retrieve_vector_resource(reader).await?; - Ok(vr.as_trait_object().generate_intro_ret_nodes()?) - } - - /// Checks if the folder at the specified path is empty. - pub async fn is_folder_empty(&self, reader: &VFSReader) -> Result { - let fs_entry = self.retrieve_fs_entry(reader).await?; - - match fs_entry { - FSEntry::Folder(folder) => { - // A folder is considered empty if it has no child folders and no child items. - Ok(folder.child_folders.is_empty() && folder.child_items.is_empty()) - } - FSEntry::Root(root) => { - // Similarly, a root is considered empty if it has no child folders. - Ok(root.child_folders.is_empty()) - } - _ => Err(VectorFSError::PathDoesNotPointAtFolder(reader.path.clone())), - } - } - - /// Returns the number of folders under the path specified in the VectorFS. - pub async fn count_number_of_folders_under_path( - &self, - path: VRPath, - profile: &ShinkaiName, - ) -> Result { - let internals = self.get_profile_fs_internals_cloned(profile).await?; - let folder_count = internals - .fs_core_resource - .retrieve_resource_nodes_exhaustive(Some(path.clone())) - .len(); - Ok(folder_count) - } - - /// Returns the number of items under the path specified in the VectorFS. - pub async fn count_number_of_items_under_path( - &self, - path: VRPath, - profile: &ShinkaiName, - ) -> Result { - let internals = self.get_profile_fs_internals_cloned(profile).await?; - let count = internals - .fs_core_resource - .retrieve_vrheader_nodes_exhaustive(Some(path.clone())) - .len(); - Ok(count) - } - - /// Returns all VRHeaderNodes under the path specified in the VectorFS, recursively (aka. any depth). - /// These represent the VRs in the VectorFS. - pub async fn retrieve_all_vr_header_nodes_underneath_folder( - &self, - reader: VFSReader, - ) -> Result, VectorFSError> { - let internals = self.get_profile_fs_internals_cloned(&reader.profile).await?; - let vrheader_nodes = internals - .fs_core_resource - .retrieve_vrheader_nodes_exhaustive(Some(reader.path.clone())); - - Ok(vrheader_nodes) - } - - /// Returns all VectorFS paths of items underneath the path specified (any depth underneath). - pub async fn retrieve_all_item_paths_underneath_folder( - &self, - reader: VFSReader, - ) -> Result, VectorFSError> { - let vrheader_nodes_all_depths = self.retrieve_all_vr_header_nodes_underneath_folder(reader).await?; - - let paths = vrheader_nodes_all_depths - .iter() - .map(|ret_node| ret_node.retrieval_path.clone()) - .collect::>(); - - Ok(paths) - } -} diff --git a/shinkai-libs/shinkai-vector-fs/src/vector_fs/vector_fs_search.rs b/shinkai-libs/shinkai-vector-fs/src/vector_fs/vector_fs_search.rs deleted file mode 100644 index 6dce6366b..000000000 --- a/shinkai-libs/shinkai-vector-fs/src/vector_fs/vector_fs_search.rs +++ /dev/null @@ -1,394 +0,0 @@ -use super::vector_fs_types::FSItem; -use super::{vector_fs::VectorFS, vector_fs_error::VectorFSError, vector_fs_reader::VFSReader}; -use crate::vector_fs::vector_fs_permissions::PermissionsIndex; -use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; -use shinkai_vector_resources::embedding_generator::EmbeddingGenerator; -use shinkai_vector_resources::source::SourceFileMap; -use shinkai_vector_resources::vector_resource::{ - deep_search_scores_average_out, BaseVectorResource, LimitTraversalMode, Node, NodeContent, ScoringMode, VRHeader, - VRKai, VectorSearchMode, -}; -use shinkai_vector_resources::{ - embeddings::Embedding, - vector_resource::{RetrievedNode, TraversalMethod, TraversalOption, VRPath, VectorResourceSearch}, -}; -use std::collections::HashMap; - -/// A retrieved node from within a Vector Resource inside of the VectorFS. -/// Includes the path of the FSItem in the VectorFS and the retrieved node -/// from the Vector Resource inside the FSItem's path. -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct FSRetrievedNode { - fs_item_path: VRPath, - pub resource_retrieved_node: RetrievedNode, -} - -impl FSRetrievedNode { - /// Creates a new FSRetrievedNode. - pub fn new(fs_item_path: VRPath, resource_retrieved_node: RetrievedNode) -> Self { - FSRetrievedNode { - fs_item_path, - resource_retrieved_node, - } - } - /// Returns the path of the FSItem the node was from - pub fn fs_item_path(&self) -> VRPath { - self.fs_item_path.clone() - } - - /// Returns the name of the FSItem the node was from - pub fn fs_item_name(&self) -> String { - self.resource_retrieved_node.resource_header.resource_name.to_string() - } - - /// Returns the reference_string of the FSItem (db key where the VR is stored) - pub fn reference_string(&self) -> String { - self.resource_retrieved_node.resource_header.reference_string() - } - - /// Returns the similarity score of the retrieved node - pub fn score(&self) -> f32 { - self.resource_retrieved_node.score - } -} - -/// TODO: -/// 1. Implement embedding generation for FSFolders by using the keywords of the FSItems in the folder. -/// 2. Implement new VectorFSSearchOptions interface, which wraps around the standard vec search options interface -/// and allows for similar functionality on the VecFS itself without any edge cases being hit due to VecFS structure. -/// 3. Update all vec search in VectorFS to use dynamic search to support alternate embedding models by default for both resource embedding & keyword embedding -impl VectorFS { - /// Generates an Embedding for the input query to be used in a Vector Search in the VecFS. - /// This automatically uses the correct default embedding model for the given profile. - pub async fn generate_query_embedding( - &self, - input_query: String, - profile: &ShinkaiName, - ) -> Result { - let generator = self._get_embedding_generator(profile).await?; - Ok(generator.generate_embedding_default(&input_query).await?) - } - - /// Generates an Embedding for the input query to be used in a Vector Search in the VecFS. - /// This automatically uses the correct default embedding model for the given profile in reader. - pub async fn generate_query_embedding_using_reader( - &self, - input_query: String, - reader: &VFSReader, - ) -> Result { - self.generate_query_embedding(input_query, &reader.profile).await - } - - /// Performs a "deep" vector search into the VectorFS starting at the reader's path, - /// first finding the num_of_resources_to_search_into most relevant FSItems, then performing another - /// vector search into each Vector Resource (inside the FSItem) to find and return the highest scored nodes. - pub async fn deep_vector_search( - &self, - reader: &VFSReader, - query_text: String, - num_of_resources_to_search_into: u64, - num_of_results: u64, - vector_search_mode: Vec, - ) -> Result, VectorFSError> { - self.deep_vector_search_customized( - reader, - query_text, - num_of_resources_to_search_into, - num_of_results, - vec![TraversalOption::SetScoringMode(ScoringMode::HierarchicalAverageScoring)], - true, - vector_search_mode, - ) - .await - } - - /// Performs a "deep" vector search into the VectorFS starting at the reader's path, - /// first finding the num_of_resources_to_search_into most relevant FSItems, then performing another - /// vector search into each Vector Resource (inside the FSItem) to find and return the highest scored nodes. - /// Allows specifying custom deep_traversal_options which are used when searching into the VRs themselves. - /// average_out_deep_search_scores: If true, averages out the VR top level search score across the VectorFS, with the scores of the nodes inside the VR. - pub async fn deep_vector_search_customized( - &self, - reader: &VFSReader, - query_text: String, - num_of_resources_to_search_into: u64, - num_of_results: u64, - deep_traversal_options: Vec, - average_out_deep_search_scores: bool, - vector_search_mode: Vec, - ) -> Result, VectorFSError> { - let query = self - .generate_query_embedding_using_reader(query_text.clone(), reader) - .await?; - - let mut ret_nodes = Vec::new(); - let mut fs_path_hashmap = HashMap::new(); - let items_with_scores = self - .vector_search_fs_item_with_score(reader, query.clone(), num_of_resources_to_search_into) - .await?; - - for (item, score) in items_with_scores { - if let Ok(new_reader) = reader.new_reader_copied_data(item.path.clone(), self).await { - if let Ok(resource) = self.retrieve_vector_resource(&new_reader).await { - fs_path_hashmap.insert(resource.as_trait_object().reference_string(), item.path); - - let generator = self._get_embedding_generator(&reader.profile).await?; - let mut results = resource - .as_trait_object() - .dynamic_vector_search_customized( - query_text.clone(), - num_of_results, - &deep_traversal_options, - None, - generator, - vector_search_mode.clone(), - ) - .await?; - - // If the average out deep search scores flag is set, we average the scores of the retrieved nodes - if average_out_deep_search_scores { - for ret_node in &mut results { - ret_node.score = deep_search_scores_average_out( - Some(query_text.clone()), - score, - resource.as_trait_object().description().unwrap_or("").to_string(), - ret_node.score, - ret_node.node.get_text_content().unwrap_or("").to_string(), - ); - } - } - ret_nodes.extend(results); - } - } - } - - // Normalize scores for different embedding model types - RetrievedNode::normalize_scores(&mut ret_nodes); - - let mut final_results = vec![]; - for node in RetrievedNode::sort_by_score(&ret_nodes, num_of_results) { - let fs_path = fs_path_hashmap.get(&node.resource_header.reference_string()).ok_or( - VectorFSError::FailedGettingFSPathOfRetrievedNode(node.resource_header.reference_string()), - )?; - final_results.push(FSRetrievedNode::new(fs_path.clone(), node)) - } - Ok(final_results) - } - - /// Performs a vector search into the VectorFS starting at the reader's path, - /// returning the retrieved FSItems extracted from the VRHeader-holding nodes - pub async fn vector_search_fs_item( - &self, - reader: &VFSReader, - query: Embedding, - num_of_results: u64, - ) -> Result, VectorFSError> { - let fs_items_with_scores = self - .vector_search_fs_item_with_score(reader, query, num_of_results) - .await?; - let fs_items = fs_items_with_scores.iter().map(|(item, _)| item.clone()).collect(); - Ok(fs_items) - } - - /// Performs a vector search into the VectorFS starting at the reader's path, - /// returning the retrieved (FSItem, score) pairs extracted from the VRHeader-holding nodes - pub async fn vector_search_fs_item_with_score( - &self, - reader: &VFSReader, - query: Embedding, - num_of_results: u64, - ) -> Result, VectorFSError> { - let ret_nodes = self - ._vector_search_core( - reader, - query, - num_of_results, - TraversalMethod::Exhaustive, - &vec![], - vec![], - ) - .await?; - let internals = self.get_profile_fs_internals_cloned(&reader.profile).await?; - - let mut fs_items_with_scores = vec![]; - for ret_node in ret_nodes { - if let NodeContent::VRHeader(_) = ret_node.node.content { - let item = FSItem::from_vr_header_node( - ret_node.node.clone(), - ret_node.retrieval_path, - &internals.last_read_index, - )?; - fs_items_with_scores.push((item, ret_node.score)); - } - } - Ok(fs_items_with_scores) - } - - /// Performs a vector search into the VectorFS starting at the reader's path, - /// returning the retrieved VRKai of the most similar FSItems. - /// Ignores FSItem results which the requester_name does not have permission to read. - pub async fn vector_search_vrkai( - &self, - reader: &VFSReader, - query: Embedding, - num_of_results: u64, - ) -> Result, VectorFSError> { - let items = self.vector_search_fs_item(reader, query, num_of_results).await?; - let mut results = vec![]; - - // If all perms pass, push - for item in items { - if let Ok(new_reader) = reader.new_reader_copied_data(item.path.parent_path(), self).await { - if let Ok(res) = self.retrieve_vrkai_in_folder(&new_reader, item.name()).await { - results.push(res); - } - } - } - Ok(results) - } - - /// Performs a vector search into the VectorFS starting at the reader's path, - /// returning the retrieved BaseVectorResources which are the most similar. - /// Ignores FSItem (Vector Resource) results which the requester_name does not have permission to read. - pub async fn vector_search_vector_resource( - &mut self, - reader: &VFSReader, - query: Embedding, - num_of_results: u64, - ) -> Result, VectorFSError> { - let items = self.vector_search_fs_item(reader, query, num_of_results).await?; - let mut results = vec![]; - - // If all perms pass, push - for item in items { - if let Ok(new_reader) = reader.new_reader_copied_data(item.path.parent_path(), self).await { - if let Ok(res) = self.retrieve_vector_resource_in_folder(&new_reader, item.name()).await { - results.push(res); - } - } - } - Ok(results) - } - - /// Performs a vector search into the VectorFS starting at the reader's path, - /// returning the retrieved SourceFileMap which are the most similar. - /// Ignores FSItem (SFM) results which the requester_name does not have permission to read. - pub async fn vector_search_source_file_map( - &self, - reader: &VFSReader, - query: Embedding, - num_of_results: u64, - ) -> Result, VectorFSError> { - let items = self.vector_search_fs_item(reader, query, num_of_results).await?; - let mut results = vec![]; - - // If all perms pass, push - for item in items { - if let Ok(new_reader) = reader.new_reader_copied_data(item.path.parent_path(), self).await { - if let Ok(res) = self.retrieve_source_file_map_in_folder(&new_reader, item.name()).await { - results.push(res); - } - } - } - Ok(results) - } - - /// Performs a vector search into the VectorFS starting at the reader's path, - /// returning the retrieved VRHeaders extracted from the nodes - pub async fn vector_search_vr_header( - &self, - reader: &VFSReader, - query: Embedding, - num_of_results: u64, - ) -> Result, VectorFSError> { - let ret_nodes = self - ._vector_search_core( - reader, - query, - num_of_results, - TraversalMethod::Exhaustive, - &vec![], - vec![], - ) - .await?; - let mut vr_headers = Vec::new(); - - for node in ret_nodes { - if let NodeContent::VRHeader(vr_header) = node.node.content { - vr_headers.push(vr_header); - } - } - - Ok(vr_headers) - } - - /// Core method all VectorFS vector searches *must* use. Performs a vector search into the VectorFS at - /// the specified path in reader, returning the retrieved VRHeader nodes. - /// Automatically inspects traversal_options to guarantee folder permissions, and any other must-have options - /// are always respected. - async fn _vector_search_core( - &self, - reader: &VFSReader, - query: Embedding, - num_of_results: u64, - traversal_method: TraversalMethod, - traversal_options: &Vec, - vector_search_mode: Vec, - ) -> Result, VectorFSError> { - let mut traversal_options = traversal_options.clone(); - let internals = self.get_profile_fs_internals_cloned(&reader.profile).await?; - let stringified_permissions_map = internals - .permissions_index - .export_permissions_hashmap_with_reader(reader) - .await; - - // Search without unique scoring (ie. hierarchical) because "folders" have no content/real embedding. - // Also remove any set traversal limit, so we can enforce folder permission traversal limiting. - traversal_options.retain(|option| match option { - TraversalOption::SetTraversalLimiting(_) | TraversalOption::SetScoringMode(_) => false, - _ => true, - }); - - // Enforce folder permissions are respected - traversal_options.push(TraversalOption::SetTraversalLimiting( - LimitTraversalMode::LimitTraversalByValidationWithMap(( - _permissions_validation_func, - stringified_permissions_map, - )), - )); - - let results = internals.fs_core_resource.vector_search_customized( - query, - num_of_results, - traversal_method, - &traversal_options, - Some(reader.path.clone()), - vector_search_mode, - ); - - Ok(results) - } -} - -/// Internal validation function used by all VectorFS vector searches, in order to validate permissions of -/// VR-holding nodes while the search is traversing. -fn _permissions_validation_func(_: &Node, path: &VRPath, hashmap: HashMap) -> bool { - // If the specified path has no permissions, then the default is to now allow traversing deeper - if !hashmap.contains_key(path) { - return false; - } - - // Fetch/parse the VFSReader from the hashmap - let reader = match hashmap.get(&PermissionsIndex::vfs_reader_unique_path()) { - Some(reader_json) => match VFSReader::from_json(reader_json) { - Ok(reader) => reader, - Err(_) => return false, - }, - None => return false, - }; - - // Initialize the PermissionsIndex struct - let perm_index = PermissionsIndex::from_hashmap(reader.profile.clone(), hashmap); - - perm_index.validate_read_access(&reader.requester_name, path).is_ok() -} diff --git a/shinkai-libs/shinkai-vector-fs/src/vector_fs/vector_fs_types.rs b/shinkai-libs/shinkai-vector-fs/src/vector_fs/vector_fs_types.rs deleted file mode 100644 index f256f54a8..000000000 --- a/shinkai-libs/shinkai-vector-fs/src/vector_fs/vector_fs_types.rs +++ /dev/null @@ -1,727 +0,0 @@ -use super::vector_fs_error::VectorFSError; -use chrono::{DateTime, Utc}; -use serde_json::Value; -use shinkai_message_primitives::{ - schemas::shinkai_name::ShinkaiName, shinkai_utils::job_scope::VectorFSItemScopeEntry, -}; -use shinkai_vector_resources::{ - resource_errors::VRError, - shinkai_time::ShinkaiTime, - source::DistributionInfo, - vector_resource::{BaseVectorResource, MapVectorResource, Node, NodeContent, VRHeader, VRKeywords, VRPath}, -}; -use std::collections::HashMap; - -/// Enum that holds the types of external-facing entries used in the VectorFS -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub enum FSEntry { - Folder(FSFolder), - Item(FSItem), - Root(FSRoot), -} - -impl FSEntry { - // Attempts to parse the FSEntry into an FSFolder - pub fn as_folder(self) -> Result { - match self { - FSEntry::Folder(folder) => Ok(folder), - FSEntry::Item(i) => Err(VectorFSError::InvalidFSEntryType(i.path.to_string())), - FSEntry::Root(root) => Err(VectorFSError::InvalidFSEntryType(root.path.to_string())), - } - } - - // Attempts to parse the FSEntry into an FSItem - pub fn as_item(self) -> Result { - match self { - FSEntry::Item(item) => Ok(item), - FSEntry::Folder(f) => Err(VectorFSError::InvalidFSEntryType(f.path.to_string())), - FSEntry::Root(root) => Err(VectorFSError::InvalidFSEntryType(root.path.to_string())), - } - } - - // Attempts to parse the FSEntry into an FSItem - pub fn as_root(self) -> Result { - match self { - FSEntry::Root(root) => Ok(root), - FSEntry::Item(item) => Err(VectorFSError::InvalidFSEntryType(item.path.to_string())), - FSEntry::Folder(f) => Err(VectorFSError::InvalidFSEntryType(f.path.to_string())), - } - } - - /// Converts the FSEntry to a JSON string - pub fn to_json(&self) -> Result { - Ok(serde_json::to_string(self)?) - } - - /// Converts the FSEntry to a "simplified" JSON string by calling simplified methods on items/folders/roots - pub fn to_json_simplified(&self) -> Result { - match self { - FSEntry::Item(item) => item.to_json_simplified(), - FSEntry::Folder(folder) => folder.to_json_simplified(), - FSEntry::Root(root) => root.to_json_simplified(), - } - } - - /// Converts the FSEntry to a "simplified" JSON Value by calling simplified methods on items/folders/roots - pub fn to_json_simplified_value(&self) -> Result { - match self { - FSEntry::Item(item) => item.to_json_simplified_value(), - FSEntry::Folder(folder) => folder.to_json_simplified_value(), - FSEntry::Root(root) => root.to_json_simplified_value(), - } - } - - /// Converts the FSEntry to a "minimal" JSON Value by calling minimal methods on items/folders/roots - pub fn to_json_minimal_value(&self) -> Result { - match self { - FSEntry::Item(item) => item.to_json_minimal_value(), - FSEntry::Folder(folder) => folder.to_json_minimal_value(), - FSEntry::Root(root) => root.to_json_minimal_value(), - } - } - - /// Creates a FSEntry from a FSEntry JSON string. - /// Attempts to parse all entry types directly, and then at the top level. - pub fn from_json(s: &str) -> Result { - if let Ok(folder) = FSFolder::from_json(s) { - return Ok(FSEntry::Folder(folder)); - } - if let Ok(item) = FSItem::from_json(s) { - return Ok(FSEntry::Item(item)); - } - if let Ok(root) = FSRoot::from_json(s) { - return Ok(FSEntry::Root(root)); - } - - // If its not any of the specific entries JSON, then fall back on top level parsing - Ok(serde_json::from_str(s)?) - } -} - -/// An external facing abstraction representing the VecFS root for a given profile. -/// Actual data represented by a FSRoot is the profile's Core MapVectorResource. -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct FSRoot { - pub path: VRPath, - pub child_folders: Vec, - // Datetime when the profile's VectorFS was created - pub created_datetime: DateTime, - /// Datetime which is updated whenever any writes take place. In other words, when - /// a FSItem or FSFolder is updated/moved/renamed/deleted/etc., last written timestamp is updated. - pub last_written_datetime: DateTime, - /// Merkle root of the profile's FS - pub merkle_root: String, -} - -impl FSRoot { - /// Generates a new FSRoot from a MapVectorResource, which is expected to be the FS core resource. - pub fn from_core_vector_resource( - resource: MapVectorResource, - lr_index: &LastReadIndex, - ) -> Result { - // Generate datetime to suffice the method, this gets ignored in practice when converting back via Self::from - let current_datetime = ShinkaiTime::generate_time_now(); - let resource = BaseVectorResource::Map(resource); - let fs_folder = FSFolder::from_vector_resource(resource, VRPath::new(), lr_index, current_datetime)?; - Ok(Self::from(fs_folder)) - } - - /// Converts to a JSON string - pub fn to_json(&self) -> Result { - Ok(serde_json::to_string(self)?) - } - - /// Deserializes from a JSON string - pub fn from_json(s: &str) -> Result { - Ok(serde_json::from_str(s)?) - } - - /// Converts the FSRoot to a "simplified" JSON string without embeddings in child items - /// and recursively simplifies child folders. - pub fn to_json_simplified(&self) -> Result { - let mut root = self.clone(); - for child_folder in &mut root.child_folders { - *child_folder = serde_json::from_str(&child_folder.to_json_simplified()?)?; - } - Ok(serde_json::to_string(&root)?) - } - - /// Converts the FSRoot to a "simplified" JSON Value without embeddings in child items - /// and recursively simplifies child folders. - pub fn to_json_simplified_value(&self) -> Result { - let mut root = self.clone(); - for child_folder in &mut root.child_folders { - *child_folder = serde_json::from_value(child_folder.to_json_simplified_value()?)?; - } - Ok(serde_json::to_value(&root)?) - } - - /// Converts the FSRoot to a "minimal" JSON Value without vr_header in child items - /// and recursively simplifies child folders. - pub fn to_json_minimal_value(&self) -> Result { - let mut root_json = serde_json::to_value(self.clone())?; - - // Recursively simplify child folders to their minimal representation - if let Some(child_folders) = root_json.get_mut("child_folders").and_then(|cf| cf.as_array_mut()) { - for folder in child_folders { - *folder = serde_json::from_value::(folder.clone())?.to_json_minimal_value()?; - } - } - - Ok(root_json) - } -} - -impl From for FSRoot { - fn from(folder: FSFolder) -> Self { - Self { - path: folder.path, - child_folders: folder.child_folders, - created_datetime: folder.created_datetime, - last_written_datetime: folder.last_written_datetime, - merkle_root: folder.merkle_hash, - } - } -} - -/// An external facing folder abstraction used to make interacting with the VectorFS easier. -/// Actual data represented by a FSFolder is a VectorResource-holding Node. -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct FSFolder { - /// Name of the FSFolder - pub name: String, - /// Path where the FSItem is held in the VectorFS - pub path: VRPath, - /// FSFolders which are held within this FSFolder - pub child_folders: Vec, - /// FSItems which are held within this FSFolder - pub child_items: Vec, - /// Datetime the FSFolder was first created - pub created_datetime: DateTime, - /// Datetime the FSFolder was last read by any ShinkaiName - pub last_read_datetime: DateTime, - /// Datetime the FSFolder was last modified, meaning contents of the directory were changed. - /// Ie. An FSEntry is moved/renamed/deleted/new one added. - pub last_modified_datetime: DateTime, - /// Datetime the FSFolder was last written to, meaning any write took place under the folder. In other words, even when - /// a VR is updated or moved/renamed, then last written is always updated. - pub last_written_datetime: DateTime, - /// Merkle hash comprised of all of the FSEntries within this folder - pub merkle_hash: String, - // pub read_permission: - // pub write_permission: -} - -impl FSFolder { - /// Initializes a new FSFolder struct - pub fn new( - path: VRPath, - child_folders: Vec, - child_items: Vec, - created_datetime: DateTime, - last_written_datetime: DateTime, - last_read_datetime: DateTime, - last_modified_datetime: DateTime, - merkle_hash: String, - ) -> Self { - let name = path.last_path_id().unwrap_or("/".to_string()); - Self { - name, - path, - child_folders, - child_items, - created_datetime, - last_read_datetime, - last_modified_datetime, - last_written_datetime, - merkle_hash, - } - } - - /// Initializes a new FSFolder struct with all datetimes set to the current moment. - pub fn _new_current_time( - path: VRPath, - child_folders: Vec, - child_items: Vec, - merkle_hash: String, - ) -> Self { - let now = ShinkaiTime::generate_time_now(); - Self::new( - path, - child_folders, - child_items, - now, - now, - now, - now, - merkle_hash, - ) - } - - /// Generates a new FSFolder using a BaseVectorResource holding Node + the path where the node was retrieved - /// from in the VecFS internals. - pub fn from_vector_resource_node( - node: Node, - node_fs_path: VRPath, - lr_index: &LastReadIndex, - ) -> Result { - // Process datetimes from node - let last_modified_datetime = Self::process_datetimes_from_node(&node)?; - - match node.content { - NodeContent::Resource(base_vector_resource) => { - // Call from_vector_resource with the parsed datetimes - Self::from_vector_resource(base_vector_resource, node_fs_path, lr_index, last_modified_datetime) - } - _ => Err(VRError::InvalidNodeType(node.id))?, - } - } - - /// Generates a new FSFolder from a BaseVectorResource + the path where it was retrieved - /// from inside of the VectorFS. - fn from_vector_resource( - resource: BaseVectorResource, - resource_fs_path: VRPath, - lr_index: &LastReadIndex, - last_modified_datetime: DateTime, - ) -> Result { - let mut child_folders = Vec::new(); - let mut child_items = Vec::new(); - - // Parse all of the inner nodes - for node in &resource.as_trait_object().get_root_nodes() { - match &node.content { - // If it's a Resource, then create a FSFolder by recursing, and push it to child_folders - NodeContent::Resource(inner_resource) => { - // Process datetimes from node - let lm_datetime = Self::process_datetimes_from_node(node)?; - let new_path = resource_fs_path.push_cloned(inner_resource.as_trait_object().name().to_string()); - child_folders.push(Self::from_vector_resource( - inner_resource.clone(), - new_path, - lr_index, - lm_datetime, - )?); - } - // If it's a VRHeader, then create a FSEntry and push it to child_items - NodeContent::VRHeader(_) => { - let new_path = resource_fs_path.push_cloned(node.id.clone()); - let fs_item = FSItem::from_vr_header_node(node.clone(), new_path, lr_index)?; - child_items.push(fs_item); - } - _ => {} - } - } - - // Fetch the datetimes/merkle root, and return the created FSFolder - let last_read_datetime = lr_index.get_last_read_datetime_or_now(&resource_fs_path); - let created_datetime = resource.as_trait_object().created_datetime(); - let last_written_datetime = resource.as_trait_object().last_written_datetime(); - let merkle_hash = resource.as_trait_object().get_merkle_root()?; - Ok(Self::new( - resource_fs_path, - child_folders, - child_items, - created_datetime, - last_written_datetime, - last_read_datetime, - last_modified_datetime, - merkle_hash, - )) - } - - /// Process last_modified datetime in a Node from the VectorFS core resource. - /// The node must be an FSFolder for this to succeed. - pub fn process_datetimes_from_node(node: &Node) -> Result, VectorFSError> { - // Read last_modified_datetime from metadata - let last_modified_str = node - .metadata - .as_ref() - .and_then(|metadata| metadata.get(&Self::last_modified_key())) - .ok_or(VectorFSError::InvalidMetadata(Self::last_modified_key()))?; - - // Parse the datetime string - let last_modified_datetime = ShinkaiTime::from_rfc3339_string(last_modified_str) - .map_err(|_| VectorFSError::InvalidMetadata(Self::last_modified_key()))?; - - Ok(last_modified_datetime) - } - - /// Returns the metadata key for the last modified datetime. - pub fn last_modified_key() -> String { - String::from("last_modified") - } - - /// Converts to a JSON string - pub fn to_json(&self) -> Result { - Ok(serde_json::to_string(self)?) - } - - /// Deserializes from a JSON string - pub fn from_json(s: &str) -> Result { - Ok(serde_json::from_str(s)?) - } - - /// Converts the FSFolder to a "simplified" JSON string without embeddings in child items - /// and recursively simplifies child folders. - pub fn to_json_simplified(&self) -> Result { - let mut folder = self.clone(); - for item in &mut folder.child_items { - item.vr_header.resource_embedding = None; - item.vr_header.resource_keywords.keywords_embedding = None; - } - for child_folder in &mut folder.child_folders { - *child_folder = serde_json::from_str(&child_folder.to_json_simplified()?)?; - } - Ok(serde_json::to_string(&folder)?) - } - - /// Converts the FSFolder to a "simplified" JSON Value without embeddings in child items - /// and recursively simplifies child folders. - pub fn to_json_simplified_value(&self) -> Result { - let mut folder = self.clone(); - for item in &mut folder.child_items { - item.vr_header.resource_embedding = None; - item.vr_header.resource_keywords.keywords_embedding = None; - } - for child_folder in &mut folder.child_folders { - *child_folder = serde_json::from_value(child_folder.to_json_simplified_value()?)?; - } - Ok(serde_json::to_value(&folder)?) - } - - /// Converts the FSFolder to a "minimal" JSON Value without vr_header in child items - /// and recursively simplifies child folders. - pub fn to_json_minimal_value(&self) -> Result { - let mut folder_json = serde_json::to_value(self.clone())?; - - // Simplify child items by removing vr_header - if let Some(child_items) = folder_json.get_mut("child_items").and_then(|ci| ci.as_array_mut()) { - for item in child_items { - item.as_object_mut().unwrap().remove("vr_header"); - } - } - - // Recursively simplify child folders - if let Some(child_folders) = folder_json.get_mut("child_folders").and_then(|cf| cf.as_array_mut()) { - for folder in child_folders { - *folder = serde_json::from_value::(folder.clone())?.to_json_minimal_value()?; - } - } - - Ok(folder_json) - } -} - -/// An external facing "file" abstraction used to make interacting with the VectorFS easier. -/// Each FSItem always represents a single stored VectorResource, which sometimes also has an optional SourceFileMap. -/// Actual data represented by a FSItem is a VRHeader-holding Node. -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct FSItem { - /// Name of the FSItem (based on Vector Resource name) - pub name: String, - /// Path where the FSItem is held in the VectorFS - pub path: VRPath, - /// The VRHeader matching the Vector Resource stored at this FSItem's path - pub vr_header: VRHeader, - /// Datetime the Vector Resource in the FSItem was first created - pub created_datetime: DateTime, - /// Datetime the Vector Resource in the FSItem was last written to, meaning any updates to its contents. - pub last_written_datetime: DateTime, - /// Datetime the FSItem was last read by any ShinkaiName - pub last_read_datetime: DateTime, - /// Datetime the Vector Resource in the FSItem was last saved/updated. - /// For example when saving a VR into the FS that someone else generated on their node, last_written and last_saved will be different. - pub vr_last_saved_datetime: DateTime, - /// Datetime the SourceFileMap in the FSItem was last saved/updated. None if no SourceFileMap was ever saved. - pub source_file_map_last_saved_datetime: Option>, - /// The original release location/date time where the VectorResource/SourceFileMap in this FSItem were made available from. - pub distribution_info: DistributionInfo, - /// The size of the Vector Resource in this FSItem - pub vr_size: usize, - /// The size of the SourceFileMap in this FSItem. Will be 0 if no SourceFiles are saved. - pub source_file_map_size: usize, - /// Merkle hash, which is in fact the merkle root of the Vector Resource stored in the FSItem - pub merkle_hash: String, -} - -impl FSItem { - /// Initialize a new FSItem struct - pub fn new( - path: VRPath, - vr_header: VRHeader, - created_datetime: DateTime, - last_written_datetime: DateTime, - last_read_datetime: DateTime, - vr_last_saved_datetime: DateTime, - source_file_map_last_saved_datetime: Option>, - distribution_info: DistributionInfo, - vr_size: usize, - source_file_map_size: usize, - merkle_hash: String, - ) -> Self { - let name = vr_header.resource_name.clone(); - Self { - name, - path, - vr_header, - created_datetime, - last_written_datetime, - last_read_datetime, - vr_last_saved_datetime, - source_file_map_last_saved_datetime, - distribution_info, - vr_size, - source_file_map_size, - merkle_hash, - } - } - - /// Returns the name of the FSItem (based on the name in VRHeader) - pub fn name(&self) -> String { - self.name.clone() - } - - /// DB key where the Vector Resource matching this FSEntry is held. - /// Uses the VRHeader reference string. Equivalent to self.resource_reference_string(). - pub fn resource_db_key(&self) -> String { - self.vr_header.reference_string() - } - - /// Returns the VRHeader's reference string. Equivalent to self.resource_db_key(). - pub fn resource_reference_string(&self) -> String { - self.vr_header.reference_string() - } - - /// Returns the DB key where the SourceFileMap matching this FSEntry is held. - /// If the FSEntry is marked as having no source file map saved, then returns an VectorFSError. - pub fn source_file_map_db_key(&self) -> Result { - if self.is_source_file_map_saved() { - Ok(self.resource_db_key()) - } else { - Err(VectorFSError::NoSourceFileAvailable(self.vr_header.reference_string())) - } - } - - /// Checks the last saved datetime to determine if it was ever saved into the FSDB - pub fn is_source_file_map_saved(&self) -> bool { - self.source_file_map_last_saved_datetime.is_some() - } - - /// Generates a new FSItem using a VRHeader holding Node + the path where the node was retrieved - /// from in the VecFS internals. Use VRPath::new() if the path is root. - pub fn from_vr_header_node( - node: Node, - node_fs_path: VRPath, - lr_index: &LastReadIndex, - ) -> Result { - match &node.content { - NodeContent::VRHeader(header) => { - // Process data from node metadata - let (vr_last_saved_datetime, source_file_map_last_saved) = Self::process_datetimes_from_node(&node)?; - let last_read_datetime = lr_index.get_last_read_datetime_or_now(&node_fs_path); - let (vr_size, sfm_size) = Self::process_sizes_from_node(&node)?; - let merkle_hash = node.get_merkle_hash()?; - - Ok(FSItem::new( - node_fs_path, - header.clone(), - header.resource_created_datetime, - header.resource_last_written_datetime, - last_read_datetime, - vr_last_saved_datetime, - source_file_map_last_saved, - header.resource_distribution_info.clone(), - vr_size, - sfm_size, - merkle_hash, - )) - } - - _ => Err(VRError::InvalidNodeType(node.id))?, - } - } - - /// Converts the FSItem into a job scope VectorFSItemScopeEntry - pub fn as_scope_entry(&self) -> VectorFSItemScopeEntry { - VectorFSItemScopeEntry { - name: self.vr_header.resource_name.clone(), - path: self.path.clone(), - source: self.vr_header.resource_source.clone(), - } - } - - /// Converts to a JSON string - pub fn to_json(&self) -> Result { - Ok(serde_json::to_string(self)?) - } - - /// Deserializes from a JSON string - pub fn from_json(s: &str) -> Result { - Ok(serde_json::from_str(s)?) - } - - /// Converts the FSItem to a "simplified" JSON string without embeddings and keywords - pub fn to_json_simplified(&self) -> Result { - let mut item = self.clone(); - item.vr_header.resource_embedding = None; - item.vr_header.resource_keywords = VRKeywords::new(); - Ok(serde_json::to_string(&item)?) - } - - /// Converts the FSItem to a "simplified" JSON Value without embeddings and keywords - pub fn to_json_simplified_value(&self) -> Result { - let mut item = self.clone(); - item.vr_header.resource_embedding = None; - item.vr_header.resource_keywords = VRKeywords::new(); - Ok(serde_json::to_value(&item)?) - } - - /// Converts the FSItem to a "minimal" JSON Value - pub fn to_json_minimal_value(&self) -> Result { - let mut item_json = serde_json::to_value(self)?; - // Remove the vr_header from the JSON representation - item_json.as_object_mut().unwrap().remove("vr_header"); - Ok(item_json) - } - - /// Process the two last_saved datetimes in a Node from the VectorFS core resource. - /// The node must be an FSItem for this to succeed. - pub fn process_datetimes_from_node(node: &Node) -> Result<(DateTime, Option>), VectorFSError> { - // Read last_saved_datetime from metadata - let last_saved_str = node - .metadata - .as_ref() - .and_then(|metadata| metadata.get(&Self::vr_last_saved_metadata_key())) - .ok_or(VectorFSError::InvalidMetadata(Self::vr_last_saved_metadata_key()))?; - - // Parse the datetime strings - let last_saved_datetime = ShinkaiTime::from_rfc3339_string(last_saved_str) - .map_err(|_| VectorFSError::InvalidMetadata(Self::vr_last_saved_metadata_key()))?; - - // Read source_file_map_saved from metadata, and convert it back into a DateTime - let source_file_map_last_saved = match node - .metadata - .as_ref() - .and_then(|metadata| metadata.get(&FSItem::source_file_map_last_saved_metadata_key())) - { - Some(s) => Some(ShinkaiTime::from_rfc3339_string(s)?), - None => None, - }; - - Ok((last_saved_datetime, source_file_map_last_saved)) - } - - /// Process the two sizes stored in metadata in an FSItem Node from the VectorFS core resource. - /// The node must be an FSItem for this to succeed. - pub fn process_sizes_from_node(node: &Node) -> Result<(usize, usize), VectorFSError> { - let vr_size_str = node - .metadata - .as_ref() - .and_then(|metadata| metadata.get(&Self::vr_size_metadata_key())); - let vr_size = match vr_size_str { - Some(s) => s - .parse::() - .map_err(|_| VectorFSError::InvalidMetadata(Self::vr_size_metadata_key()))?, - None => 0, - }; - - let sfm_size_str = node - .metadata - .as_ref() - .and_then(|metadata| metadata.get(&Self::source_file_map_size_metadata_key())); - let sfm_size = match sfm_size_str { - Some(s) => s - .parse::() - .map_err(|_| VectorFSError::InvalidMetadata(Self::source_file_map_size_metadata_key()))?, - None => 0, - }; - - Ok((vr_size, sfm_size)) - } - - /// Returns the metadata key for the Vector Resource last saved datetime. - pub fn vr_last_saved_metadata_key() -> String { - String::from("vr_last_saved") - } - - /// Metadata key where Vector Resource's size will be found in a Node. - pub fn vr_size_metadata_key() -> String { - String::from("vr_size") - } - - /// Metadata key where Source File Map's last saved datetime will be found in a Node. - pub fn source_file_map_last_saved_metadata_key() -> String { - String::from("sfm_last_saved") - } - - /// Metadata key where SourceFileMap's size will be found in a Node. - pub fn source_file_map_size_metadata_key() -> String { - String::from("sfm_size") - } -} - -/// TODO: Implement SubscriptionsIndex later on when it's relevant. For now struct exists -/// to have types roughly in place. -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct SubscriptionsIndex { - pub index: HashMap>, -} - -impl SubscriptionsIndex { - // Creates a new SubscriptionsIndex with the provided index - pub fn new(index: HashMap>) -> Self { - Self { index } - } - - // Creates a new SubscriptionsIndex with an empty index - pub fn new_empty() -> Self { - Self { index: HashMap::new() } - } -} - -/// An active in-memory index which holds the last read Datetime of any -/// accessed paths in the VectorFS -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct LastReadIndex { - pub index: HashMap, ShinkaiName)>, -} - -impl LastReadIndex { - // Creates a new LastReadIndex with the provided index - pub fn new(index: HashMap, ShinkaiName)>) -> Self { - Self { index } - } - - // Creates a new LastReadIndex with an empty index - pub fn new_empty() -> Self { - Self { index: HashMap::new() } - } - - // Updates the last read datetime and name for a given path - pub fn update_path_last_read(&mut self, path: VRPath, datetime: DateTime, name: ShinkaiName) { - self.index.insert(path, (datetime, name)); - } - - // Retrieves the last read DateTime and ShinkaiName for a given path - pub fn get_last_read(&self, path: &VRPath) -> Option<&(DateTime, ShinkaiName)> { - self.index.get(path) - } - - // Retrieves the DateTime when the the FSEntry at the given path was last read - pub fn get_last_read_datetime(&self, path: &VRPath) -> Option<&DateTime> { - self.index.get(path).map(|tuple| &tuple.0) - } - - // Retrieves the ShinkaiName who last read the FSEntry at the given path - pub fn get_last_read_name(&self, path: &VRPath) -> Option<&ShinkaiName> { - self.index.get(path).map(|tuple| &tuple.1) - } - - // Retrieves the DateTime when the the FSEntry at the given path was last read, or the current time if not found - pub fn get_last_read_datetime_or_now(&self, path: &VRPath) -> DateTime { - self.get_last_read_datetime(path) - .cloned() - .unwrap_or_else(ShinkaiTime::generate_time_now) - } -} diff --git a/shinkai-libs/shinkai-vector-fs/src/vector_fs/vector_fs_writer.rs b/shinkai-libs/shinkai-vector-fs/src/vector_fs/vector_fs_writer.rs deleted file mode 100644 index 0a0df66fb..000000000 --- a/shinkai-libs/shinkai-vector-fs/src/vector_fs/vector_fs_writer.rs +++ /dev/null @@ -1,1510 +0,0 @@ -use super::vector_fs_permissions::PathPermission; -use super::vector_fs_types::{FSEntry, FSFolder, FSItem}; -use super::{vector_fs::VectorFS, vector_fs_error::VectorFSError, vector_fs_reader::VFSReader}; -use crate::vector_fs::vector_fs_permissions::{ReadPermission, WritePermission}; -use chrono::{DateTime, Utc}; -use serde::{Deserialize, Serialize}; -use shinkai_message_primitives::schemas::shinkai_name::ShinkaiName; -use shinkai_vector_resources::resource_errors::VRError; -use shinkai_vector_resources::shinkai_time::ShinkaiTime; -use shinkai_vector_resources::source::SourceFileMap; -use shinkai_vector_resources::vector_resource::VectorResourceCore; -use shinkai_vector_resources::vector_resource::{NodeContent, RetrievedNode, SourceFileType, VRKai, VRPack}; -use shinkai_vector_resources::{ - embeddings::Embedding, - vector_resource::{BaseVectorResource, MapVectorResource, Node, VRHeader, VRPath, VRSourceReference}, -}; -use std::collections::HashMap; -use std::future::Future; -use std::pin::Pin; - -/// A struct that represents having rights to write to the VectorFS under a profile/at a specific path. -/// If a VFSWriter struct is constructed, that means the `requester_name` has passed -/// permissions validation and is thus allowed to write to `path`. -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)] -pub struct VFSWriter { - pub requester_name: ShinkaiName, - pub path: VRPath, - pub profile: ShinkaiName, -} - -impl VFSWriter { - /// Creates a new VFSWriter if the `requester_name` passes write permission validation check. - pub async fn new( - requester_name: ShinkaiName, - path: VRPath, - vector_fs: &VectorFS, - profile: ShinkaiName, - ) -> Result { - let writer = VFSWriter { - requester_name: requester_name.clone(), - path: path.clone(), - profile: profile.clone(), - }; - - // Validate profile ShinkaiName has an actual profile inside - if profile.extract_profile().is_err() { - return Err(VectorFSError::ProfileNameNonExistent(profile.to_string())); - } - - // Validate write permissions to ensure requester_name has rights - vector_fs - .validate_write_access_for_paths(profile.clone(), requester_name.clone(), vec![path.clone()]) - .await - .map_err(|_| { - VectorFSError::InvalidWriterPermission(requester_name.clone(), profile.clone(), path.clone()) - })?; - - Ok(writer) - } - - /// Generates a VFSReader using the same requester_name/profile held in self. - /// Read permissions are verified before the VFSReader is produced. - pub async fn new_reader_copied_data(&self, path: VRPath, vector_fs: &VectorFS) -> Result { - VFSReader::new(self.requester_name.clone(), path, vector_fs, self.profile.clone()).await - } - - /// Generates a VFSWriter using the same requester_name/profile held in self. - /// Write permissions are verified before the VFSWriter is produced. - pub async fn new_writer_copied_data(&self, path: VRPath, vector_fs: &VectorFS) -> Result { - VFSWriter::new(self.requester_name.clone(), path, vector_fs, self.profile.clone()).await - } - - /// Generates a new empty ProfileBoundWiteBatch using the profile in the Writer - fn new_write_batch(&self) -> Result { - ProfileBoundWriteBatch::new_vfs_batch(&self.profile) - } -} - -impl VectorFS { - /// Copies the FSFolder from the writer's path into being held underneath the destination_path. - pub async fn copy_folder(&self, writer: &VFSWriter, destination_path: VRPath) -> Result { - let write_batch = writer.new_write_batch()?; - let (_write_batch, new_folder) = self - .internal_wb_copy_folder(writer, destination_path, write_batch, false) - .await?; - Ok(new_folder) - } - - /// Internal method to copy the FSFolder from the writer's path into being held underneath the destination_path. - fn internal_wb_copy_folder<'a>( - &'a self, - writer: &'a VFSWriter, - destination_path: VRPath, - mut write_batch: ProfileBoundWriteBatch, - is_recursive_call: bool, - ) -> Pin> + Send + 'a>> { - Box::pin(async move { - let current_datetime = ShinkaiTime::generate_time_now(); - let destination_writer = writer.new_writer_copied_data(destination_path.clone(), self).await?; - - // Ensure paths are valid before proceeding - self.validate_path_points_to_folder(writer.path.clone(), &writer.profile) - .await?; - if &destination_path != &VRPath::root() { - self.validate_path_points_to_folder(destination_path.clone(), &writer.profile) - .await?; - } - let destination_child_path = destination_path.push_cloned(writer.path.last_path_id()?); - if self - .validate_path_points_to_entry(destination_child_path.clone(), &writer.profile) - .await - .is_ok() - { - return Err(VectorFSError::CannotOverwriteFSEntry(destination_child_path.clone())); - } - - // Get the existing folder - let (folder_ret_node, embedding) = self._get_node_from_core_resource(writer).await?; - let metadata = folder_ret_node.node.metadata.clone(); - let mut folder_resource = folder_ret_node.node.get_vector_resource_content()?.clone(); - // Backup tag index, remove nodes/embeddings, and then reapply tag index - let cloned_tag_index = folder_resource.as_trait_object().get_data_tag_index().clone(); - let nodes_embeddings = folder_resource.as_trait_object_mut().remove_root_nodes()?; - folder_resource - .as_trait_object_mut() - .set_data_tag_index(cloned_tag_index); - - // We insert the emptied folder resource into the destination path, and copy permissions - self._add_existing_vr_to_core_resource( - &destination_writer, - folder_resource, - embedding, - metadata, - current_datetime, - ) - .await?; - { - let internals = self.get_profile_fs_internals_cloned(&writer.profile).await?; - internals - .permissions_index - .copy_path_permission(writer.path.clone(), destination_path.clone()) - .await?; - self._update_fs_internals(writer.profile.clone(), internals).await?; - } - - // Determine and copy permissions from the parent of the new copied folder - let parent_path = destination_path.parent_path(); - let (read_permission, write_permission) = if parent_path == VRPath::root() { - (ReadPermission::Private, WritePermission::Private) - } else { - let parent_permissions = self - .get_profile_fs_internals_cloned(&writer.profile) - .await? - .permissions_index - .get_path_permission(&parent_path) - .await - .unwrap_or(PathPermission { - read_permission: ReadPermission::Private, - write_permission: WritePermission::Private, - whitelist: HashMap::new(), - }); - (parent_permissions.read_permission, parent_permissions.write_permission) - }; - - // Set permissions for the new copied folder - { - let internals = self.get_profile_fs_internals_cloned(&writer.profile).await?; - internals - .permissions_index - .insert_path_permission(destination_child_path.clone(), read_permission, write_permission) - .await?; - self._update_fs_internals(writer.profile.clone(), internals).await?; - } - - // Now we copy each of the folder's original child folders/items (nodes) and add them to their destination path - for (node, _) in nodes_embeddings { - let origin_writer = writer - .new_writer_copied_data(writer.path.push_cloned(node.id.clone()), self) - .await?; - let dest_path = destination_child_path.clone(); - match node.content { - NodeContent::Resource(_) => { - let (batch, _) = self - .internal_wb_copy_folder(&origin_writer, dest_path, write_batch, true) - .await?; - write_batch = batch; - } - NodeContent::VRHeader(_) => { - let (batch, _) = self.wb_copy_item(&origin_writer, dest_path, write_batch).await?; - write_batch = batch; - } - _ => continue, - } - } - - // Only commit updating the fs internals once at the top level, efficiency improvement - if !is_recursive_call { - let internals = self.get_profile_fs_internals_cloned(&writer.profile).await?; - self.save_profile_fs_internals(internals, &writer.profile).await?; - } - - // Fetch the new FSFolder after everything has been copied over in fs internals - let reader = destination_writer - .new_reader_copied_data(destination_child_path.clone(), self) - .await?; - let fs_entry = self.retrieve_fs_entry(&reader).await?; - - match fs_entry { - FSEntry::Folder(new_folder) => Ok((write_batch, new_folder)), - _ => Err(VectorFSError::PathDoesNotPointAtFolder(destination_child_path)), - } - }) - } - - /// Deletes the folder at writer's path, including all items and subfolders within. - pub async fn delete_folder(&self, writer: &VFSWriter) -> Result<(), VectorFSError> { - let mut write_batch = writer.new_write_batch()?; - write_batch = self.internal_wb_delete_folder(writer, write_batch, false).await?; - Ok(()) - } - - /// Internal method that deletes the folder at writer's path, including all items and subfolders within, using a write batch. - fn internal_wb_delete_folder<'a>( - &'a self, - writer: &'a VFSWriter, - mut write_batch: ProfileBoundWriteBatch, - is_recursive_call: bool, - ) -> Pin> + Send + 'a>> { - Box::pin(async move { - self.validate_path_points_to_folder(writer.path.clone(), &writer.profile) - .await?; - - // Read the folder node first without removing it - let (folder_node, _) = self._get_node_from_core_resource(writer).await?; - let internals = self.get_profile_fs_internals_cloned(&writer.profile).await?; - let folder = - FSFolder::from_vector_resource_node(folder_node.node, writer.path.clone(), &internals.last_read_index)?; - - // Iterate over items in the folder and delete each - for item in folder.child_items { - let item_writer = VFSWriter { - requester_name: writer.requester_name.clone(), - path: writer.path.push_cloned(item.name.clone()), - profile: writer.profile.clone(), - }; - write_batch = self.wb_delete_item(&item_writer, write_batch).await?; - } - - // Recursively delete subfolders - for subfolder in folder.child_folders { - let folder_writer = VFSWriter { - requester_name: writer.requester_name.clone(), - path: writer.path.push_cloned(subfolder.name.clone()), - profile: writer.profile.clone(), - }; - write_batch = self - .internal_wb_delete_folder(&folder_writer, write_batch, true) - .await?; - } - - // Now remove the folder node from the core resource and remove its path permissions - let (_removed_folder_node, _) = self._remove_node_from_core_resource(writer).await?; - { - let internals = self.get_profile_fs_internals_cloned(&writer.profile).await?; - internals - .permissions_index - .remove_path_permission(folder.path.clone()) - .await; - self._update_fs_internals(writer.profile.clone(), internals).await?; - } - - // Only commit updating the fs internals once at the top level, efficiency improvement - // TODO: Efficiency, have each recursive call return the list of folder/item paths to delete in the permissions index, and do it all just once here - if !is_recursive_call { - let internals = self.get_profile_fs_internals_cloned(&writer.profile).await?; - self.save_profile_fs_internals(internals, &writer.profile).await?; - } - - Ok(write_batch) - }) - } - - /// Deletes the FSItem at the writer's path. - pub async fn delete_item(&self, writer: &VFSWriter) -> Result<(), VectorFSError> { - let mut write_batch = writer.new_write_batch()?; - let _ = self.wb_delete_item(writer, write_batch).await?; - Ok(()) - } - - /// Deletes the item at writer's path, within a write batch. - pub async fn wb_delete_item( - &self, - writer: &VFSWriter, - write_batch: ProfileBoundWriteBatch, - ) -> Result { - self.validate_path_points_to_item(writer.path.clone(), &writer.profile) - .await?; - let (item_node, _) = self._remove_node_from_core_resource(writer).await?; - let ref_string = item_node.get_vr_header_content()?.reference_string(); - - let internals = self.get_profile_fs_internals_cloned(&writer.profile).await?; - internals - .permissions_index - .remove_path_permission(writer.path.clone()) - .await; - self._update_fs_internals(writer.profile.clone(), internals.clone()) - .await?; - self.db.delete_resource(&ref_string)?; - self.save_profile_fs_internals(internals, &writer.profile).await?; - Ok(write_batch) - } - - /// Copies the FSItem from the writer's path into being held underneath the destination_path. - /// Does not support copying into VecFS root. - pub async fn copy_item(&self, writer: &VFSWriter, destination_path: VRPath) -> Result { - let write_batch = writer.new_write_batch()?; - let (_write_batch, new_item) = self.wb_copy_item(writer, destination_path, write_batch).await?; - Ok(new_item) - } - - /// Copy the FSItem from the writer's path into being held underneath the destination_path. - /// Does not support copying into VecFS root. - pub async fn wb_copy_item( - &self, - writer: &VFSWriter, - destination_path: VRPath, - mut write_batch: ProfileBoundWriteBatch, - ) -> Result<(ProfileBoundWriteBatch, FSItem), VectorFSError> { - let current_datetime = ShinkaiTime::generate_time_now(); - let destination_writer = writer.new_writer_copied_data(destination_path.clone(), self).await?; - - // Ensure paths are valid before proceeding - self.validate_path_points_to_item(writer.path.clone(), &writer.profile) - .await?; - self.validate_path_points_to_folder(destination_path.clone(), &writer.profile) - .await?; - let destination_child_path = destination_path.push_cloned(writer.path.last_path_id()?); - if self - .validate_path_points_to_entry(destination_child_path.clone(), &writer.profile) - .await - .is_ok() - { - return Err(VectorFSError::CannotOverwriteFSEntry(destination_child_path.clone())); - } - - // Get the existing item - let (item_ret_node, _) = self._get_node_from_core_resource(writer).await?; - let item_metadata = item_ret_node.node.metadata; - let mut source_file_map = None; - let source_file_map_is_saved = item_metadata - .as_ref() - .and_then(|metadata| metadata.get(&FSItem::source_file_map_last_saved_metadata_key())) - .map_or(false, |_| true); - - // Fetch the VR and SFM from the DB - let reader = writer.new_reader_copied_data(writer.path.clone(), self).await?; - if source_file_map_is_saved { - source_file_map = Some(self.retrieve_source_file_map(&reader).await?); - } - let mut vector_resource = self.retrieve_vector_resource(&reader).await?; - // Generate a new VR id for the resource, and generate a new header - vector_resource.as_trait_object_mut().generate_and_update_resource_id(); - let header = vector_resource.as_trait_object().generate_resource_header(); - let source_db_key = header.reference_string(); - - // Save the copied item w/new resource id into the new destination w/permissions - let new_item = self - ._add_vr_header_to_core_resource(&destination_writer, header, item_metadata, current_datetime, false) - .await?; - - // Determine and set permissions based on the parent of the destination path - let parent_path = destination_path.parent_path(); - let (read_permission, write_permission) = if parent_path == VRPath::root() { - (ReadPermission::Private, WritePermission::Private) - } else { - let parent_permissions = self - .get_profile_fs_internals_cloned(&writer.profile) - .await? - .permissions_index - .get_path_permission(&parent_path) - .await - .unwrap_or(PathPermission { - read_permission: ReadPermission::Private, - write_permission: WritePermission::Private, - whitelist: HashMap::new(), - }); - (parent_permissions.read_permission, parent_permissions.write_permission) - }; - - // Set permissions for the new copied item - { - let internals = self.get_profile_fs_internals_cloned(&writer.profile).await?; - internals - .permissions_index - .insert_path_permission(new_item.path.clone(), read_permission, write_permission) - .await?; - self._update_fs_internals(writer.profile.clone(), internals).await?; - } - - // Save fs internals, new VR, and new SFM to the DB - if let Some(sfm) = source_file_map { - self.db.save_source_file_map(&sfm, &source_db_key, &writer.profile)?; - } - self.db.save_resource(&vector_resource, &write_batch.profile_name)?; - let internals = self.get_profile_fs_internals_cloned(&writer.profile).await?; - self.save_profile_fs_internals(internals, &writer.profile).await?; - - Ok((write_batch, new_item)) - } - - /// Moves the FSItem from the writer's path into being held underneath the destination_path. - /// Does not support moving into VecFS root. - pub async fn move_item(&self, writer: &VFSWriter, destination_path: VRPath) -> Result { - let current_datetime = ShinkaiTime::generate_time_now(); - let destination_writer = writer.new_writer_copied_data(destination_path.clone(), self).await?; - - // Ensure paths are valid before proceeding - self.validate_path_points_to_item(writer.path.clone(), &writer.profile) - .await?; - self.validate_path_points_to_folder(destination_path.clone(), &writer.profile) - .await?; - let destination_child_path = destination_path.push_cloned(writer.path.last_path_id()?); - if self - .validate_path_points_to_entry(destination_child_path.clone(), &writer.profile) - .await - .is_ok() - { - return Err(VectorFSError::CannotOverwriteFSEntry(destination_child_path.clone())); - } - - // If the item was moved successfully in memory, then commit to the DB - let move_result = self - ._internal_move_item(writer, &destination_writer, current_datetime, destination_path) - .await; - if let Ok(new_item) = move_result { - let internals = self.get_profile_fs_internals_cloned(&writer.profile).await?; - self.save_profile_fs_internals(internals, &writer.profile).await?; - Ok(new_item) - } - // Else if it was not successful in memory, reload fs internals from db to revert changes and return error - else { - self.revert_internals_to_last_db_save(&writer.profile, &writer.profile) - .await?; - move_result - } - } - - /// Internal method which moves the item at writer's path into destination_writer's path (in memory only) - async fn _internal_move_item( - &self, - writer: &VFSWriter, - destination_writer: &VFSWriter, - current_datetime: DateTime, - destination_path: VRPath, - ) -> Result { - // Remove the existing item - let (item_node, _) = self._remove_node_from_core_resource(writer).await?; - let header = item_node.get_vr_header_content()?.clone(); - let item_metadata = item_node.metadata; - // And save the item into the new destination w/permissions - let new_item = self - ._add_vr_header_to_core_resource(destination_writer, header, item_metadata, current_datetime, false) - .await?; - - // Determine and set permissions based on the parent of the destination path - let (read_permission, write_permission) = if destination_path == VRPath::root() { - (ReadPermission::Private, WritePermission::Private) - } else { - let parent_permissions = self - .get_profile_fs_internals_cloned(&writer.profile) - .await? - .permissions_index - .get_path_permission(&destination_path) - .await - .unwrap_or(PathPermission { - read_permission: ReadPermission::Private, - write_permission: WritePermission::Private, - whitelist: HashMap::new(), - }); - (parent_permissions.read_permission, parent_permissions.write_permission) - }; - - // Set permissions for the new moved item - { - let internals = self.get_profile_fs_internals_cloned(&writer.profile).await?; - internals - .permissions_index - .insert_path_permission(new_item.path.clone(), read_permission, write_permission) - .await?; - // Remove the original item's permissions - internals - .permissions_index - .remove_path_permission(writer.path.clone()) - .await; - self._update_fs_internals(writer.profile.clone(), internals).await?; - } - Ok(new_item) - } - - /// Moves the FSFolder from the writer's path into being held underneath the destination_path. - /// Supports moving into VecFS root. - pub async fn move_folder(&self, writer: &VFSWriter, destination_path: VRPath) -> Result { - let current_datetime = ShinkaiTime::generate_time_now(); - let destination_writer = writer.new_writer_copied_data(destination_path.clone(), self).await?; - - // Ensure paths are valid before proceeding - self.validate_path_points_to_folder(writer.path.clone(), &writer.profile) - .await?; - if &destination_path != &VRPath::root() { - self.validate_path_points_to_folder(destination_path.clone(), &writer.profile) - .await?; - } - - let destination_child_path = destination_path.push_cloned(writer.path.last_path_id()?); - if self - .validate_path_points_to_entry(destination_child_path.clone(), &writer.profile) - .await - .is_ok() - { - return Err(VectorFSError::CannotOverwriteFSEntry(destination_child_path.clone())); - } - - // Make sure we don't partially copy the folder into itself before failing - if writer.path.is_descendant_path(&destination_child_path) { - return Err(VectorFSError::CannotMoveFolderIntoItself(writer.path.clone())); - } - - // If the folder was moved successfully in memory, then commit to the DB - let move_result = self - .internal_move_folder(writer, &destination_writer, current_datetime, destination_path) - .await; - if let Ok(new_folder) = move_result { - let internals = self.get_profile_fs_internals_cloned(&writer.profile).await?; - self.save_profile_fs_internals(internals, &writer.profile).await?; - Ok(new_folder) - } - // Else if it was not successful in memory, reload fs internals from db to revert changes and return error - else { - self.revert_internals_to_last_db_save(&writer.profile, &writer.profile) - .await?; - Ok(move_result?) - } - } - - /// Internal method which moves the folder at writer's path into destination_writer's path (in memory only) - async fn internal_move_folder( - &self, - writer: &VFSWriter, - destination_writer: &VFSWriter, - current_datetime: DateTime, - destination_path: VRPath, - ) -> Result { - // Copy the folder to the new destination - let new_folder = self - .internal_copy_folder(writer, destination_writer, current_datetime) - .await?; - - // Determine and set permissions based on the parent of the destination path - let (read_permission, write_permission) = if destination_path == VRPath::root() { - (ReadPermission::Private, WritePermission::Private) - } else { - let parent_permissions = self - .get_profile_fs_internals_cloned(&writer.profile) - .await? - .permissions_index - .get_path_permission(&destination_path) - .await - .unwrap_or(PathPermission { - read_permission: ReadPermission::Private, - write_permission: WritePermission::Private, - whitelist: HashMap::new(), - }); - (parent_permissions.read_permission, parent_permissions.write_permission) - }; - - // Set permissions for the new moved folder - { - let internals = self.get_profile_fs_internals_cloned(&writer.profile).await?; - internals - .permissions_index - .insert_path_permission(new_folder.path.clone(), read_permission, write_permission) - .await?; - // Remove the original folder's permissions - internals - .permissions_index - .remove_path_permission(writer.path.clone()) - .await; - self._update_fs_internals(writer.profile.clone(), internals).await?; - } - - // Remove the existing folder - self._remove_node_from_core_resource(writer).await?; - - Ok(new_folder) - } - - /// Internal method which copies the folder at writer's path into destination_writer's path (in memory only) - async fn internal_copy_folder( - &self, - writer: &VFSWriter, - destination_writer: &VFSWriter, - current_datetime: DateTime, - ) -> Result { - // Get the existing folder - let (folder_node, folder_embedding) = self._get_node_from_core_resource(writer).await?; - let folder_resource = folder_node.node.get_vector_resource_content()?.clone(); - let folder_metadata = folder_node.node.metadata; - - // Save the folder into the new destination w/permissions - let new_folder = self - ._add_existing_vr_to_core_resource( - destination_writer, - folder_resource, - folder_embedding, - folder_metadata, - current_datetime, - ) - .await?; - { - let internals = self.get_profile_fs_internals_cloned(&writer.profile).await?; - internals - .permissions_index - .copy_path_permission(writer.path.clone(), new_folder.path.clone()) - .await?; - self._update_fs_internals(writer.profile.clone(), internals).await?; - } - Ok(new_folder) - } - - /// Automatically creates new FSFolders along the given path that do not exist, including the final path id (aka. don't supply an FSItem's path, use its parent path). - /// Returns a Vec containing the paths of the newly created folders. - pub async fn create_new_folder_auto(&self, writer: &VFSWriter, path: VRPath) -> Result, VectorFSError> { - let mut current_path = VRPath::root(); - let mut created_folders = Vec::new(); - for segment in path.path_ids { - current_path.push(segment.clone()); - if self - .validate_path_points_to_entry(current_path.clone(), &writer.profile) - .await - .is_err() - { - let new_writer = writer.new_writer_copied_data(current_path.pop_cloned(), self).await?; - self.create_new_folder(&new_writer, &segment).await?; - created_folders.push(current_path.clone()); - } - } - Ok(created_folders) - } - - /// Creates a new FSFolder underneath the writer's path. Errors if the path in `writer` does not exist. - pub async fn create_new_folder( - &self, - writer: &VFSWriter, - new_folder_name: &str, - ) -> Result { - // Create a new MapVectorResource which represents a folder - let current_datetime = ShinkaiTime::generate_time_now(); - let new_vr = BaseVectorResource::Map(MapVectorResource::new_empty( - new_folder_name, - None, - VRSourceReference::None, - true, - )); - let embedding = Embedding::new_empty(); // Empty embedding as folders do not score in VecFS search - - // Setup default metadata for new folder node - let mut metadata = HashMap::new(); - metadata.insert(FSFolder::last_modified_key(), current_datetime.to_rfc3339()); - - // Call the new method to save the existing folder - self.internal_save_folder(writer, new_vr, embedding, Some(metadata), current_datetime) - .await - } - - /// Internal method which saves a FSFolder into the writer's path. - async fn internal_save_folder( - &self, - writer: &VFSWriter, - new_vr: BaseVectorResource, - embedding: Embedding, - metadata: Option>, - current_datetime: DateTime, - ) -> Result { - // Add the folder into the internals - let new_folder = self - ._add_existing_vr_to_core_resource(writer, new_vr, embedding, metadata, current_datetime) - .await?; - let new_folder_path = new_folder.path.clone(); - - // Determine permissions based on whether the parent folder is root - let read_permission; - let write_permission; - if writer.path == VRPath::root() { - read_permission = ReadPermission::Private; - write_permission = WritePermission::Private; - } else { - // Read the permissions of the parent folder - let parent_permissions = self - .get_profile_fs_internals_cloned(&writer.profile) - .await? - .permissions_index - .get_path_permission(&writer.path) - .await - .unwrap_or(PathPermission { - read_permission: ReadPermission::Private, - write_permission: WritePermission::Private, - whitelist: HashMap::new(), - }); - read_permission = parent_permissions.read_permission; - write_permission = parent_permissions.write_permission; - } - - // Add read/write permission for the folder path - { - let internals = self.get_profile_fs_internals_cloned(&writer.profile).await?; - internals - .permissions_index - .insert_path_permission(new_folder_path, read_permission, write_permission) - .await?; - self._update_fs_internals(writer.profile.clone(), internals).await?; - } - - // Save the FSInternals into the FSDB - let internals = self.get_profile_fs_internals_cloned(&writer.profile).await?; - self.save_profile_fs_internals(internals, &writer.profile).await?; - - Ok(new_folder) - } - - /// Updates the permissions of a folder, all its subfolders, and subitems recursively. - pub fn update_permissions_recursively<'a>( - &'a self, - writer: &'a VFSWriter, - read_permission: ReadPermission, - write_permission: WritePermission, - ) -> Pin> + Send + 'a>> { - Box::pin(async move { - // Ensure the path points to a folder before proceeding - self.validate_path_points_to_folder(writer.path.clone(), &writer.profile) - .await?; - - // Retrieve the folder node - let (folder_node, _) = self._get_node_from_core_resource(writer).await?; - let mut folder_resource = folder_node.node.get_vector_resource_content()?.clone(); - - // Update permissions for the current folder - { - let internals = self.get_profile_fs_internals_cloned(&writer.profile).await?; - internals - .permissions_index - .insert_path_permission(writer.path.clone(), read_permission.clone(), write_permission.clone()) - .await?; - self._update_fs_internals(writer.profile.clone(), internals).await?; - } - - // Recursively update permissions for all child nodes - if let NodeContent::Resource(_) = folder_node.node.content { - let nodes_embeddings = folder_resource.as_trait_object_mut().remove_root_nodes()?; - for (node, _) in nodes_embeddings { - let child_writer = writer - .new_writer_copied_data(writer.path.push_cloned(node.id.clone()), self) - .await?; - match node.content { - NodeContent::Resource(_res) => { - self.update_permissions_recursively( - &child_writer, - read_permission.clone(), - write_permission.clone(), - ) - .await?; - } - NodeContent::VRHeader(_) => { - let internals = self.get_profile_fs_internals_cloned(&child_writer.profile).await?; - internals - .permissions_index - .insert_path_permission( - child_writer.path.clone(), - read_permission.clone(), - write_permission.clone(), - ) - .await?; - self._update_fs_internals(writer.profile.clone(), internals).await?; - } - _ => continue, - } - } - } - - // Save the FSInternals into the FSDB - let internals = self.get_profile_fs_internals_cloned(&writer.profile).await?; - self.save_profile_fs_internals(internals, &writer.profile).await?; - - Ok(()) - }) - } - - /// Extracts the VRPack into the VectorFS underneath the folder specified in the writer's path. Uses the VRPack's name - /// as the folder name which everything gets extracted into. - pub async fn extract_vrpack_in_folder(&self, writer: &VFSWriter, vrpack: VRPack) -> Result<(), VectorFSError> { - // Construct the base path for the VRPack extraction - let base_path = writer.path.clone(); - - // Check if an entry already exists at vec_fs_base_path - let unpack_destination_path = base_path.push_cloned(vrpack.name.to_string()); - if self - .validate_path_points_to_entry(unpack_destination_path.clone(), &writer.profile) - .await - .is_ok() - { - return Err(VectorFSError::CannotOverwriteFSEntry(unpack_destination_path.clone())); - } - - let vrkais_with_paths = vrpack.unpack_all_vrkais()?; - let mut folder_merkle_hash_map: HashMap = HashMap::new(); - - for (vrkai, path) in vrkais_with_paths { - let parent_folder_path = base_path.append_path_cloned(&path.parent_path()); - let parent_folder_writer = writer.new_writer_copied_data(parent_folder_path.clone(), self).await?; - // Create the folders - let new_folders = self - .create_new_folder_auto(&parent_folder_writer, parent_folder_path.clone()) - .await?; - // Save the VRKai in its final location - self.save_vrkai_in_folder(&parent_folder_writer, vrkai).await?; - - // Now update the folder merkle hash map - for full_folder_path in new_folders { - // Remove the base path from the full folder path - let mut folder_path = full_folder_path.clone(); - for _ in base_path.path_ids.iter() { - folder_path.front_pop(); - } - // Skip if empty - if folder_path.path_ids.is_empty() { - continue; - } - if folder_merkle_hash_map.get(&folder_path).is_none() { - let merkle_hash = vrpack.get_folder_merkle_hash(folder_path.clone())?; - folder_merkle_hash_map.insert(full_folder_path, merkle_hash); - } - } - } - - // Sets the Merkle hashes for a collection of folders. - self._set_folders_merkle_hashes( - writer, - folder_merkle_hash_map - .iter() - .map(|(path, hash)| (path.clone(), hash.clone())) - .collect(), - base_path.clone(), - ) - .await?; - - Ok(()) - } - - /// Internal method which sets the merkle hashes of folders in the VectorFS - /// without updating any other folder merkle hashes during setting. - /// Then once done setting all merkle hashes, updates the merkle hashes of all folders - /// from base_path and upwards. - async fn _set_folders_merkle_hashes( - &self, - writer: &VFSWriter, - folder_paths_with_hashes: Vec<(VRPath, String)>, - base_path: VRPath, - ) -> Result<(), VectorFSError> { - { - // Fetch the profile's file system internals - let mut internals = self.get_profile_fs_internals_cloned(&writer.profile).await?; - - // Iterate over each folder path and its corresponding Merkle hash - for (folder_path, merkle_hash) in folder_paths_with_hashes { - // Use the core resource to set the Merkle hash at the specified path - internals - .fs_core_resource - ._set_resource_merkle_hash_at_path(folder_path, merkle_hash) - .map_err(VectorFSError::from)?; // Convert VRError to VectorFSError as needed - } - - // Once done with merkle hash updates, update the merkle hashes of all folders from base_path and upwards. - internals - .fs_core_resource - ._update_resource_merkle_hash_at_path(base_path, true)?; - self._update_fs_internals(writer.profile.clone(), internals).await?; - } - - // Finally saving the profile fs internals - let internals = self.get_profile_fs_internals_cloned(&writer.profile).await?; - self.save_profile_fs_internals(internals, &writer.profile).await?; - Ok(()) - } - - /// Saves a VRKai into an FSItem at the exact path specified in writer (ie. `.../{parent_folder}/resource_name`) - /// If a FSItem already exists underneath the writer's path, then updates(overwrites) it. - /// Does not support saving into VecFS root. - pub async fn save_vrkai(&self, writer: &VFSWriter, vrkai: VRKai) -> Result { - let parent_folder_path = writer.path.pop_cloned(); - let new_writer = writer.new_writer_copied_data(parent_folder_path.clone(), self).await?; - self.save_vrkai_in_folder(&new_writer, vrkai).await - } - - /// Saves a VRKai into an FSItem, underneath the FSFolder at the writer's path. - /// If a FSItem with the same name (as the VR) already exists underneath the current path, then updates(overwrites) it. - /// Does not support saving into VecFS root. - pub async fn save_vrkai_in_folder(&self, writer: &VFSWriter, vrkai: VRKai) -> Result { - self.save_vector_resource_in_folder(writer, vrkai.resource, vrkai.sfm) - .await - } - - /// Saves a Vector Resource and optional SourceFile into an FSItem at the exact path specified in writer (ie. `.../{parent_folder}/resource_name`) - /// If a FSItem already exists underneath the writer's path, then updates(overwrites) it. - /// Does not support saving into VecFS root. - pub async fn save_vector_resource( - &self, - writer: &VFSWriter, - resource: BaseVectorResource, - source_file_map: Option, - ) -> Result { - let parent_folder_path = writer.path.pop_cloned(); - let new_writer = writer.new_writer_copied_data(parent_folder_path.clone(), self).await?; - self.save_vector_resource_in_folder(&new_writer, resource, source_file_map) - .await - } - - /// Saves a Vector Resource and optional SourceFile into an FSItem, underneath the FSFolder at the writer's path. - /// If a FSItem with the same name (as the VR) already exists underneath the current path, then updates(overwrites) it. - /// Does not support saving into VecFS root. - pub async fn save_vector_resource_in_folder( - &self, - writer: &VFSWriter, - resource: BaseVectorResource, - source_file_map: Option, - ) -> Result { - let mut resource = resource; - - let vr_header = resource.as_trait_object().generate_resource_header(); - let source_db_key = vr_header.reference_string(); - let resource_name = SourceFileType::clean_string_of_extension(resource.as_trait_object().name()); - resource.as_trait_object_mut().set_name(resource_name.clone()); - let node_path = writer.path.push_cloned(resource_name.to_string()); - let mut node_metadata = None; - let mut node_at_path_already_exists = false; - #[allow(unused_assignments)] - let mut new_item = None; - - { - // Ensure path of writer points at a folder before proceeding - self.validate_path_points_to_folder(writer.path.clone(), &writer.profile) - .await?; - // If an existing FSFolder is already saved at the node path, return error. - if let Ok(_) = self - .validate_path_points_to_folder(node_path.clone(), &writer.profile) - .await - { - return Err(VectorFSError::CannotOverwriteFolder(node_path.clone())); - } - // If an existing FSItem is saved at the node path - let mut existing_vr_ref = None; - if let Ok(_) = self - .validate_path_points_to_item(node_path.clone(), &writer.profile) - .await - { - if let Ok(ret_node) = self - ._retrieve_core_resource_node_at_path(node_path.clone(), &writer.profile) - .await - { - node_metadata.clone_from(&ret_node.node.metadata); - node_at_path_already_exists = true; - if let Ok(vr_header) = ret_node.node.get_vr_header_content() { - existing_vr_ref = Some(vr_header.reference_string()); - } - } - } - - // Check if an existing VR is saved in the FSDB with the same reference string. If so, re-generate id of the current resource. - if existing_vr_ref != Some(resource.as_trait_object().reference_string()) { - if let Ok(_r) = self - .db - .get_resource(&resource.as_trait_object().reference_string(), &writer.profile) - { - resource.as_trait_object_mut().generate_and_update_resource_id(); - } - } - - // Now all validation checks/setup have passed, move forward with saving header/resource/source file - let current_datetime = ShinkaiTime::generate_time_now(); - // Update the metadata keys of the FSItem node - let mut node_metadata = node_metadata.unwrap_or_else(HashMap::new); - node_metadata.insert(FSItem::vr_last_saved_metadata_key(), current_datetime.to_rfc3339()); - if let Some(sfm) = &source_file_map { - // Last Saved SFM - node_metadata.insert( - FSItem::source_file_map_last_saved_metadata_key(), - current_datetime.to_rfc3339(), - ); - // SFM Size - let sfm_size = sfm.encoded_size()?; - node_metadata.insert(FSItem::source_file_map_size_metadata_key(), sfm_size.to_string()); - } - // Update vr_size key in metadata - let vr_size = resource.as_trait_object().encoded_size()?; - node_metadata.insert(FSItem::vr_size_metadata_key(), vr_size.to_string()); - - // Now after updating the metadata, finally save the VRHeader Node into the core vector resource - { - new_item = Some( - self._add_vr_header_to_core_resource( - writer, - vr_header, - Some(node_metadata), - current_datetime, - !node_at_path_already_exists, - ) - .await?, - ); - } - } - - // Now that we've inserted the the new item into the fs internals core VR proceed forward - if let Some(item) = new_item { - // Determine permissions based on whether the parent folder is root - // This shouldn't be possible now but just to play it safe - let (read_permission, write_permission) = if writer.path == VRPath::root() { - (ReadPermission::Private, WritePermission::Private) - } else { - // Read the permissions of the parent folder - let parent_permissions = self - .get_profile_fs_internals_cloned(&writer.profile) - .await? - .permissions_index - .get_path_permission(&writer.path) - .await - .unwrap_or(PathPermission { - read_permission: ReadPermission::Private, - write_permission: WritePermission::Private, - whitelist: HashMap::new(), - }); - (parent_permissions.read_permission, parent_permissions.write_permission) - }; - - // Add read/write permission for the new item path - { - let internals = self.get_profile_fs_internals_cloned(&writer.profile).await?; - internals - .permissions_index - .insert_path_permission(item.path.clone(), read_permission, write_permission) - .await?; - self._update_fs_internals(writer.profile.clone(), internals).await?; - } - - // Finally saving the resource, the source file (if it was provided), and the FSInternals into the FSDB - let write_batch = writer.new_write_batch()?; - if let Some(sfm) = source_file_map { - self.db.save_source_file_map(&sfm, &source_db_key, &writer.profile)?; - } - self.db.save_resource(&resource, &write_batch.profile_name)?; - let internals = self.get_profile_fs_internals_cloned(&writer.profile).await?; - self.save_profile_fs_internals(internals, &writer.profile).await?; - - Ok(item) - } else { - Err(VectorFSError::NoEntryAtPath(node_path)) - } - } - - /// Updates the SourceFileMap of the FSItem at the writer's path. - /// If no FSItem with the same name already exists underneath the current path, then errors. - pub async fn update_source_file_map( - &self, - writer: &VFSWriter, - source_file_map: SourceFileMap, - ) -> Result { - let mut source_db_key = String::new(); - let mut node_metadata = None; - let mut vr_header = None; - #[allow(unused_assignments)] - let mut new_item = None; - - { - // If an existing FSFolder is already saved at the node path, return error. - if let Ok(_) = self - .validate_path_points_to_folder(writer.path.clone(), &writer.profile) - .await - { - return Err(VectorFSError::CannotOverwriteFolder(writer.path.clone())); - } - // If an existing FSItem is saved at the node path - if let Ok(_) = self - .validate_path_points_to_item(writer.path.clone(), &writer.profile) - .await - { - if let Ok(ret_node) = self - ._retrieve_core_resource_node_at_path(writer.path.clone(), &writer.profile) - .await - { - if let Ok(header) = ret_node.node.get_vr_header_content() { - node_metadata.clone_from(&ret_node.node.metadata); - vr_header = Some(header.clone()); - source_db_key = header.reference_string(); - } else { - return Err(VectorFSError::InvalidFSEntryType(writer.path.to_string())); - } - } - } - - // Now all validation checks/setup have passed, move forward with saving header/source file map - let current_datetime = ShinkaiTime::generate_time_now(); - // Update the metadata keys of the FSItem node - let mut node_metadata = node_metadata.unwrap_or_else(HashMap::new); - node_metadata.insert( - FSItem::source_file_map_last_saved_metadata_key(), - current_datetime.to_rfc3339(), - ); - let sfm_size = source_file_map.encoded_size()?; - node_metadata.insert(FSItem::source_file_map_size_metadata_key(), sfm_size.to_string()); - - // Now after updating the metadata, finally save the VRHeader Node into the core vector resource - let vr_header = vr_header.ok_or(VectorFSError::InvalidFSEntryType(writer.path.to_string()))?; - { - new_item = Some( - self._add_vr_header_to_core_resource( - writer, - vr_header, - Some(node_metadata), - current_datetime, - false, - ) - .await?, - ); - } - } - - // Finally saving the the source file map and the FSInternals into the FSDB - let write_batch = writer.new_write_batch()?; - self.db - .save_source_file_map(&source_file_map, &source_db_key, &writer.profile)?; - let internals = self.get_profile_fs_internals_cloned(&writer.profile).await?; - self.save_profile_fs_internals(internals, &writer.profile).await?; - - if let Some(item) = new_item { - Ok(item) - } else { - Err(VectorFSError::NoEntryAtPath(writer.path.clone())) - } - } - - /// Updates the description of the Vector Resource in the FSItem at the writer's path. - pub async fn update_item_resource_description( - &self, - writer: &VFSWriter, - description: String, - ) -> Result { - // Fetch the VR and SFM from the DB - let reader = writer.new_reader_copied_data(writer.path.clone(), self).await?; - let mut vector_resource = self.retrieve_vector_resource(&reader).await?; - vector_resource.as_trait_object_mut().set_description(Some(description)); - - // Now save the VR - Self::save_vector_resource(self, writer, vector_resource, None).await - } - - /// Internal method used to add a VRHeader into the core resource of a profile's VectorFS internals in memory. - async fn _add_vr_header_to_core_resource( - &self, - writer: &VFSWriter, - vr_header: VRHeader, - metadata: Option>, - current_datetime: DateTime, - adding_new_item_to_fs: bool, - ) -> Result { - let new_node_path = writer.path.push_cloned(vr_header.resource_name.clone()); - - // Mutator method for inserting the VR header and updating the last_modified metadata of parent folder - let mut mutator = |node: &mut Node, _embedding: &mut Embedding| -> Result<(), VRError> { - // If adding a new FSItem update last_modified key to be current date time. If overwriting existing item, - // or moving an item, then can skip. - if adding_new_item_to_fs { - node.metadata - .as_mut() - .map(|m| m.insert(FSFolder::last_modified_key(), current_datetime.to_rfc3339())); - } - // Setup the new node & insert it - let node_id = vr_header.resource_name.clone(); - let resource = node.get_vector_resource_content_mut()?; - let new_vr_header_node = Node::new_vr_header(node_id, &vr_header, metadata.clone(), &vec![]); - let new_node_embedding = vr_header - .resource_embedding - .clone() - .ok_or(VRError::NoEmbeddingProvided)?; - resource.as_trait_object_mut().insert_node_dt_specified( - vr_header.resource_name.clone(), - new_vr_header_node, - new_node_embedding, - Some(current_datetime), - true, - )?; - - // Update the resource's keywords. If no keywords, copy all, else random replace a few - if resource.as_trait_object_mut().keywords().keyword_list.is_empty() { - resource - .as_trait_object_mut() - .keywords_mut() - .set_keywords(vr_header.resource_keywords.keyword_list.clone()) - } else { - resource - .as_trait_object_mut() - .keywords_mut() - .random_replace_keywords(5, vr_header.resource_keywords.keyword_list.clone()) - } - Ok(()) - }; - - // If an embedding exists on the VR, and it is generated using the same embedding model - if vr_header.resource_embedding.clone().is_some() { - // Acquire a write lock on internals_map to ensure thread-safe access - let mut internals_map = self.internals_map.write().await; - let internals = internals_map - .get_mut(&writer.profile) - .ok_or_else(|| VectorFSError::ProfileNameNonExistent(writer.profile.to_string()))?; - - if vr_header.resource_embedding_model_used == internals.default_embedding_model() - || internals - .supported_embedding_models - .contains(&vr_header.resource_embedding_model_used) - { - internals - .fs_core_resource - .mutate_node_at_path(writer.path.clone(), &mut mutator, true)?; - // Update last read of the new FSItem - internals.last_read_index.update_path_last_read( - new_node_path.clone(), - current_datetime, - writer.requester_name.clone(), - ); - - let retrieved_node = internals - .fs_core_resource - .retrieve_node_at_path(new_node_path.clone(), None)?; - let new_item = FSItem::from_vr_header_node( - retrieved_node.node, - new_node_path.clone(), - &internals.last_read_index, - )?; - Ok(new_item) - } else { - // TODO: If the embedding model does not match, instead of error, regenerate the resource's embedding - // using the default embedding model and add it to the VRHeader in the FSItem. At the same time implement dynamic vector searching in VecFS to support this. - Err(VectorFSError::EmbeddingModelTypeMismatch( - vr_header.resource_embedding_model_used, - internals.default_embedding_model(), - )) - } - } else { - Err(VectorFSError::EmbeddingMissingInResource(vr_header.resource_name)) - } - } - - /// Internal method used to add an existing VectorResource into the core resource of a profile's VectorFS internals in memory. - /// Aka, add a folder into the VectorFS under the given path. - async fn _add_existing_vr_to_core_resource( - &self, - writer: &VFSWriter, - resource: BaseVectorResource, - embedding: Embedding, - metadata: Option>, - current_datetime: DateTime, - ) -> Result { - let resource_name = resource.as_trait_object().name().to_string(); - let resource_keywords = resource.as_trait_object().keywords().keyword_list.clone(); - let new_node_path = writer.path.push_cloned(resource_name.clone()); - - // Check the path points to a folder - if &writer.path != &VRPath::root() { - self.validate_path_points_to_folder(writer.path.clone(), &writer.profile) - .await?; - } - // Check if anything exists at the new node's path and error if so (cannot overwrite an existing FSEntry) - if let Ok(_) = self - .validate_path_points_to_entry(new_node_path.clone(), &writer.profile) - .await - { - return Err(VectorFSError::EntryAlreadyExistsAtPath(new_node_path)); - } - - // Acquire a write lock on internals_map to ensure thread-safe access - let mut internals_map = self.internals_map.write().await; - let internals = internals_map - .get_mut(&writer.profile) - .ok_or_else(|| VectorFSError::ProfileNameNonExistent(writer.profile.to_string()))?; - - // Check if parent is root, if so then direct insert into root and return, else proceed - if writer.path.is_empty() { - let new_node = Node::new_vector_resource(resource_name.clone(), &resource, metadata.clone()); - internals.fs_core_resource.insert_node_dt_specified( - resource_name.clone(), - new_node.clone(), - embedding.clone(), - None, - true, - )?; - // Update last read of the new FSFolder - internals.last_read_index.update_path_last_read( - new_node_path.clone(), - current_datetime, - writer.requester_name.clone(), - ); - - let folder = FSFolder::from_vector_resource_node(new_node, new_node_path, &internals.last_read_index)?; - return Ok(folder); - } - drop(internals_map); - - // Mutator method for inserting the VR and updating the last_modified metadata of parent folder - let mut mutator = |node: &mut Node, _: &mut Embedding| -> Result<(), VRError> { - // Update last_modified key of the parent folder - node.metadata - .as_mut() - .map(|m| m.insert(FSFolder::last_modified_key(), current_datetime.to_rfc3339())); - // Create the new folder child node and insert it - let new_node = Node::new_vector_resource(resource_name.clone(), &resource, metadata.clone()); - let parent_resource = node.get_vector_resource_content_mut()?; - parent_resource.as_trait_object_mut().insert_node_dt_specified( - resource_name.clone(), - new_node, - embedding.clone(), - None, - true, - )?; - - // If new resource has keywords, and none in target copy all, else random replace a few - if !resource_keywords.is_empty() { - if parent_resource.as_trait_object_mut().keywords().keyword_list.is_empty() { - parent_resource - .as_trait_object_mut() - .keywords_mut() - .set_keywords(resource_keywords.clone()) - } else { - parent_resource - .as_trait_object_mut() - .keywords_mut() - .random_replace_keywords(5, resource_keywords.clone()) - } - } - - Ok(()) - }; - - // Acquire a write lock on internals_map to ensure thread-safe access - let mut internals_map = self.internals_map.write().await; - let internals = internals_map - .get_mut(&writer.profile) - .ok_or_else(|| VectorFSError::ProfileNameNonExistent(writer.profile.to_string()))?; - internals - .fs_core_resource - .mutate_node_at_path(writer.path.clone(), &mut mutator, true)?; - // Update last read of the new FSFolder - internals.last_read_index.update_path_last_read( - new_node_path.clone(), - current_datetime, - writer.requester_name.clone(), - ); - - let retrieved_node = internals - .fs_core_resource - .retrieve_node_at_path(new_node_path.clone(), None)?; - let folder = - FSFolder::from_vector_resource_node(retrieved_node.node, new_node_path, &internals.last_read_index)?; - - Ok(folder) - } - - /// Internal method used to remove a child node underneath the writer's path, given its id. Applies only in memory. - /// This only works if path is a folder/root and node_id is either an item or folder underneath, and node_id points - /// to a valid node. - async fn _remove_child_node_from_core_resource( - &self, - writer: &VFSWriter, - node_id: String, - ) -> Result<(Node, Embedding), VectorFSError> { - let mut internals_map = self.internals_map.write().await; - let internals = internals_map - .get_mut(&writer.profile) - .ok_or_else(|| VectorFSError::ProfileNameNonExistent(writer.profile.to_string()))?; - - let path = writer.path.push_cloned(node_id); - Ok(internals.fs_core_resource.remove_node_at_path(path, true)?) - } - - /// Internal method used to remove the node at path. Applies only in memory. - /// Errors if no node exists at path. - async fn _remove_node_from_core_resource(&self, writer: &VFSWriter) -> Result<(Node, Embedding), VectorFSError> { - let mut internals = self.get_profile_fs_internals_cloned(&writer.profile).await?; - let result = internals - .fs_core_resource - .remove_node_at_path(writer.path.clone(), true)?; - self._update_fs_internals(writer.profile.clone(), internals).await?; - Ok(result) - } - - /// Internal method used to get a child node underneath the writer's path, given its id. Applies only in memory. - /// This only works if path is a folder and node_id is either an item or folder underneath, and node_id points - /// to a valid node. - async fn _get_child_node_from_core_resource( - &self, - writer: &VFSWriter, - node_id: String, - ) -> Result<(RetrievedNode, Embedding), VectorFSError> { - let internals = self.get_profile_fs_internals_cloned(&writer.profile).await?; - let path = writer.path.push_cloned(node_id); - let result = internals - .fs_core_resource - .retrieve_node_and_embedding_at_path(path, None)?; - Ok(result) - } - - /// Internal method used to get the node at writer's path. Applies only in memory. - /// Errors if no node exists at path. - async fn _get_node_from_core_resource( - &self, - writer: &VFSWriter, - ) -> Result<(RetrievedNode, Embedding), VectorFSError> { - let internals = self.get_profile_fs_internals_cloned(&writer.profile).await?; - let result = internals - .fs_core_resource - .retrieve_node_and_embedding_at_path(writer.path.clone(), None)?; - Ok(result) - } -} - -/// Represents an operation to be performed in a transaction. -#[derive(Debug, Clone)] -pub enum TransactionOperation { - Write(String, String, Vec), // Represents a key-value pair to write - Delete(String, String), // Represents a key to delete -} - -/// A struct that offers a profile-bounded interface for write operations. -/// All keys are prefixed with the profile name. -pub struct ProfileBoundWriteBatch { - pub operations: Vec, - pub profile_name: String, -} - -impl ProfileBoundWriteBatch { - /// Create a new ProfileBoundWriteBatch with ShinkaiDBError wrapping - pub fn new(profile: &ShinkaiName) -> Result { - // Also validates that the name includes a profile - let profile_name = Self::get_profile_name_string(profile)?; - // Create write batch - let operations = Vec::new(); - Ok(Self { - profile_name, - operations, - }) - } - - /// Create a new ProfileBoundWriteBatch with VectorFSError wrapping - pub fn new_vfs_batch(profile: &ShinkaiName) -> Result { - // Also validates that the name includes a profile - match Self::get_profile_name_string(profile) { - Ok(profile_name) => { - Ok(Self { - operations: Vec::new(), // Initialize the operations vector - profile_name, - }) - } - Err(e) => Err(VectorFSError::FailedCreatingProfileBoundWriteBatch(e.to_string())), - } - } - - /// Extracts the profile name with ShinkaiDBError wrapping - pub fn get_profile_name_string(profile: &ShinkaiName) -> Result { - profile - .get_profile_name_string() - .ok_or(VectorFSError::ShinkaiNameLacksProfile) - } - - /// Saves the value inside of the key (profile-bound) at the provided column family. - pub fn pb_put_cf(&mut self, cf_name: &str, key: &str, value: V) - where - V: AsRef<[u8]>, - { - let new_key = self.gen_pb_key(key); - self.operations.push(TransactionOperation::Write( - cf_name.to_string(), - new_key, - value.as_ref().to_vec(), - )); - } - - /// Removes the value inside of the key (profile-bound) at the provided column family. - pub fn pb_delete_cf(&mut self, cf_name: &str, key: &str) { - let new_key = self.gen_pb_key(key); - self.operations - .push(TransactionOperation::Delete(cf_name.to_string(), new_key)); - } - - /// Given an input key, generates the profile bound key using the internal profile. - pub fn gen_pb_key(&self, key: &str) -> String { - Self::generate_profile_bound_key_from_str(key, &self.profile_name) - } - - /// Prepends the profile name to the provided key to make it "profile bound" - pub fn generate_profile_bound_key_from_str(key: &str, profile_name: &str) -> String { - let mut prof_name = profile_name.to_string() + ":"; - prof_name.push_str(key); - prof_name - } -} diff --git a/shinkai-libs/shinkai-vector-fs/src/welcome_files/mod.rs b/shinkai-libs/shinkai-vector-fs/src/welcome_files/mod.rs deleted file mode 100644 index aef384f78..000000000 --- a/shinkai-libs/shinkai-vector-fs/src/welcome_files/mod.rs +++ /dev/null @@ -1,3 +0,0 @@ -pub mod welcome_message; -pub mod shinkai_faq; -pub mod shinkai_whitepaper; \ No newline at end of file diff --git a/shinkai-libs/shinkai-vector-fs/src/welcome_files/shinkai_faq.rs b/shinkai-libs/shinkai-vector-fs/src/welcome_files/shinkai_faq.rs deleted file mode 100644 index dbdd1748e..000000000 --- a/shinkai-libs/shinkai-vector-fs/src/welcome_files/shinkai_faq.rs +++ /dev/null @@ -1,2 +0,0 @@ -/// To update this file, just upload any new version to Shinkai and download it. Then, copy the contents of the downloaded file to this variable. -pub const SHINKAI_FAQ_VRKAI: &str = r#"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"#; diff --git a/shinkai-libs/shinkai-vector-fs/src/welcome_files/shinkai_whitepaper.rs b/shinkai-libs/shinkai-vector-fs/src/welcome_files/shinkai_whitepaper.rs deleted file mode 100644 index 47cce74ed..000000000 --- a/shinkai-libs/shinkai-vector-fs/src/welcome_files/shinkai_whitepaper.rs +++ /dev/null @@ -1 +0,0 @@ -pub const SHINKAI_WHITEPAPER_VRKAI: &str = r#"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"#; \ No newline at end of file diff --git a/shinkai-libs/shinkai-vector-fs/src/welcome_files/welcome_message.rs b/shinkai-libs/shinkai-vector-fs/src/welcome_files/welcome_message.rs deleted file mode 100644 index bd68ca8fa..000000000 --- a/shinkai-libs/shinkai-vector-fs/src/welcome_files/welcome_message.rs +++ /dev/null @@ -1,11 +0,0 @@ -pub const WELCOME_MESSAGE: &str = r#" -Welcome to Shinkai - your all-in-one AI app! - -* Use any AI model, with complete data privacy when running models on your device. -* Chat with your files and find information quickly, as Shinkai supports various file types. -* Make your AI smarter by connecting your AI to up-to-date information through our decentralized network. -* (Coming Soon) Have a personal AI assistant securely handle tasks for you by storing your passwords and credentials exclusively on your device. -* (Coming in May) Benefit from Shinkai's open-source transparency and contribute to the project if you're a developer. - -If you have any other questions about Shinkai, feel free to ask me. You can also start a new chat with me to talk about other topics! -"#; diff --git a/shinkai-libs/shinkai-vector-resources/Cargo.lock b/shinkai-libs/shinkai-vector-resources/Cargo.lock deleted file mode 100644 index 389f51fda..000000000 --- a/shinkai-libs/shinkai-vector-resources/Cargo.lock +++ /dev/null @@ -1,2723 +0,0 @@ -# This file is automatically @generated by Cargo. -# It is not intended for manual editing. -version = 3 - -[[package]] -name = "addr2line" -version = "0.21.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb" -dependencies = [ - "gimli", -] - -[[package]] -name = "adler" -version = "1.0.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe" - -[[package]] -name = "ahash" -version = "0.8.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "72832d73be48bac96a5d7944568f305d829ed55b0ce3b483647089dfaf6cf704" -dependencies = [ - "cfg-if", - "getrandom", - "once_cell", - "version_check", - "zerocopy", -] - -[[package]] -name = "aho-corasick" -version = "1.0.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c378d78423fdad8089616f827526ee33c19f2fddbd5de1629152c9593ba4783" -dependencies = [ - "memchr", -] - -[[package]] -name = "android-tzdata" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0" - -[[package]] -name = "android_system_properties" -version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311" -dependencies = [ - "libc", -] - -[[package]] -name = "anstream" -version = "0.6.13" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d96bd03f33fe50a863e394ee9718a706f988b9079b20c3784fb726e7678b62fb" -dependencies = [ - "anstyle", - "anstyle-parse", - "anstyle-query", - "anstyle-wincon", - "colorchoice", - "utf8parse", -] - -[[package]] -name = "anstyle" -version = "1.0.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8901269c6307e8d93993578286ac0edf7f195079ffff5ebdeea6a59ffb7e36bc" - -[[package]] -name = "anstyle-parse" -version = "0.2.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c75ac65da39e5fe5ab759307499ddad880d724eed2f6ce5b5e8a26f4f387928c" -dependencies = [ - "utf8parse", -] - -[[package]] -name = "anstyle-query" -version = "1.0.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e28923312444cdd728e4738b3f9c9cac739500909bb3d3c94b43551b16517648" -dependencies = [ - "windows-sys 0.52.0", -] - -[[package]] -name = "anstyle-wincon" -version = "3.0.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1cd54b81ec8d6180e24654d0b371ad22fc3dd083b6ff8ba325b72e00c87660a7" -dependencies = [ - "anstyle", - "windows-sys 0.52.0", -] - -[[package]] -name = "anyhow" -version = "1.0.75" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a4668cab20f66d8d020e1fbc0ebe47217433c1b6c8f2040faf858554e394ace6" - -[[package]] -name = "arbitrary" -version = "1.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7d5a26814d8dcb93b0e5a0ff3c6d80a8843bafb21b39e8e18a6f05471870e110" -dependencies = [ - "derive_arbitrary", -] - -[[package]] -name = "arrayref" -version = "0.3.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6b4930d2cb77ce62f89ee5d5289b4ac049559b1c45539271f5ed4fdc7db34545" - -[[package]] -name = "arrayvec" -version = "0.7.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711" - -[[package]] -name = "async-recursion" -version = "1.0.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5fd55a5ba1179988837d24ab4c7cc8ed6efdeff578ede0416b4225a5fca35bd0" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.31", -] - -[[package]] -name = "async-trait" -version = "0.1.74" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a66537f1bb974b254c98ed142ff995236e81b9d0fe4db0575f46612cb15eb0f9" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.31", -] - -[[package]] -name = "atty" -version = "0.2.14" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8" -dependencies = [ - "hermit-abi 0.1.19", - "libc", - "winapi", -] - -[[package]] -name = "autocfg" -version = "1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa" - -[[package]] -name = "backtrace" -version = "0.3.69" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2089b7e3f35b9dd2d0ed921ead4f6d318c27680d4a5bd167b3ee120edb105837" -dependencies = [ - "addr2line", - "cc", - "cfg-if", - "libc", - "miniz_oxide", - "object", - "rustc-demangle", -] - -[[package]] -name = "base64" -version = "0.13.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8" - -[[package]] -name = "base64" -version = "0.21.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "414dcefbc63d77c526a76b3afcf6fbb9b5e2791c19c3aa2297733208750c6e53" - -[[package]] -name = "bincode" -version = "1.3.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad" -dependencies = [ - "serde", -] - -[[package]] -name = "bit-set" -version = "0.5.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1" -dependencies = [ - "bit-vec", -] - -[[package]] -name = "bit-vec" -version = "0.6.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb" - -[[package]] -name = "bitflags" -version = "1.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" - -[[package]] -name = "bitflags" -version = "2.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b4682ae6287fcf752ecaabbfcc7b6f9b72aa33933dc23a554d853aea8eea8635" - -[[package]] -name = "blake3" -version = "1.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0231f06152bf547e9c2b5194f247cd97aacf6dcd8b15d8e5ec0663f64580da87" -dependencies = [ - "arrayref", - "arrayvec", - "cc", - "cfg-if", - "constant_time_eq", -] - -[[package]] -name = "bumpalo" -version = "3.13.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a3e2c3daef883ecc1b5d58c15adae93470a91d425f3532ba1695849656af3fc1" - -[[package]] -name = "byteorder" -version = "1.4.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610" - -[[package]] -name = "bytes" -version = "1.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "89b2fd2a0dcf38d7971e2194b6b6eebab45ae01067456a7fd93d5547a61b70be" - -[[package]] -name = "cc" -version = "1.0.83" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0" -dependencies = [ - "libc", -] - -[[package]] -name = "cfg-if" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" - -[[package]] -name = "chrono" -version = "0.4.31" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f2c685bad3eb3d45a01354cedb7d5faa66194d1d58ba6e267a8de788f79db38" -dependencies = [ - "android-tzdata", - "iana-time-zone", - "js-sys", - "num-traits", - "serde", - "wasm-bindgen", - "windows-targets 0.48.5", -] - -[[package]] -name = "chrono-tz" -version = "0.5.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2554a3155fec064362507487171dcc4edc3df60cb10f3a1fb10ed8094822b120" -dependencies = [ - "chrono", - "parse-zoneinfo", -] - -[[package]] -name = "clap" -version = "4.4.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e578d6ec4194633722ccf9544794b71b1385c3c027efe0c55db226fc880865c" -dependencies = [ - "clap_builder", - "clap_derive", -] - -[[package]] -name = "clap_builder" -version = "4.4.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4df4df40ec50c46000231c914968278b1eb05098cf8f1b3a518a95030e71d1c7" -dependencies = [ - "anstream", - "anstyle", - "clap_lex", - "strsim", - "terminal_size", -] - -[[package]] -name = "clap_derive" -version = "4.4.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf9804afaaf59a91e75b022a30fb7229a7901f60c755489cc61c9b423b836442" -dependencies = [ - "heck", - "proc-macro2", - "quote", - "syn 2.0.31", -] - -[[package]] -name = "clap_lex" -version = "0.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "702fc72eb24e5a1e48ce58027a675bc24edd52096d5397d4aea7c6dd9eca0bd1" - -[[package]] -name = "colorchoice" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "acbf1af155f9b9ef647e42cdc158db4b64a1b61f743629225fde6f3e0be2a7c7" - -[[package]] -name = "comrak" -version = "0.22.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d0436149c9f6a1935b13306206c739b1ba84fa81f551b5eb87fc2ca7a13700af" -dependencies = [ - "clap", - "derive_builder", - "entities", - "memchr", - "once_cell", - "regex", - "shell-words", - "slug", - "syntect", - "typed-arena", - "unicode_categories", - "xdg", -] - -[[package]] -name = "constant_time_eq" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f7144d30dcf0fafbce74250a3963025d8d52177934239851c917d29f1df280c2" - -[[package]] -name = "convert_case" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e" - -[[package]] -name = "core-foundation" -version = "0.9.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "194a7a9e6de53fa55116934067c844d9d749312f75c6f6d0980e8c252f8c2146" -dependencies = [ - "core-foundation-sys", - "libc", -] - -[[package]] -name = "core-foundation-sys" -version = "0.8.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e496a50fda8aacccc86d7529e2c1e0892dbd0f898a6b5645b5561b89c3210efa" - -[[package]] -name = "crc32fast" -version = "1.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b3855a8a784b474f333699ef2bbca9db2c4a1f6d9088a90a2d25b1eb53111eaa" -dependencies = [ - "cfg-if", -] - -[[package]] -name = "crossbeam-utils" -version = "0.8.19" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "248e3bacc7dc6baa3b21e405ee045c3047101a49145e7e9eca583ab4c2ca5345" - -[[package]] -name = "cssparser" -version = "0.31.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b3df4f93e5fbbe73ec01ec8d3f68bba73107993a5b1e7519273c32db9b0d5be" -dependencies = [ - "cssparser-macros", - "dtoa-short", - "itoa", - "phf 0.11.2", - "smallvec", -] - -[[package]] -name = "cssparser-macros" -version = "0.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "13b588ba4ac1a99f7f2964d24b3d896ddc6bf847ee3855dbd4366f058cfcd331" -dependencies = [ - "quote", - "syn 2.0.31", -] - -[[package]] -name = "csv" -version = "1.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "626ae34994d3d8d668f4269922248239db4ae42d538b14c398b74a52208e8086" -dependencies = [ - "csv-core", - "itoa", - "ryu", - "serde", -] - -[[package]] -name = "csv-core" -version = "0.1.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90" -dependencies = [ - "memchr", -] - -[[package]] -name = "darling" -version = "0.14.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7b750cb3417fd1b327431a470f388520309479ab0bf5e323505daf0290cd3850" -dependencies = [ - "darling_core", - "darling_macro", -] - -[[package]] -name = "darling_core" -version = "0.14.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "109c1ca6e6b7f82cc233a97004ea8ed7ca123a9af07a8230878fcfda9b158bf0" -dependencies = [ - "fnv", - "ident_case", - "proc-macro2", - "quote", - "strsim", - "syn 1.0.109", -] - -[[package]] -name = "darling_macro" -version = "0.14.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a4aab4dbc9f7611d8b55048a3a16d2d010c2c8334e46304b40ac1cc14bf3b48e" -dependencies = [ - "darling_core", - "quote", - "syn 1.0.109", -] - -[[package]] -name = "deranged" -version = "0.3.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4" -dependencies = [ - "powerfmt", -] - -[[package]] -name = "derive_arbitrary" -version = "1.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "67e77553c4162a157adbf834ebae5b415acbecbeafc7a74b0e886657506a7611" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.31", -] - -[[package]] -name = "derive_builder" -version = "0.12.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8d67778784b508018359cbc8696edb3db78160bab2c2a28ba7f56ef6932997f8" -dependencies = [ - "derive_builder_macro", -] - -[[package]] -name = "derive_builder_core" -version = "0.12.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c11bdc11a0c47bc7d37d582b5285da6849c96681023680b906673c5707af7b0f" -dependencies = [ - "darling", - "proc-macro2", - "quote", - "syn 1.0.109", -] - -[[package]] -name = "derive_builder_macro" -version = "0.12.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ebcda35c7a396850a55ffeac740804b40ffec779b98fffbb1738f4033f0ee79e" -dependencies = [ - "derive_builder_core", - "syn 1.0.109", -] - -[[package]] -name = "derive_more" -version = "0.99.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4fb810d30a7c1953f91334de7244731fc3f3c10d7fe163338a35b9f640960321" -dependencies = [ - "convert_case", - "proc-macro2", - "quote", - "rustc_version", - "syn 1.0.109", -] - -[[package]] -name = "deunicode" -version = "1.4.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "322ef0094744e63628e6f0eb2295517f79276a5b342a4c2ff3042566ca181d4e" - -[[package]] -name = "displaydoc" -version = "0.2.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "487585f4d0c6655fe74905e2504d8ad6908e4db67f744eb140876906c2f3175d" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.31", -] - -[[package]] -name = "docx-rust" -version = "0.1.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "895c3d3886569f4b8ae770b29a5fca9ac31ccdfbf91c5ff006d93c74449367c4" -dependencies = [ - "derive_more", - "hard-xml", - "log", - "zip", -] - -[[package]] -name = "dtoa" -version = "1.0.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dcbb2bf8e87535c23f7a8a321e364ce21462d0ff10cb6407820e8e96dfff6653" - -[[package]] -name = "dtoa-short" -version = "0.3.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dbaceec3c6e4211c79e7b1800fb9680527106beb2f9c51904a3210c03a448c74" -dependencies = [ - "dtoa", -] - -[[package]] -name = "ego-tree" -version = "0.6.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3a68a4904193147e0a8dec3314640e6db742afd5f6e634f428a6af230d9b3591" - -[[package]] -name = "encoding_rs" -version = "0.8.33" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7268b386296a025e474d5140678f75d6de9493ae55a5d709eeb9dd08149945e1" -dependencies = [ - "cfg-if", -] - -[[package]] -name = "entities" -version = "1.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b5320ae4c3782150d900b79807611a59a99fc9a1d61d686faafc24b93fc8d7ca" - -[[package]] -name = "env_logger" -version = "0.9.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a12e6657c4c97ebab115a42dcee77225f7f482cdd841cf7088c657a42e9e00e7" -dependencies = [ - "atty", - "humantime", - "log", - "regex", - "termcolor", -] - -[[package]] -name = "equivalent" -version = "1.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5" - -[[package]] -name = "errno" -version = "0.3.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "136526188508e25c6fef639d7927dfb3e0e3084488bf202267829cf7fc23dbdd" -dependencies = [ - "errno-dragonfly", - "libc", - "windows-sys 0.48.0", -] - -[[package]] -name = "errno-dragonfly" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf" -dependencies = [ - "cc", - "libc", -] - -[[package]] -name = "fancy-regex" -version = "0.11.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b95f7c0680e4142284cf8b22c14a476e87d61b004a3a0861872b32ef7ead40a2" -dependencies = [ - "bit-set", - "regex", -] - -[[package]] -name = "fastrand" -version = "2.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6999dc1837253364c2ebb0704ba97994bd874e8f195d665c50b7548f6ea92764" - -[[package]] -name = "flate2" -version = "1.0.28" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "46303f565772937ffe1d394a4fac6f411c6013172fadde9dcdb1e147a086940e" -dependencies = [ - "crc32fast", - "miniz_oxide", -] - -[[package]] -name = "fnv" -version = "1.0.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" - -[[package]] -name = "foreign-types" -version = "0.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1" -dependencies = [ - "foreign-types-shared", -] - -[[package]] -name = "foreign-types-shared" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b" - -[[package]] -name = "form_urlencoded" -version = "1.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a62bc1cf6f830c2ec14a513a9fb124d0a213a629668a4186f329db21fe045652" -dependencies = [ - "percent-encoding", -] - -[[package]] -name = "futf" -version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "df420e2e84819663797d1ec6544b13c5be84629e7bb00dc960d6917db2987843" -dependencies = [ - "mac", - "new_debug_unreachable", -] - -[[package]] -name = "futures" -version = "0.3.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0" -dependencies = [ - "futures-channel", - "futures-core", - "futures-executor", - "futures-io", - "futures-sink", - "futures-task", - "futures-util", -] - -[[package]] -name = "futures-channel" -version = "0.3.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78" -dependencies = [ - "futures-core", - "futures-sink", -] - -[[package]] -name = "futures-core" -version = "0.3.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d" - -[[package]] -name = "futures-executor" -version = "0.3.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a576fc72ae164fca6b9db127eaa9a9dda0d61316034f33a0a0d4eda41f02b01d" -dependencies = [ - "futures-core", - "futures-task", - "futures-util", -] - -[[package]] -name = "futures-io" -version = "0.3.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1" - -[[package]] -name = "futures-macro" -version = "0.3.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.31", -] - -[[package]] -name = "futures-sink" -version = "0.3.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5" - -[[package]] -name = "futures-task" -version = "0.3.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004" - -[[package]] -name = "futures-util" -version = "0.3.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48" -dependencies = [ - "futures-channel", - "futures-core", - "futures-io", - "futures-macro", - "futures-sink", - "futures-task", - "memchr", - "pin-project-lite", - "pin-utils", - "slab", -] - -[[package]] -name = "fxhash" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c" -dependencies = [ - "byteorder", -] - -[[package]] -name = "getopts" -version = "0.2.21" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "14dbbfd5c71d70241ecf9e6f13737f7b5ce823821063188d7e46c41d371eebd5" -dependencies = [ - "unicode-width", -] - -[[package]] -name = "getrandom" -version = "0.2.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "be4136b2a15dd319360be1c07d9933517ccf0be8f16bf62a3bee4f0d618df427" -dependencies = [ - "cfg-if", - "libc", - "wasi", -] - -[[package]] -name = "gimli" -version = "0.28.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6fb8d784f27acf97159b40fc4db5ecd8aa23b9ad5ef69cdd136d3bc80665f0c0" - -[[package]] -name = "h2" -version = "0.3.21" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "91fc23aa11be92976ef4729127f1a74adf36d8436f7816b185d18df956790833" -dependencies = [ - "bytes", - "fnv", - "futures-core", - "futures-sink", - "futures-util", - "http", - "indexmap 1.9.3", - "slab", - "tokio", - "tokio-util", - "tracing", -] - -[[package]] -name = "hard-xml" -version = "1.36.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a344e0cef8802f37dc47f17c01a04354d3e66d9f6c8744108b0912f616efe266" -dependencies = [ - "hard-xml-derive", - "jetscii", - "lazy_static", - "memchr", - "xmlparser", -] - -[[package]] -name = "hard-xml-derive" -version = "1.36.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1bfae7cdfe23e50ea96929ccf1948d9ae1d8608353556461e5de247463d3a4f6" -dependencies = [ - "bitflags 2.4.0", - "proc-macro2", - "quote", - "syn 1.0.109", -] - -[[package]] -name = "hashbrown" -version = "0.12.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" - -[[package]] -name = "hashbrown" -version = "0.14.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604" - -[[package]] -name = "heck" -version = "0.4.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8" - -[[package]] -name = "hermit-abi" -version = "0.1.19" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33" -dependencies = [ - "libc", -] - -[[package]] -name = "hermit-abi" -version = "0.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "443144c8cdadd93ebf52ddb4056d257f5b52c04d3c804e657d19eb73fc33668b" - -[[package]] -name = "hex" -version = "0.4.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" - -[[package]] -name = "html5ever" -version = "0.26.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bea68cab48b8459f17cf1c944c67ddc572d272d9f2b274140f223ecb1da4a3b7" -dependencies = [ - "log", - "mac", - "markup5ever", - "proc-macro2", - "quote", - "syn 1.0.109", -] - -[[package]] -name = "http" -version = "0.2.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bd6effc99afb63425aff9b05836f029929e345a6148a14b7ecd5ab67af944482" -dependencies = [ - "bytes", - "fnv", - "itoa", -] - -[[package]] -name = "http-body" -version = "0.4.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d5f38f16d184e36f2408a55281cd658ecbd3ca05cce6d6510a176eca393e26d1" -dependencies = [ - "bytes", - "http", - "pin-project-lite", -] - -[[package]] -name = "httparse" -version = "1.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d897f394bad6a705d5f4104762e116a75639e470d80901eed05a860a95cb1904" - -[[package]] -name = "httpdate" -version = "1.0.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9" - -[[package]] -name = "humantime" -version = "2.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4" - -[[package]] -name = "hyper" -version = "0.14.27" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ffb1cfd654a8219eaef89881fdb3bb3b1cdc5fa75ded05d6933b2b382e395468" -dependencies = [ - "bytes", - "futures-channel", - "futures-core", - "futures-util", - "h2", - "http", - "http-body", - "httparse", - "httpdate", - "itoa", - "pin-project-lite", - "socket2 0.4.9", - "tokio", - "tower-service", - "tracing", - "want", -] - -[[package]] -name = "hyper-tls" -version = "0.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905" -dependencies = [ - "bytes", - "hyper", - "native-tls", - "tokio", - "tokio-native-tls", -] - -[[package]] -name = "iana-time-zone" -version = "0.1.58" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8326b86b6cff230b97d0d312a6c40a60726df3332e721f72a1b035f451663b20" -dependencies = [ - "android_system_properties", - "core-foundation-sys", - "iana-time-zone-haiku", - "js-sys", - "wasm-bindgen", - "windows-core", -] - -[[package]] -name = "iana-time-zone-haiku" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f" -dependencies = [ - "cc", -] - -[[package]] -name = "ident_case" -version = "1.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39" - -[[package]] -name = "idna" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7d20d6b07bfbc108882d88ed8e37d39636dcc260e15e30c45e6ba089610b917c" -dependencies = [ - "unicode-bidi", - "unicode-normalization", -] - -[[package]] -name = "indexmap" -version = "1.9.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99" -dependencies = [ - "autocfg", - "hashbrown 0.12.3", -] - -[[package]] -name = "indexmap" -version = "2.2.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26" -dependencies = [ - "equivalent", - "hashbrown 0.14.3", -] - -[[package]] -name = "ipnet" -version = "2.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "28b29a3cd74f0f4598934efe3aeba42bae0eb4680554128851ebbecb02af14e6" - -[[package]] -name = "itoa" -version = "1.0.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "af150ab688ff2122fcef229be89cb50dd66af9e01a4ff320cc137eecc9bacc38" - -[[package]] -name = "jetscii" -version = "0.5.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "47f142fe24a9c9944451e8349de0a56af5f3e7226dc46f3ed4d4ecc0b85af75e" - -[[package]] -name = "js-sys" -version = "0.3.64" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c5f195fe497f702db0f318b07fdd68edb16955aed830df8363d837542f8f935a" -dependencies = [ - "wasm-bindgen", -] - -[[package]] -name = "keyphrases" -version = "0.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d3469baa50de5674276e5328795aec868ab2cbf2e52ae830b7c36d39b737a4a2" -dependencies = [ - "regex", -] - -[[package]] -name = "lazy_static" -version = "1.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" - -[[package]] -name = "libc" -version = "0.2.153" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd" - -[[package]] -name = "line-wrap" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dd1bc4d24ad230d21fb898d1116b1801d7adfc449d42026475862ab48b11e70e" - -[[package]] -name = "linked-hash-map" -version = "0.5.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f" - -[[package]] -name = "linux-raw-sys" -version = "0.4.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "57bcfdad1b858c2db7c38303a6d2ad4dfaf5eb53dfeb0910128b2c26d6158503" - -[[package]] -name = "lock_api" -version = "0.4.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c1cc9717a20b1bb222f333e6a92fd32f7d8a18ddc5a3191a11af45dcbf4dcd16" -dependencies = [ - "autocfg", - "scopeguard", -] - -[[package]] -name = "log" -version = "0.4.20" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f" - -[[package]] -name = "lz4_flex" -version = "0.11.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "912b45c753ff5f7f5208307e8ace7d2a2e30d024e26d3509f3dce546c044ce15" -dependencies = [ - "twox-hash", -] - -[[package]] -name = "mac" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4" - -[[package]] -name = "markup5ever" -version = "0.11.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a2629bb1404f3d34c2e921f21fd34ba00b206124c81f65c50b43b6aaefeb016" -dependencies = [ - "log", - "phf 0.10.1", - "phf_codegen", - "string_cache", - "string_cache_codegen", - "tendril", -] - -[[package]] -name = "memchr" -version = "2.6.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f232d6ef707e1956a43342693d2a31e72989554d58299d7a88738cc95b0d35c" - -[[package]] -name = "mime" -version = "0.3.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a" - -[[package]] -name = "mime_guess" -version = "2.0.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4192263c238a5f0d0c6bfd21f336a313a4ce1c450542449ca191bb657b4642ef" -dependencies = [ - "mime", - "unicase", -] - -[[package]] -name = "miniz_oxide" -version = "0.7.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e7810e0be55b428ada41041c41f32c9f1a42817901b4ccf45fa3d4b6561e74c7" -dependencies = [ - "adler", -] - -[[package]] -name = "mio" -version = "0.8.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c" -dependencies = [ - "libc", - "wasi", - "windows-sys 0.48.0", -] - -[[package]] -name = "native-tls" -version = "0.2.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07226173c32f2926027b63cce4bcd8076c3552846cbe7925f3aaffeac0a3b92e" -dependencies = [ - "lazy_static", - "libc", - "log", - "openssl", - "openssl-probe", - "openssl-sys", - "schannel", - "security-framework", - "security-framework-sys", - "tempfile", -] - -[[package]] -name = "new_debug_unreachable" -version = "1.0.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e4a24736216ec316047a1fc4252e27dabb04218aa4a3f37c6e7ddbf1f9782b54" - -[[package]] -name = "num-conv" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9" - -[[package]] -name = "num-traits" -version = "0.2.16" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f30b0abd723be7e2ffca1272140fac1a2f084c77ec3e123c192b66af1ee9e6c2" -dependencies = [ - "autocfg", -] - -[[package]] -name = "num_cpus" -version = "1.16.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43" -dependencies = [ - "hermit-abi 0.3.2", - "libc", -] - -[[package]] -name = "object" -version = "0.32.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9cf5f9dd3933bd50a9e1f149ec995f39ae2c496d31fd772c1fd45ebc27e902b0" -dependencies = [ - "memchr", -] - -[[package]] -name = "once_cell" -version = "1.19.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92" - -[[package]] -name = "onig" -version = "6.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8c4b31c8722ad9171c6d77d3557db078cab2bd50afcc9d09c8b315c59df8ca4f" -dependencies = [ - "bitflags 1.3.2", - "libc", - "once_cell", - "onig_sys", -] - -[[package]] -name = "onig_sys" -version = "69.8.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7b829e3d7e9cc74c7e315ee8edb185bf4190da5acde74afd7fc59c35b1f086e7" -dependencies = [ - "cc", - "pkg-config", -] - -[[package]] -name = "openssl" -version = "0.10.57" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bac25ee399abb46215765b1cb35bc0212377e58a061560d8b29b024fd0430e7c" -dependencies = [ - "bitflags 2.4.0", - "cfg-if", - "foreign-types", - "libc", - "once_cell", - "openssl-macros", - "openssl-sys", -] - -[[package]] -name = "openssl-macros" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.31", -] - -[[package]] -name = "openssl-probe" -version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf" - -[[package]] -name = "openssl-sys" -version = "0.9.93" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "db4d56a4c0478783083cfafcc42493dd4a981d41669da64b4572a2a089b51b1d" -dependencies = [ - "cc", - "libc", - "pkg-config", - "vcpkg", -] - -[[package]] -name = "ordered-float" -version = "3.9.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2a54938017eacd63036332b4ae5c8a49fc8c0c1d6d629893057e4f13609edd06" -dependencies = [ - "num-traits", -] - -[[package]] -name = "parking_lot" -version = "0.12.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f" -dependencies = [ - "lock_api", - "parking_lot_core", -] - -[[package]] -name = "parking_lot_core" -version = "0.9.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "93f00c865fe7cabf650081affecd3871070f26767e7b2070a3ffae14c654b447" -dependencies = [ - "cfg-if", - "libc", - "redox_syscall", - "smallvec", - "windows-targets 0.48.5", -] - -[[package]] -name = "parse-zoneinfo" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c705f256449c60da65e11ff6626e0c16a0a0b96aaa348de61376b249bc340f41" -dependencies = [ - "regex", -] - -[[package]] -name = "percent-encoding" -version = "2.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b2a4787296e9989611394c33f193f676704af1686e70b8f8033ab5ba9a35a94" - -[[package]] -name = "phf" -version = "0.10.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fabbf1ead8a5bcbc20f5f8b939ee3f5b0f6f281b6ad3468b84656b658b455259" -dependencies = [ - "phf_shared 0.10.0", -] - -[[package]] -name = "phf" -version = "0.11.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ade2d8b8f33c7333b51bcf0428d37e217e9f32192ae4772156f65063b8ce03dc" -dependencies = [ - "phf_macros", - "phf_shared 0.11.2", -] - -[[package]] -name = "phf_codegen" -version = "0.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4fb1c3a8bc4dd4e5cfce29b44ffc14bedd2ee294559a294e2a4d4c9e9a6a13cd" -dependencies = [ - "phf_generator 0.10.0", - "phf_shared 0.10.0", -] - -[[package]] -name = "phf_generator" -version = "0.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5d5285893bb5eb82e6aaf5d59ee909a06a16737a8970984dd7746ba9283498d6" -dependencies = [ - "phf_shared 0.10.0", - "rand", -] - -[[package]] -name = "phf_generator" -version = "0.11.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "48e4cc64c2ad9ebe670cb8fd69dd50ae301650392e81c05f9bfcb2d5bdbc24b0" -dependencies = [ - "phf_shared 0.11.2", - "rand", -] - -[[package]] -name = "phf_macros" -version = "0.11.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3444646e286606587e49f3bcf1679b8cef1dc2c5ecc29ddacaffc305180d464b" -dependencies = [ - "phf_generator 0.11.2", - "phf_shared 0.11.2", - "proc-macro2", - "quote", - "syn 2.0.31", -] - -[[package]] -name = "phf_shared" -version = "0.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6796ad771acdc0123d2a88dc428b5e38ef24456743ddb1744ed628f9815c096" -dependencies = [ - "siphasher", -] - -[[package]] -name = "phf_shared" -version = "0.11.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "90fcb95eef784c2ac79119d1dd819e162b5da872ce6f3c3abe1e8ca1c082f72b" -dependencies = [ - "siphasher", -] - -[[package]] -name = "pin-project-lite" -version = "0.2.13" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58" - -[[package]] -name = "pin-utils" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" - -[[package]] -name = "pkg-config" -version = "0.3.27" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26072860ba924cbfa98ea39c8c19b4dd6a4a25423dbdf219c1eca91aa0cf6964" - -[[package]] -name = "plist" -version = "1.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d9d34169e64b3c7a80c8621a48adaf44e0cf62c78a9b25dd9dd35f1881a17cf9" -dependencies = [ - "base64 0.21.3", - "indexmap 2.2.6", - "line-wrap", - "quick-xml", - "serde", - "time", -] - -[[package]] -name = "powerfmt" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391" - -[[package]] -name = "ppv-lite86" -version = "0.2.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de" - -[[package]] -name = "precomputed-hash" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c" - -[[package]] -name = "proc-macro2" -version = "1.0.66" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "18fb31db3f9bddb2ea821cde30a9f70117e3f119938b5ee630b7403aa6e2ead9" -dependencies = [ - "unicode-ident", -] - -[[package]] -name = "quick-xml" -version = "0.31.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1004a344b30a54e2ee58d66a71b32d2db2feb0a31f9a2d302bf0536f15de2a33" -dependencies = [ - "memchr", -] - -[[package]] -name = "quote" -version = "1.0.33" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae" -dependencies = [ - "proc-macro2", -] - -[[package]] -name = "rand" -version = "0.8.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" -dependencies = [ - "libc", - "rand_chacha", - "rand_core", -] - -[[package]] -name = "rand_chacha" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" -dependencies = [ - "ppv-lite86", - "rand_core", -] - -[[package]] -name = "rand_core" -version = "0.6.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" -dependencies = [ - "getrandom", -] - -[[package]] -name = "redox_syscall" -version = "0.3.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29" -dependencies = [ - "bitflags 1.3.2", -] - -[[package]] -name = "regex" -version = "1.9.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "697061221ea1b4a94a624f67d0ae2bfe4e22b8a17b6a192afb11046542cc8c47" -dependencies = [ - "aho-corasick", - "memchr", - "regex-automata", - "regex-syntax 0.7.5", -] - -[[package]] -name = "regex-automata" -version = "0.3.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c2f401f4955220693b56f8ec66ee9c78abffd8d1c4f23dc41a23839eb88f0795" -dependencies = [ - "aho-corasick", - "memchr", - "regex-syntax 0.7.5", -] - -[[package]] -name = "regex-syntax" -version = "0.7.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dbb5fb1acd8a1a18b3dd5be62d25485eb770e05afb408a9627d14d451bae12da" - -[[package]] -name = "regex-syntax" -version = "0.8.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "adad44e29e4c806119491a7f06f03de4d1af22c3a680dd47f1e6e179439d1f56" - -[[package]] -name = "reqwest" -version = "0.11.24" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c6920094eb85afde5e4a138be3f2de8bbdf28000f0029e72c45025a56b042251" -dependencies = [ - "base64 0.21.3", - "bytes", - "encoding_rs", - "futures-core", - "futures-util", - "h2", - "http", - "http-body", - "hyper", - "hyper-tls", - "ipnet", - "js-sys", - "log", - "mime", - "mime_guess", - "native-tls", - "once_cell", - "percent-encoding", - "pin-project-lite", - "rustls-pemfile", - "serde", - "serde_json", - "serde_urlencoded", - "sync_wrapper", - "system-configuration", - "tokio", - "tokio-native-tls", - "tower-service", - "url", - "wasm-bindgen", - "wasm-bindgen-futures", - "web-sys", - "winreg", -] - -[[package]] -name = "rustc-demangle" -version = "0.1.23" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76" - -[[package]] -name = "rustc_version" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366" -dependencies = [ - "semver", -] - -[[package]] -name = "rustix" -version = "0.38.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c0c3dde1fc030af041adc40e79c0e7fbcf431dd24870053d187d7c66e4b87453" -dependencies = [ - "bitflags 2.4.0", - "errno", - "libc", - "linux-raw-sys", - "windows-sys 0.48.0", -] - -[[package]] -name = "rustls-pemfile" -version = "1.0.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c" -dependencies = [ - "base64 0.21.3", -] - -[[package]] -name = "ryu" -version = "1.0.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1ad4cc8da4ef723ed60bced201181d83791ad433213d8c24efffda1eec85d741" - -[[package]] -name = "same-file" -version = "1.0.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" -dependencies = [ - "winapi-util", -] - -[[package]] -name = "schannel" -version = "0.1.22" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c3733bf4cf7ea0880754e19cb5a462007c4a8c1914bff372ccc95b464f1df88" -dependencies = [ - "windows-sys 0.48.0", -] - -[[package]] -name = "scopeguard" -version = "1.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" - -[[package]] -name = "scraper" -version = "0.19.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b80b33679ff7a0ea53d37f3b39de77ea0c75b12c5805ac43ec0c33b3051af1b" -dependencies = [ - "ahash", - "cssparser", - "ego-tree", - "getopts", - "html5ever", - "once_cell", - "selectors", - "tendril", -] - -[[package]] -name = "security-framework" -version = "2.9.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "05b64fb303737d99b81884b2c63433e9ae28abebe5eb5045dcdd175dc2ecf4de" -dependencies = [ - "bitflags 1.3.2", - "core-foundation", - "core-foundation-sys", - "libc", - "security-framework-sys", -] - -[[package]] -name = "security-framework-sys" -version = "2.9.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e932934257d3b408ed8f30db49d85ea163bfe74961f017f405b025af298f0c7a" -dependencies = [ - "core-foundation-sys", - "libc", -] - -[[package]] -name = "selectors" -version = "0.25.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4eb30575f3638fc8f6815f448d50cb1a2e255b0897985c8c59f4d37b72a07b06" -dependencies = [ - "bitflags 2.4.0", - "cssparser", - "derive_more", - "fxhash", - "log", - "new_debug_unreachable", - "phf 0.10.1", - "phf_codegen", - "precomputed-hash", - "servo_arc", - "smallvec", -] - -[[package]] -name = "semver" -version = "1.0.23" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b" - -[[package]] -name = "serde" -version = "1.0.188" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf9e0fcba69a370eed61bcf2b728575f726b50b55cba78064753d708ddc7549e" -dependencies = [ - "serde_derive", -] - -[[package]] -name = "serde_derive" -version = "1.0.188" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4eca7ac642d82aa35b60049a6eccb4be6be75e599bd2e9adb5f875a737654af2" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.31", -] - -[[package]] -name = "serde_json" -version = "1.0.105" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "693151e1ac27563d6dbcec9dee9fbd5da8539b20fa14ad3752b2e6d363ace360" -dependencies = [ - "itoa", - "ryu", - "serde", -] - -[[package]] -name = "serde_urlencoded" -version = "0.7.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd" -dependencies = [ - "form_urlencoded", - "itoa", - "ryu", - "serde", -] - -[[package]] -name = "servo_arc" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d036d71a959e00c77a63538b90a6c2390969f9772b096ea837205c6bd0491a44" -dependencies = [ - "stable_deref_trait", -] - -[[package]] -name = "shell-words" -version = "1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "24188a676b6ae68c3b2cb3a01be17fbf7240ce009799bb56d5b1409051e78fde" - -[[package]] -name = "shinkai_vector_resources" -version = "0.1.0" -dependencies = [ - "anyhow", - "async-recursion", - "async-trait", - "base64 0.13.1", - "blake3", - "byteorder", - "chrono", - "chrono-tz", - "comrak", - "csv", - "docx-rust", - "env_logger", - "futures", - "hex", - "keyphrases", - "lazy_static", - "lz4_flex", - "ordered-float", - "rand", - "regex", - "reqwest", - "scraper", - "serde", - "serde_json", - "textcode", - "tokio", - "urlencoding", -] - -[[package]] -name = "signal-hook-registry" -version = "1.4.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d8229b473baa5980ac72ef434c4415e70c4b5e71b423043adb4ba059f89c99a1" -dependencies = [ - "libc", -] - -[[package]] -name = "siphasher" -version = "0.3.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d" - -[[package]] -name = "slab" -version = "0.4.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67" -dependencies = [ - "autocfg", -] - -[[package]] -name = "slug" -version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3bd94acec9c8da640005f8e135a39fc0372e74535e6b368b7a04b875f784c8c4" -dependencies = [ - "deunicode", - "wasm-bindgen", -] - -[[package]] -name = "smallvec" -version = "1.11.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "942b4a808e05215192e39f4ab80813e599068285906cc91aa64f923db842bd5a" - -[[package]] -name = "socket2" -version = "0.4.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "64a4a911eed85daf18834cfaa86a79b7d266ff93ff5ba14005426219480ed662" -dependencies = [ - "libc", - "winapi", -] - -[[package]] -name = "socket2" -version = "0.5.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "05ffd9c0a93b7543e062e759284fcf5f5e3b098501104bfbdde4d404db792871" -dependencies = [ - "libc", - "windows-sys 0.52.0", -] - -[[package]] -name = "stable_deref_trait" -version = "1.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" - -[[package]] -name = "static_assertions" -version = "1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f" - -[[package]] -name = "string_cache" -version = "0.8.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f91138e76242f575eb1d3b38b4f1362f10d3a43f47d182a5b359af488a02293b" -dependencies = [ - "new_debug_unreachable", - "once_cell", - "parking_lot", - "phf_shared 0.10.0", - "precomputed-hash", - "serde", -] - -[[package]] -name = "string_cache_codegen" -version = "0.5.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6bb30289b722be4ff74a408c3cc27edeaad656e06cb1fe8fa9231fa59c728988" -dependencies = [ - "phf_generator 0.10.0", - "phf_shared 0.10.0", - "proc-macro2", - "quote", -] - -[[package]] -name = "strsim" -version = "0.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623" - -[[package]] -name = "syn" -version = "1.0.109" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237" -dependencies = [ - "proc-macro2", - "quote", - "unicode-ident", -] - -[[package]] -name = "syn" -version = "2.0.31" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "718fa2415bcb8d8bd775917a1bf12a7931b6dfa890753378538118181e0cb398" -dependencies = [ - "proc-macro2", - "quote", - "unicode-ident", -] - -[[package]] -name = "sync_wrapper" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160" - -[[package]] -name = "syntect" -version = "5.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "874dcfa363995604333cf947ae9f751ca3af4522c60886774c4963943b4746b1" -dependencies = [ - "bincode", - "bitflags 1.3.2", - "fancy-regex", - "flate2", - "fnv", - "once_cell", - "onig", - "plist", - "regex-syntax 0.8.3", - "serde", - "serde_derive", - "serde_json", - "thiserror", - "walkdir", - "yaml-rust", -] - -[[package]] -name = "system-configuration" -version = "0.5.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7" -dependencies = [ - "bitflags 1.3.2", - "core-foundation", - "system-configuration-sys", -] - -[[package]] -name = "system-configuration-sys" -version = "0.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a75fb188eb626b924683e3b95e3a48e63551fcfb51949de2f06a9d91dbee93c9" -dependencies = [ - "core-foundation-sys", - "libc", -] - -[[package]] -name = "tempfile" -version = "3.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cb94d2f3cc536af71caac6b6fcebf65860b347e7ce0cc9ebe8f70d3e521054ef" -dependencies = [ - "cfg-if", - "fastrand", - "redox_syscall", - "rustix", - "windows-sys 0.48.0", -] - -[[package]] -name = "tendril" -version = "0.4.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d24a120c5fc464a3458240ee02c299ebcb9d67b5249c8848b09d639dca8d7bb0" -dependencies = [ - "futf", - "mac", - "utf-8", -] - -[[package]] -name = "termcolor" -version = "1.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "be55cf8942feac5c765c2c993422806843c9a9a45d4d5c407ad6dd2ea95eb9b6" -dependencies = [ - "winapi-util", -] - -[[package]] -name = "terminal_size" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "21bebf2b7c9e0a515f6e0f8c51dc0f8e4696391e6f1ff30379559f8365fb0df7" -dependencies = [ - "rustix", - "windows-sys 0.48.0", -] - -[[package]] -name = "textcode" -version = "0.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "383d5314770f8b7b2129936c78638db0dad1cfc9e7ef78706d4ccf9f0a0677fd" - -[[package]] -name = "thiserror" -version = "1.0.55" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6e3de26b0965292219b4287ff031fcba86837900fe9cd2b34ea8ad893c0953d2" -dependencies = [ - "thiserror-impl", -] - -[[package]] -name = "thiserror-impl" -version = "1.0.55" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "268026685b2be38d7103e9e507c938a1fcb3d7e6eb15e87870b617bf37b6d581" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.31", -] - -[[package]] -name = "time" -version = "0.3.36" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5dfd88e563464686c916c7e46e623e520ddc6d79fa6641390f2e3fa86e83e885" -dependencies = [ - "deranged", - "itoa", - "num-conv", - "powerfmt", - "serde", - "time-core", - "time-macros", -] - -[[package]] -name = "time-core" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3" - -[[package]] -name = "time-macros" -version = "0.2.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf" -dependencies = [ - "num-conv", - "time-core", -] - -[[package]] -name = "tinyvec" -version = "1.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50" -dependencies = [ - "tinyvec_macros", -] - -[[package]] -name = "tinyvec_macros" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" - -[[package]] -name = "tokio" -version = "1.36.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "61285f6515fa018fb2d1e46eb21223fff441ee8db5d0f1435e8ab4f5cdb80931" -dependencies = [ - "backtrace", - "bytes", - "libc", - "mio", - "num_cpus", - "parking_lot", - "pin-project-lite", - "signal-hook-registry", - "socket2 0.5.6", - "tokio-macros", - "windows-sys 0.48.0", -] - -[[package]] -name = "tokio-macros" -version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.31", -] - -[[package]] -name = "tokio-native-tls" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2" -dependencies = [ - "native-tls", - "tokio", -] - -[[package]] -name = "tokio-util" -version = "0.7.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "806fe8c2c87eccc8b3267cbae29ed3ab2d0bd37fca70ab622e46aaa9375ddb7d" -dependencies = [ - "bytes", - "futures-core", - "futures-sink", - "pin-project-lite", - "tokio", - "tracing", -] - -[[package]] -name = "tower-service" -version = "0.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52" - -[[package]] -name = "tracing" -version = "0.1.37" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8ce8c33a8d48bd45d624a6e523445fd21ec13d3653cd51f681abf67418f54eb8" -dependencies = [ - "cfg-if", - "pin-project-lite", - "tracing-core", -] - -[[package]] -name = "tracing-core" -version = "0.1.31" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0955b8137a1df6f1a2e9a37d8a6656291ff0297c1a97c24e0d8425fe2312f79a" -dependencies = [ - "once_cell", -] - -[[package]] -name = "try-lock" -version = "0.2.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3528ecfd12c466c6f163363caf2d02a71161dd5e1cc6ae7b34207ea2d42d81ed" - -[[package]] -name = "twox-hash" -version = "1.6.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675" -dependencies = [ - "cfg-if", - "static_assertions", -] - -[[package]] -name = "typed-arena" -version = "2.0.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6af6ae20167a9ece4bcb41af5b80f8a1f1df981f6391189ce00fd257af04126a" - -[[package]] -name = "unicase" -version = "2.7.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f7d2d4dafb69621809a81864c9c1b864479e1235c0dd4e199924b9742439ed89" -dependencies = [ - "version_check", -] - -[[package]] -name = "unicode-bidi" -version = "0.3.13" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "92888ba5573ff080736b3648696b70cafad7d250551175acbaa4e0385b3e1460" - -[[package]] -name = "unicode-ident" -version = "1.0.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "301abaae475aa91687eb82514b328ab47a211a533026cb25fc3e519b86adfc3c" - -[[package]] -name = "unicode-normalization" -version = "0.1.22" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c5713f0fc4b5db668a2ac63cdb7bb4469d8c9fed047b1d0292cc7b0ce2ba921" -dependencies = [ - "tinyvec", -] - -[[package]] -name = "unicode-width" -version = "0.1.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e51733f11c9c4f72aa0c160008246859e340b00807569a0da0e7a1079b27ba85" - -[[package]] -name = "unicode_categories" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "39ec24b3121d976906ece63c9daad25b85969647682eee313cb5779fdd69e14e" - -[[package]] -name = "url" -version = "2.4.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "143b538f18257fac9cad154828a57c6bf5157e1aa604d4816b5995bf6de87ae5" -dependencies = [ - "form_urlencoded", - "idna", - "percent-encoding", -] - -[[package]] -name = "urlencoding" -version = "1.3.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a1f0175e03a0973cf4afd476bef05c26e228520400eb1fd473ad417b1c00ffb" - -[[package]] -name = "utf-8" -version = "0.7.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9" - -[[package]] -name = "utf8parse" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a" - -[[package]] -name = "vcpkg" -version = "0.2.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426" - -[[package]] -name = "version_check" -version = "0.9.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f" - -[[package]] -name = "walkdir" -version = "2.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" -dependencies = [ - "same-file", - "winapi-util", -] - -[[package]] -name = "want" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e" -dependencies = [ - "try-lock", -] - -[[package]] -name = "wasi" -version = "0.11.0+wasi-snapshot-preview1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" - -[[package]] -name = "wasm-bindgen" -version = "0.2.87" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7706a72ab36d8cb1f80ffbf0e071533974a60d0a308d01a5d0375bf60499a342" -dependencies = [ - "cfg-if", - "wasm-bindgen-macro", -] - -[[package]] -name = "wasm-bindgen-backend" -version = "0.2.87" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ef2b6d3c510e9625e5fe6f509ab07d66a760f0885d858736483c32ed7809abd" -dependencies = [ - "bumpalo", - "log", - "once_cell", - "proc-macro2", - "quote", - "syn 2.0.31", - "wasm-bindgen-shared", -] - -[[package]] -name = "wasm-bindgen-futures" -version = "0.4.37" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c02dbc21516f9f1f04f187958890d7e6026df8d16540b7ad9492bc34a67cea03" -dependencies = [ - "cfg-if", - "js-sys", - "wasm-bindgen", - "web-sys", -] - -[[package]] -name = "wasm-bindgen-macro" -version = "0.2.87" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dee495e55982a3bd48105a7b947fd2a9b4a8ae3010041b9e0faab3f9cd028f1d" -dependencies = [ - "quote", - "wasm-bindgen-macro-support", -] - -[[package]] -name = "wasm-bindgen-macro-support" -version = "0.2.87" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "54681b18a46765f095758388f2d0cf16eb8d4169b639ab575a8f5693af210c7b" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.31", - "wasm-bindgen-backend", - "wasm-bindgen-shared", -] - -[[package]] -name = "wasm-bindgen-shared" -version = "0.2.87" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ca6ad05a4870b2bf5fe995117d3728437bd27d7cd5f06f13c17443ef369775a1" - -[[package]] -name = "web-sys" -version = "0.3.64" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b85cbef8c220a6abc02aefd892dfc0fc23afb1c6a426316ec33253a3877249b" -dependencies = [ - "js-sys", - "wasm-bindgen", -] - -[[package]] -name = "winapi" -version = "0.3.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" -dependencies = [ - "winapi-i686-pc-windows-gnu", - "winapi-x86_64-pc-windows-gnu", -] - -[[package]] -name = "winapi-i686-pc-windows-gnu" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" - -[[package]] -name = "winapi-util" -version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178" -dependencies = [ - "winapi", -] - -[[package]] -name = "winapi-x86_64-pc-windows-gnu" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" - -[[package]] -name = "windows-core" -version = "0.51.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1f8cf84f35d2db49a46868f947758c7a1138116f7fac3bc844f43ade1292e64" -dependencies = [ - "windows-targets 0.48.5", -] - -[[package]] -name = "windows-sys" -version = "0.48.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9" -dependencies = [ - "windows-targets 0.48.5", -] - -[[package]] -name = "windows-sys" -version = "0.52.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" -dependencies = [ - "windows-targets 0.52.4", -] - -[[package]] -name = "windows-targets" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c" -dependencies = [ - "windows_aarch64_gnullvm 0.48.5", - "windows_aarch64_msvc 0.48.5", - "windows_i686_gnu 0.48.5", - "windows_i686_msvc 0.48.5", - "windows_x86_64_gnu 0.48.5", - "windows_x86_64_gnullvm 0.48.5", - "windows_x86_64_msvc 0.48.5", -] - -[[package]] -name = "windows-targets" -version = "0.52.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7dd37b7e5ab9018759f893a1952c9420d060016fc19a472b4bb20d1bdd694d1b" -dependencies = [ - "windows_aarch64_gnullvm 0.52.4", - "windows_aarch64_msvc 0.52.4", - "windows_i686_gnu 0.52.4", - "windows_i686_msvc 0.52.4", - "windows_x86_64_gnu 0.52.4", - "windows_x86_64_gnullvm 0.52.4", - "windows_x86_64_msvc 0.52.4", -] - -[[package]] -name = "windows_aarch64_gnullvm" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8" - -[[package]] -name = "windows_aarch64_gnullvm" -version = "0.52.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bcf46cf4c365c6f2d1cc93ce535f2c8b244591df96ceee75d8e83deb70a9cac9" - -[[package]] -name = "windows_aarch64_msvc" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc" - -[[package]] -name = "windows_aarch64_msvc" -version = "0.52.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da9f259dd3bcf6990b55bffd094c4f7235817ba4ceebde8e6d11cd0c5633b675" - -[[package]] -name = "windows_i686_gnu" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e" - -[[package]] -name = "windows_i686_gnu" -version = "0.52.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b474d8268f99e0995f25b9f095bc7434632601028cf86590aea5c8a5cb7801d3" - -[[package]] -name = "windows_i686_msvc" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406" - -[[package]] -name = "windows_i686_msvc" -version = "0.52.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1515e9a29e5bed743cb4415a9ecf5dfca648ce85ee42e15873c3cd8610ff8e02" - -[[package]] -name = "windows_x86_64_gnu" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e" - -[[package]] -name = "windows_x86_64_gnu" -version = "0.52.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5eee091590e89cc02ad514ffe3ead9eb6b660aedca2183455434b93546371a03" - -[[package]] -name = "windows_x86_64_gnullvm" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc" - -[[package]] -name = "windows_x86_64_gnullvm" -version = "0.52.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "77ca79f2451b49fa9e2af39f0747fe999fcda4f5e241b2898624dca97a1f2177" - -[[package]] -name = "windows_x86_64_msvc" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" - -[[package]] -name = "windows_x86_64_msvc" -version = "0.52.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "32b752e52a2da0ddfbdbcc6fceadfeede4c939ed16d13e648833a61dfb611ed8" - -[[package]] -name = "winreg" -version = "0.50.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1" -dependencies = [ - "cfg-if", - "windows-sys 0.48.0", -] - -[[package]] -name = "xdg" -version = "2.5.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "213b7324336b53d2414b2db8537e56544d981803139155afa84f76eeebb7a546" - -[[package]] -name = "xmlparser" -version = "0.13.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "66fee0b777b0f5ac1c69bb06d361268faafa61cd4682ae064a171c16c433e9e4" - -[[package]] -name = "yaml-rust" -version = "0.4.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85" -dependencies = [ - "linked-hash-map", -] - -[[package]] -name = "zerocopy" -version = "0.7.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4c19fae0c8a9efc6a8281f2e623db8af1db9e57852e04cde3e754dd2dc29340f" -dependencies = [ - "zerocopy-derive", -] - -[[package]] -name = "zerocopy-derive" -version = "0.7.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fc56589e9ddd1f1c28d4b4b5c773ce232910a6bb67a70133d61c9e347585efe9" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.31", -] - -[[package]] -name = "zip" -version = "1.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ed14a57c18714abaa03196c0714ed36bab969d7457f72d12fb5c2e1ced4c24ae" -dependencies = [ - "arbitrary", - "crc32fast", - "crossbeam-utils", - "displaydoc", - "flate2", - "indexmap 2.2.6", - "thiserror", -] diff --git a/shinkai-libs/shinkai-vector-resources/Cargo.toml b/shinkai-libs/shinkai-vector-resources/Cargo.toml deleted file mode 100644 index ec1f78b79..000000000 --- a/shinkai-libs/shinkai-vector-resources/Cargo.toml +++ /dev/null @@ -1,64 +0,0 @@ -[package] -name = "shinkai_vector_resources" -version = { workspace = true } -edition = { workspace = true } -authors = { workspace = true } - -[dependencies] -lazy_static = "1.5.0" -regex = { workspace = true } -csv = "1.1.6" -serde_json = { workspace = true } -ordered-float = "3.7.0" -blake3 = { workspace = true } -keyphrases = "0.3.2" -async-trait = "0.1.74" -scraper = "0.19.0" -chrono = { workspace = true, features = ["serde"] } -rand = { workspace = true } -hex = { workspace = true } -lz4_flex = "0.11.0" -base64 = { workspace = true } -futures = { workspace = true } -urlencoding = "1.1.1" -docx-rust = "0.1.8" -shinkai_ocr = { path = "../shinkai-ocr", optional = true } -utoipa = "4.2.3" -num-traits = "0.2" -umya-spreadsheet = { version = "2.1.1", optional = true } -comrak = { version = "0.22.0", default-features = true, optional = true } -reqwest = { workspace = true, features = [ - "json", - "tokio-native-tls", - "blocking", - "multipart", - "default-tls", -] } -serde = { workspace = true, features = ["derive"] } - -[build-dependencies] -reqwest = { workspace = true, features = [ - "json", - "tokio-native-tls", - "blocking", - "multipart", -] } - -[features] -default = ["desktop-only"] -desktop-only = ["reqwest/blocking", "comrak", "shinkai_ocr", "umya-spreadsheet"] -static-pdf-parser = ["shinkai_ocr/static"] - -wasm-http = [] - -[dev-dependencies] -tokio = { workspace = true, features = ["full"] } - -[[test]] -name = "pdf_parsing_tests" -path = "tests/pdf_parsing_tests.rs" -required-features = ["static-pdf-parser"] - -[[test]] -name = "vector_resource_tests" -path = "tests/vector_resource_tests.rs" diff --git a/shinkai-libs/shinkai-vector-resources/README.md b/shinkai-libs/shinkai-vector-resources/README.md deleted file mode 100644 index 644197049..000000000 --- a/shinkai-libs/shinkai-vector-resources/README.md +++ /dev/null @@ -1,58 +0,0 @@ -# Shinkai Vector Resources - -A powerful native Rust fully in-memory/serializable Vector Search solution. - -A Vector Resource is made up of a hierarchy of nodes, where each node can either hold a piece of `Text` or another `Vector Resource`. Vector Searching can be performed starting from the root resource or from any path throughout the entire hierarchy, and with the easy-to-use enum-based TraversalMethod interface, offers great customizability of how results are found/scored. - -## Importing Into Your Project - -By default the library includes both async & blocking interfaces for parsing files into Vector Resources automatically (with hierarchy/embeddings auto-generated + batched). This ingestion is non-wasm compatible, and is included as a default feature called `desktop-only`. - -Past ingestion & generation of the Vector Resources themselves (which requires sending requests to Embedding Generation Server), all other parts of the library are pure Rust and are wasm compatible. As such, you can generate Vector Resources in non-wasm code and simply serialize/send them into the wasm side, to then use them freely with no issues. - -To disable `desktop-only` & support wasm, simply import as such: - -``` -shinkai_vector_resources = { path = "../shinkai-vector-resources", default-features = false } -``` - -Otherwise if you wish to include the file ingestion/Vector Resource generation interface: - -``` -shinkai_vector_resources = { path = "../shinkai-vector-resources" } -``` - -## How To Use Vector Resources - -Reference `vector_resource_tests.rs` to see the examples of the basic flow of: - -1. Ingesting a source document (pdf/txt/epub/...) into a Vector Resource -2. Generating a query -3. Performing a vector search on the resource using the query -4. Examining results - -Reference `vector_resource_tests.rs` to see examples of how to use advanced capabilities such as: - -1. Differences between DocumentVectorResource vs. MapVectorResource -2. How pathing works through the hierarchy (and making searches starting at arbitrary paths) -3. Different TaversalMethods available when making a Vector Search -4. Syntactic Vector Searches -5. Manual Vector Resource building (including manual hierarchy building) - -## Tests - -### Running Tests - -Of note, the tests read files which are held outside of this crate in the actual repo. In other words, they will fail if testing the crate alone. - -As such, if outside of the repo run: - -``` -cargo test --test vector_resource_tests -``` - -Else run: - -``` -cargo test -``` diff --git a/shinkai-libs/shinkai-vector-resources/scripts/compile_bert_cpp.sh b/shinkai-libs/shinkai-vector-resources/scripts/compile_bert_cpp.sh deleted file mode 100644 index fc93cd630..000000000 --- a/shinkai-libs/shinkai-vector-resources/scripts/compile_bert_cpp.sh +++ /dev/null @@ -1,11 +0,0 @@ -git clone https://github.com/robkorn/bert.cpp -cd bert.cpp -git submodule update --init --recursive -mkdir build -cd build -cmake .. -DBUILD_SHARED_LIBS=OFF -DCMAKE_BUILD_TYPE=Release -make -cd .. -cp build/bin/server ../bert-cpp-server -cd .. -rm -rf bert.cpp diff --git a/shinkai-libs/shinkai-vector-resources/src/data_tags.rs b/shinkai-libs/shinkai-vector-resources/src/data_tags.rs deleted file mode 100644 index c6b2990ba..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/data_tags.rs +++ /dev/null @@ -1,121 +0,0 @@ -use super::vector_resource::Node; -use regex::Regex; -use serde::{Deserialize, Serialize}; -use utoipa::ToSchema; -use std::collections::HashMap; -use std::error::Error; - -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] -pub struct DataTag { - pub name: String, - pub description: String, - pub regex_str: String, -} - -impl DataTag { - /// Validates the provided regex string and creates a new DataTag - pub fn new(name: &str, description: &str, regex_str: &str) -> Result> { - if !regex_str.is_empty() { - Regex::new(regex_str)?; // Attempt to compile regex, will error if invalid - } - Ok(Self { - name: name.to_string(), - description: description.to_string(), - regex_str: regex_str.to_string(), - }) - } - - /// Checks if the provided input string matches the regex of the DataTag - pub fn validate(&self, input_string: &str) -> bool { - // This should never fail in practice because in new we already checked - match Regex::new(&self.regex_str) { - Ok(regex) => regex.is_match(input_string), - Err(_) => false, - } - } - - /// Validates a list of tags and returns those that pass validation - pub fn validate_tag_list(input_string: &str, tag_list: &[DataTag]) -> Vec { - tag_list - .iter() - .filter(|tag| tag.validate(input_string)) - .cloned() // Clone each DataTag that passes validation - .collect() - } -} - -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, ToSchema)] -pub struct DataTagIndex { - index: HashMap>, -} - -// Add Default implementation for DataTagIndex -impl Default for DataTagIndex { - fn default() -> Self { - Self::new() - } -} - -impl DataTagIndex { - /// Initializes an empty DataTagIndex - pub fn new() -> Self { - Self { index: HashMap::new() } - } - - /// Returns list of names of all data tags part of the index - pub fn data_tag_names(&self) -> Vec { - self.index.keys().cloned().collect() - } - - /// Adds reference to the node (id) to all tags in the index that are - /// annotated on the node in node.content_tags - pub fn add_node(&mut self, node: &Node) { - self.add_node_id_multi_tags(&node.id, &node.data_tag_names); - } - - /// Removes all references to the node in the index - pub fn remove_node(&mut self, node: &Node) { - self.remove_node_id_multi_tags(&node.id, &node.data_tag_names); - } - - /// Deletes all references in the index associated with old_node, - /// replacing them with the new_node - pub fn replace_node(&mut self, old_node: &Node, new_node: &Node) { - self.remove_node(old_node); - self.add_node(new_node); - } - - /// Add a node id under several DataTags in the index - fn add_node_id_multi_tags(&mut self, id: &str, tag_names: &Vec) { - for name in tag_names { - self.add_node_id(id, name) - } - } - - /// Removes a node id under several DataTags in the index - fn remove_node_id_multi_tags(&mut self, id: &str, tag_names: &Vec) { - for name in tag_names { - self.remove_node_id(id, name) - } - } - - /// Add a node id under a DataTag in the index - fn add_node_id(&mut self, id: &str, tag_name: &str) { - let entry = self.index.entry(tag_name.to_string()).or_default(); - if !entry.contains(&id.to_string()) { - entry.push(id.to_string()); - } - } - - /// Remove a node id associated with a DataTag in the index - fn remove_node_id(&mut self, id: &str, tag_name: &str) { - if let Some(ids) = self.index.get_mut(tag_name) { - ids.retain(|x| x != id); - } - } - - /// Get node ids associated with a data tag name - pub fn get_node_ids(&self, data_tag_name: &str) -> Option<&Vec> { - self.index.get(data_tag_name) - } -} diff --git a/shinkai-libs/shinkai-vector-resources/src/embeddings.rs b/shinkai-libs/shinkai-vector-resources/src/embeddings.rs deleted file mode 100644 index 5fa23b67d..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/embeddings.rs +++ /dev/null @@ -1,135 +0,0 @@ -use ordered_float::NotNan; -use utoipa::ToSchema; -use std::cmp::Reverse; -use std::collections::BinaryHeap; - -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, ToSchema)] -/// A struct that represents a Vector Embedding with an added string id. -pub struct Embedding { - pub id: String, - pub vector: Vec, -} - -impl Embedding { - /// Creates a new `Embedding`. - pub fn new(id: &str, vector: Vec) -> Self { - Embedding { - id: String::from(id), - vector, - } - } - - /// Creates a new empty `Embedding`. - pub fn new_empty() -> Self { - Embedding::new("", vec![]) - } - - pub fn set_id(&mut self, id: String) { - self.id = id; - } - - pub fn set_id_with_integer(&mut self, id: u64) { - self.id = id.to_string(); - } - - /// Pretty print embedding info - pub fn pretty_print(&self) { - println!("Embedding ID: {}", self.id); - println!(" Embeddings length: {}", self.vector.len()); - println!(" Embeddings first 10: {:.02?}", &self.vector[0..10]); - } - - /// Calculate the cosine similarity score between the self embedding and the input embedding. - pub fn cosine_similarity(&self, embedding2: &Embedding) -> f32 { - let dot_product = self.dot(&self.vector, &embedding2.vector); - let magnitude1 = self.magnitude(&self.vector); - let magnitude2 = self.magnitude(&embedding2.vector); - - let result = dot_product / (magnitude1 * magnitude2); - if result.is_nan() || result < 0.0 { - 0.0 - } else { - result - } - } - - /// Calculate the dot product between two vectors. - fn dot(&self, v1: &[f32], v2: &[f32]) -> f32 { - v1.iter().zip(v2.iter()).map(|(&x, &y)| x * y).sum() - } - - /// Calculate the magnitude of a vector. - fn magnitude(&self, v: &[f32]) -> f32 { - v.iter().map(|&x| x * x).sum::().sqrt() - } - - /// Calculate the cosine similarity score between the self embedding and the input embedding. - /// This function is equivalent to `.cosine_similarity()` - pub fn score_similarity(&self, embedding: &Embedding) -> f32 { - self.cosine_similarity(embedding) - } - - /// Calculate the cosine similarity score between the self embedding - /// and a list of embeddings, returning the `num_of_results` - /// most similar embeddings as a tuple of (score, embedding_id) - pub fn score_similarities(&self, embeddings: &Vec, num_of_results: u64) -> Vec<(f32, String)> { - let num_of_results = num_of_results as usize; - - // Calculate the similarity scores for all node embeddings and skip any that - // are NaN or less than 0 - let scores: Vec<(NotNan, String)> = embeddings - .iter() - .filter_map(|embedding| { - let similarity = self.cosine_similarity(&embedding); - match NotNan::new(similarity) { - Ok(not_nan_similarity) => { - // If the similarity is a negative, set it to 0 to ensure sorting works properly - let final_similarity = if similarity < 0.0 { - NotNan::new(0.0).unwrap() // Safe unwrap - } else { - not_nan_similarity - }; - Some((final_similarity, embedding.id.clone())) - } - // If the similarity was Nan, set it to 0 to ensure sorting works properly - Err(_) => Some((NotNan::new(0.0).unwrap(), embedding.id.clone())), // Safe unwrap - } - }) - .collect(); - - // Use a binary heap to more efficiently order the scores to get most similar - let results = Self::bin_heap_order_scores(scores, num_of_results); - - results - } - - /// Order scores using a binary heap and return the most similar scores - pub fn bin_heap_order_scores(scores: Vec<(NotNan, G)>, num_of_results: usize) -> Vec<(f32, G)> - where - G: Clone + Ord, - { - let mut heap = BinaryHeap::with_capacity(num_of_results); - for score in scores { - if heap.len() < num_of_results { - heap.push(Reverse(score)); - } else if let Some(least_similar_score) = heap.peek() { - if least_similar_score.0 .0 < score.0 { - heap.pop(); - heap.push(Reverse(score)); - } - } - } - - // Create a Vec to hold the reversed results - let mut results: Vec<(f32, G)> = Vec::new(); - - while let Some(Reverse((similarity, id))) = heap.pop() { - results.push((similarity.into_inner(), id)); - } - - // Reverse the order of the scores so that the highest score is first - results.reverse(); - - results - } -} diff --git a/shinkai-libs/shinkai-vector-resources/src/file_parser/file_parser.rs b/shinkai-libs/shinkai-vector-resources/src/file_parser/file_parser.rs deleted file mode 100644 index 741462ad1..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/file_parser/file_parser.rs +++ /dev/null @@ -1,369 +0,0 @@ -use super::file_parser_types::TextGroup; -use super::local_parsing::LocalFileParser; -#[cfg(feature = "desktop-only")] -use crate::data_tags::DataTag; -use crate::embedding_generator::EmbeddingGenerator; -use crate::embeddings::Embedding; -use crate::resource_errors::VRError; -use crate::source::DistributionInfo; -use crate::source::TextChunkingStrategy; -use crate::source::VRSourceReference; -use crate::vector_resource::{BaseVectorResource, DocumentVectorResource, VectorResourceCore}; -#[cfg(feature = "desktop-only")] -use std::{future::Future, pin::Pin}; - -pub struct ShinkaiFileParser; - -impl ShinkaiFileParser { - #[cfg(feature = "desktop-only")] - pub async fn initialize_local_file_parser() -> Result<(), Box> { - use shinkai_ocr::image_parser::ImageParser; - - ImageParser::check_and_download_dependencies().await - } - - #[cfg(feature = "desktop-only")] - /// Processes the input file into a BaseVectorResource. - pub async fn process_file_into_resource( - file_buffer: Vec, - generator: &dyn EmbeddingGenerator, - file_name: String, - desc: Option, - parsing_tags: &Vec, - max_node_text_size: u64, - distribution_info: DistributionInfo, - ) -> Result { - let cleaned_name = ShinkaiFileParser::clean_name(&file_name); - let source = VRSourceReference::from_file(&file_name, TextChunkingStrategy::V1)?; - let text_groups = - Self::process_file_into_text_groups(file_buffer, file_name, max_node_text_size, source.clone()).await?; - - ShinkaiFileParser::process_groups_into_resource( - text_groups, - generator, - cleaned_name, - desc, - source, - parsing_tags, - max_node_text_size, - distribution_info, - ) - .await - } - - #[cfg(feature = "desktop-only")] - /// Processes the input file into a BaseVectorResource. - pub fn process_file_into_resource_blocking( - file_buffer: Vec, - generator: &dyn EmbeddingGenerator, - file_name: String, - desc: Option, - parsing_tags: &Vec, - max_node_text_size: u64, - distribution_info: DistributionInfo, - ) -> Result { - let cleaned_name = ShinkaiFileParser::clean_name(&file_name); - let source = VRSourceReference::from_file(&file_name, TextChunkingStrategy::V1)?; - let text_groups = ShinkaiFileParser::process_file_into_text_groups_blocking( - file_buffer, - file_name, - max_node_text_size, - source.clone(), - )?; - - // Here, we switch to the blocking variant of `process_groups_into_resource`. - ShinkaiFileParser::process_groups_into_resource_blocking( - text_groups, - generator, - cleaned_name, - desc, - source, - parsing_tags, - max_node_text_size, - distribution_info, - ) - } - - #[cfg(feature = "desktop-only")] - /// Processes the input file into a list of `TextGroup` with no embedding generated yet. - pub async fn process_file_into_text_groups( - file_buffer: Vec, - file_name: String, - max_node_text_size: u64, - source: VRSourceReference, - ) -> Result, VRError> { - LocalFileParser::process_file_into_grouped_text(file_buffer, file_name, max_node_text_size, source) - } - - #[cfg(feature = "desktop-only")] - /// Processes the input file into a list of `TextGroup` with no embedding generated yet. - pub fn process_file_into_text_groups_blocking( - file_buffer: Vec, - file_name: String, - max_node_text_size: u64, - source: VRSourceReference, - ) -> Result, VRError> { - LocalFileParser::process_file_into_grouped_text(file_buffer, file_name, max_node_text_size, source) - } - - #[cfg(feature = "desktop-only")] - /// Processes an ordered list of `TextGroup`s into a ready-to-go BaseVectorResource - pub async fn process_groups_into_resource( - text_groups: Vec, - generator: &dyn EmbeddingGenerator, - name: String, - desc: Option, - source: VRSourceReference, - parsing_tags: &Vec, - max_node_text_size: u64, - distribution_info: DistributionInfo, - ) -> Result { - Self::process_groups_into_resource_with_custom_collection( - text_groups, - generator, - name, - desc, - source, - parsing_tags, - max_node_text_size, - ShinkaiFileParser::collect_texts_and_indices, - distribution_info, - ) - .await - } - - #[cfg(feature = "desktop-only")] - /// Processes an ordered list of `TextGroup`s into a ready-to-go BaseVectorResource. - pub fn process_groups_into_resource_blocking( - text_groups: Vec, - generator: &dyn EmbeddingGenerator, - name: String, - desc: Option, - source: VRSourceReference, - parsing_tags: &Vec, - max_node_text_size: u64, - distribution_info: DistributionInfo, - ) -> Result { - Self::process_groups_into_resource_blocking_with_custom_collection( - text_groups, - generator, - name, - desc, - source, - parsing_tags, - max_node_text_size, - ShinkaiFileParser::collect_texts_and_indices, - distribution_info, - ) - } - - #[cfg(feature = "desktop-only")] - /// Processes an ordered list of `TextGroup`s into a ready-to-go BaseVectorResource. - /// Allows specifying a custom collection function. - pub async fn process_groups_into_resource_with_custom_collection( - text_groups: Vec, - generator: &dyn EmbeddingGenerator, - name: String, - desc: Option, - source: VRSourceReference, - parsing_tags: &Vec, - max_node_text_size: u64, - collect_texts_and_indices: fn(&[TextGroup], u64, Vec) -> (Vec, Vec<(Vec, usize)>), - distribution_info: DistributionInfo, - ) -> Result { - let new_text_groups = ShinkaiFileParser::generate_text_group_embeddings( - text_groups, - generator.box_clone(), - 31, - max_node_text_size, - collect_texts_and_indices, - ) - .await?; - - let mut resource = ShinkaiFileParser::process_new_doc_resource_with_embeddings_already_generated( - new_text_groups, - &*generator, - &name, - desc, - source, - parsing_tags, - None, - ) - .await?; - resource.as_trait_object_mut().set_distribution_info(distribution_info); - Ok(resource) - } - - #[cfg(feature = "desktop-only")] - /// Processes an ordered list of `TextGroup`s into a - /// a ready-to-go BaseVectorResource. Allows specifying a custom collection function. - pub fn process_groups_into_resource_blocking_with_custom_collection( - text_groups: Vec, - generator: &dyn EmbeddingGenerator, - name: String, - desc: Option, - source: VRSourceReference, - parsing_tags: &Vec, - max_node_text_size: u64, - collect_texts_and_indices: fn(&[TextGroup], u64, Vec) -> (Vec, Vec<(Vec, usize)>), - distribution_info: DistributionInfo, - ) -> Result { - // Group elements together before generating the doc - let cloned_generator = generator.box_clone(); - - // Use block_on to run the async-based batched embedding generation logic - let new_text_groups = ShinkaiFileParser::generate_text_group_embeddings_blocking( - &text_groups, - cloned_generator, - 31, - max_node_text_size, - collect_texts_and_indices, - )?; - - let mut resource = ShinkaiFileParser::process_new_doc_resource_blocking_with_embeddings_already_generated( - new_text_groups, - &*generator, - &name, - desc, - source, - parsing_tags, - None, - )?; - - resource.as_trait_object_mut().set_distribution_info(distribution_info); - Ok(resource) - } - - #[cfg(feature = "desktop-only")] - /// Recursively processes all text groups & their sub groups into DocumentResources. - /// This method assumes your text groups already have embeddings generated for them. - fn process_new_doc_resource_with_embeddings_already_generated<'a>( - text_groups: Vec, - generator: &'a dyn EmbeddingGenerator, - name: &'a str, - desc: Option, - source: VRSourceReference, - parsing_tags: &'a Vec, - resource_embedding: Option, - ) -> Pin> + Send + 'a>> { - Box::pin(async move { - let name = ShinkaiFileParser::clean_name(name); - let max_embedding_token_count = generator.model_type().max_input_token_count(); - let resource_desc = Self::_setup_resource_description( - desc, - &text_groups, - max_embedding_token_count, - max_embedding_token_count.checked_div(2).unwrap_or(100), - ); - let mut doc = DocumentVectorResource::new_empty(&name, resource_desc.as_deref(), source.clone(), true); - doc.set_embedding_model_used(generator.model_type()); - - // Sets the keywords - let keywords = Self::extract_keywords(&text_groups, 25); - doc.keywords_mut().set_keywords(keywords.clone()); - doc.keywords_mut().update_keywords_embedding(generator).await?; - // Sets a Resource Embedding if none provided. Primarily only used at the root level as the rest should already have them. - match resource_embedding { - Some(embedding) => doc.set_resource_embedding(embedding), - None => { - doc.update_resource_embedding(generator, None).await?; - } - } - - // Add each text group as either Vector Resource Nodes, - // or data-holding Nodes depending on if each has any sub-groups - for grouped_text in &text_groups { - let (_, metadata, has_sub_groups, new_name) = Self::process_grouped_text(grouped_text); - if has_sub_groups { - let new_doc = Self::process_new_doc_resource_with_embeddings_already_generated( - grouped_text.sub_groups.clone(), - generator, - &new_name, - None, - source.clone(), - parsing_tags, - grouped_text.embedding.clone(), - ) - .await?; - doc.append_vector_resource_node_auto(new_doc, metadata)?; - } else { - if grouped_text.text.len() <= 2 { - continue; - } - if let Some(embedding) = &grouped_text.embedding { - doc.append_text_node(&grouped_text.text, metadata, embedding.clone(), parsing_tags)?; - } else { - let embedding = generator.generate_embedding_default(&grouped_text.text).await?; - doc.append_text_node(&grouped_text.text, metadata, embedding, parsing_tags)?; - } - } - } - - Ok(BaseVectorResource::Document(doc)) - }) - } - - #[cfg(feature = "desktop-only")] - /// Recursively processes all text groups & their sub groups into DocumentResources. - /// This method assumes your text groups already have embeddings generated for them. - fn process_new_doc_resource_blocking_with_embeddings_already_generated( - text_groups: Vec, - generator: &dyn EmbeddingGenerator, - name: &str, - desc: Option, - source: VRSourceReference, - parsing_tags: &Vec, - resource_embedding: Option, - ) -> Result { - let name = ShinkaiFileParser::clean_name(name); - let max_embedding_token_count = generator.model_type().max_input_token_count(); - let resource_desc = Self::_setup_resource_description( - desc, - &text_groups, - max_embedding_token_count, - max_embedding_token_count / 2, - ); - let mut doc = DocumentVectorResource::new_empty(&name, resource_desc.as_deref(), source.clone(), true); - doc.set_embedding_model_used(generator.model_type()); - - // Sets the keywords and generates a keyword embedding - let keywords = Self::extract_keywords(&text_groups, 25); - doc.keywords_mut().set_keywords(keywords.clone()); - doc.keywords_mut().update_keywords_embedding_blocking(generator)?; - // Sets a Resource Embedding if none provided. Primarily only used at the root level as the rest should already have them. - match resource_embedding { - Some(embedding) => doc.set_resource_embedding(embedding), - None => { - doc.update_resource_embedding_blocking(generator, None)?; - } - } - - for grouped_text in &text_groups { - let (_new_resource_id, metadata, has_sub_groups, new_name) = Self::process_grouped_text(grouped_text); - if has_sub_groups { - let new_doc = Self::process_new_doc_resource_blocking_with_embeddings_already_generated( - grouped_text.sub_groups.clone(), - generator, - &new_name, - None, - source.clone(), - parsing_tags, - grouped_text.embedding.clone(), - )?; - let _ = doc.append_vector_resource_node_auto(new_doc, metadata); - } else { - if grouped_text.text.len() <= 2 { - continue; - } - if let Some(embedding) = &grouped_text.embedding { - let _ = doc.append_text_node(&grouped_text.text, metadata, embedding.clone(), parsing_tags); - } else { - let embedding = generator.generate_embedding_default_blocking(&grouped_text.text)?; - let _ = doc.append_text_node(&grouped_text.text, metadata, embedding, parsing_tags); - } - } - } - - Ok(BaseVectorResource::Document(doc)) - } -} diff --git a/shinkai-libs/shinkai-vector-resources/src/file_parser/file_parser_grouping.rs b/shinkai-libs/shinkai-vector-resources/src/file_parser/file_parser_grouping.rs deleted file mode 100644 index a7ce5547e..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/file_parser/file_parser_grouping.rs +++ /dev/null @@ -1,321 +0,0 @@ -use super::file_parser::ShinkaiFileParser; -use super::file_parser_types::TextGroup; -use crate::embedding_generator::EmbeddingGenerator; -use crate::embeddings::Embedding; -use crate::resource_errors::VRError; -use keyphrases::KeyPhraseExtractor; -use regex::Regex; -use std::collections::HashMap; -#[cfg(feature = "desktop-only")] -use std::{future::Future, pin::Pin}; - -impl ShinkaiFileParser { - /// Recursive function to collect all texts from the text groups and their subgroups - pub fn collect_texts_and_indices( - text_groups: &[TextGroup], - max_node_text_size: u64, - path: Vec, - ) -> (Vec, Vec<(Vec, usize)>) { - let mut texts = Vec::new(); - let mut indices = Vec::new(); - - for (i, text_group) in text_groups.iter().enumerate() { - texts.push(text_group.format_text_for_embedding(max_node_text_size)); - let mut current_path = path.clone(); - current_path.push(i); - indices.push((current_path.clone(), texts.len() - 1)); - - for (j, sub_group) in text_group.sub_groups.iter().enumerate() { - texts.push(sub_group.format_text_for_embedding(max_node_text_size)); - let mut sub_path = current_path.clone(); - sub_path.push(j); - indices.push((sub_path.clone(), texts.len() - 1)); - - let (sub_texts, sub_indices) = - Self::collect_texts_and_indices(&sub_group.sub_groups, max_node_text_size, sub_path); - texts.extend(sub_texts); - indices.extend(sub_indices); - } - } - - (texts, indices) - } - - /// Recursive function to assign the generated embeddings back to the text groups and their subgroups - fn assign_embeddings( - text_groups: &mut [TextGroup], - embeddings: &mut Vec, - indices: &[(Vec, usize)], - ) { - for (path, flat_index) in indices { - if let Some(embedding) = embeddings.get(*flat_index) { - let mut target = &mut text_groups[path[0]]; - for &index in &path[1..] { - target = &mut target.sub_groups[index]; - } - target.embedding = Some(embedding.clone()); - } - } - } - - #[cfg(feature = "desktop-only")] - /// Recursively goes through all of the text groups and batch generates embeddings - /// for all of them in parallel, processing up to 10 futures at a time. - pub fn generate_text_group_embeddings( - text_groups: Vec, - generator: Box, - mut max_batch_size: u64, - max_node_text_size: u64, - collect_texts_and_indices: fn(&[TextGroup], u64, Vec) -> (Vec, Vec<(Vec, usize)>), - ) -> Pin, VRError>> + Send>> { - Box::pin(async move { - // Clone the input text_groups - - let mut text_groups = text_groups; - - // Collect all texts from the text groups and their subgroups - let (texts, indices) = collect_texts_and_indices(&text_groups, max_node_text_size, vec![]); - - // Generate embeddings for all texts in batches - let ids: Vec = vec!["".to_string(); texts.len()]; - let mut all_futures = Vec::new(); - let mut current_batch_futures = Vec::new(); - - for (index, batch) in texts.chunks(max_batch_size as usize).enumerate() { - let batch_texts = batch.to_vec(); - let batch_ids = ids[..batch.len()].to_vec(); - let generator_clone = generator.box_clone(); // Clone the generator for use in the future. - - // Use the `move` keyword to take ownership of `generator_clone` inside the async block. - let future = async move { generator_clone.generate_embeddings(&batch_texts, &batch_ids).await }; - current_batch_futures.push(future); - - // If we've collected 10 futures or are at the last batch, add them to all_futures and start a new vector - if current_batch_futures.len() == 10 || index == texts.chunks(max_batch_size as usize).count() - 1 { - all_futures.push(current_batch_futures); - current_batch_futures = Vec::new(); - } - } - - // Process each group of up to 10 futures in sequence - let mut embeddings = Vec::new(); - for futures_group in all_futures { - let results = futures::future::join_all(futures_group).await; - for result in results { - match result { - Ok(batch_embeddings) => { - embeddings.extend(batch_embeddings); - } - Err(e) => { - if max_batch_size > 5 { - max_batch_size -= 5; - return Self::generate_text_group_embeddings( - text_groups, - generator, - max_batch_size, - max_node_text_size, - collect_texts_and_indices, - ) - .await; - } else { - return Err(e); - } - } - } - } - } - - // Assign the generated embeddings back to the text groups and their subgroups - Self::assign_embeddings(&mut text_groups, &mut embeddings, &indices); - - Ok(text_groups) - }) - } - - #[cfg(feature = "desktop-only")] - /// Recursively goes through all of the text groups and batch generates embeddings - /// for all of them. - pub fn generate_text_group_embeddings_blocking( - text_groups: &Vec, - generator: Box, - mut max_batch_size: u64, - max_node_text_size: u64, - collect_texts_and_indices: fn(&[TextGroup], u64, Vec) -> (Vec, Vec<(Vec, usize)>), - ) -> Result, VRError> { - // Clone the input text_groups - let mut text_groups = text_groups.clone(); - - // Collect all texts from the text groups and their subgroups - let (texts, indices) = collect_texts_and_indices(&text_groups, max_node_text_size, vec![]); - - // Generate embeddings for all texts in batches - let ids: Vec = vec!["".to_string(); texts.len()]; - let mut embeddings = Vec::new(); - for batch in texts.chunks(max_batch_size as usize) { - let batch_ids = &ids[..batch.len()]; - match generator.generate_embeddings_blocking(&batch.to_vec(), &batch_ids.to_vec()) { - Ok(batch_embeddings) => { - embeddings.extend(batch_embeddings); - } - Err(e) => { - if max_batch_size > 5 { - max_batch_size -= 5; - return Self::generate_text_group_embeddings_blocking( - &text_groups, - generator, - max_batch_size, - max_node_text_size, - collect_texts_and_indices, - ); - } else { - return Err(e); - } - } - } - } - - // Assign the generated embeddings back to the text groups and their subgroups - Self::assign_embeddings(&mut text_groups, &mut embeddings, &indices); - - Ok(text_groups) - } - - /// Helper method for processing a grouped text for process_new_doc_resource - pub fn process_grouped_text(grouped_text: &TextGroup) -> (String, Option>, bool, String) { - let has_sub_groups = !grouped_text.sub_groups.is_empty(); - let new_name = grouped_text.text.clone(); - let new_resource_id = Self::generate_data_hash(new_name.as_bytes()); - - let metadata = grouped_text.metadata.clone(); - - (new_resource_id, Some(metadata), has_sub_groups, new_name) - } - - /// Internal method used to push into correct group for hierarchical grouping - pub fn push_group_to_appropriate_parent( - group: TextGroup, - title_group: &mut Option, - groups: &mut Vec, - ) { - if group.text.len() <= 2 { - return; - } - - if let Some(title_group) = title_group.as_mut() { - title_group.push_sub_group(group); - } else { - groups.push(group); - } - } - - /// Splits a string into chunks at the nearest whitespace to a given size - pub fn split_into_chunks(text: &str, chunk_size: usize) -> Vec { - let mut chunks = Vec::new(); - let mut start = 0; - while start < text.len() { - let end = start + chunk_size; - let end = if end < text.len() { - let mut end = end; - while end > start && !text.as_bytes()[end].is_ascii_whitespace() { - end -= 1; - } - if end == start { - start + chunk_size - } else { - end - } - } else { - text.len() - }; - - let chunk = &text[start..end]; - chunks.push(chunk.to_string()); - - start = end; - } - - chunks - } - - /// Splits a string into chunks at the nearest whitespace to a given size avoiding splitting metadata - pub fn split_into_chunks_with_metadata(text: &str, chunk_size: usize) -> Vec { - // The regex matches both pure and replaceable metadata - let re = Regex::new(Self::METADATA_REGEX).unwrap(); - let matched_positions: Vec<(usize, usize)> = re.find_iter(text).map(|m| (m.start(), m.end())).collect(); - - let mut chunks = Vec::new(); - let mut start = 0; - while start < text.len() { - let end = start + chunk_size; - let end = if end < text.len() { - let mut end = end; - while end > start - && (!text.as_bytes()[end].is_ascii_whitespace() - || matched_positions - .iter() - .any(|(meta_start, meta_end)| end >= *meta_start && end < *meta_end)) - { - end -= 1; - } - if end == start { - start + chunk_size - } else { - end - } - } else { - text.len() - }; - - let chunk = &text[start..end]; - chunks.push(chunk.to_string()); - - start = end; - } - - chunks - } - - /// Extracts the most important keywords from all Groups/Sub-groups - /// using the RAKE algorithm. - pub fn extract_keywords(groups: &Vec, num: u64) -> Vec { - // Extract all the text out of all the TextGroup and its subgroups and combine them together into a single string - let text = Self::extract_all_text_from_groups(groups); - - // Create a new KeyPhraseExtractor with a maximum of num keywords - let extractor = KeyPhraseExtractor::new(&text, num as usize); - - // Get the keywords - let keywords = extractor.get_keywords(); - - // Return only the keywords, discarding the scores - keywords.into_iter().map(|(_score, keyword)| keyword).collect() - } - - /// Extracts all text from the list of groups and any sub-groups inside - fn extract_all_text_from_groups(group: &Vec) -> String { - group - .iter() - .map(|element| { - let mut text = element.text.clone(); - for sub_group in &element.sub_groups { - text.push_str(&Self::extract_all_text_from_groups(&vec![sub_group.clone()])); - } - text - }) - .collect::>() - .join(" ") - } - - /// Concatenate text up to a maximum size. - pub fn concatenate_groups_up_to_max_size(elements: &Vec, max_size: usize) -> String { - let mut desc = String::new(); - for e in elements { - if desc.len() + e.text.len() + 1 > max_size { - break; // Stop appending if adding the next element would exceed max_size - } - desc.push_str(&e.text); - desc.push('\n'); // Add a line break after each element's text - } - desc.trim_end().to_string() // Trim any trailing space before returning - } -} diff --git a/shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/csv_parsing.rs b/shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/csv_parsing.rs deleted file mode 100644 index c47829af5..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/csv_parsing.rs +++ /dev/null @@ -1,72 +0,0 @@ -use super::LocalFileParser; -use crate::{file_parser::file_parser_types::TextGroup, resource_errors::VRError}; -use csv::ReaderBuilder; -use std::io::Cursor; - -impl LocalFileParser { - /// Attempts to process the provided csv file into a list of TextGroups. - pub fn process_csv_file(file_buffer: Vec, max_node_text_size: u64) -> Result, VRError> { - let csv_lines = Self::parse_csv_auto(&file_buffer).map_err(|_| VRError::FailedCSVParsing)?; - Self::process_table_rows(csv_lines, max_node_text_size) - } - - // /// Parse CSV data from a buffer and attempt to automatically detect - // /// headers. - pub fn parse_csv_auto(buffer: &[u8]) -> Result, VRError> { - let mut reader = ReaderBuilder::new().flexible(true).from_reader(Cursor::new(buffer)); - let headers = reader - .headers() - .map_err(|_| VRError::FailedCSVParsing)? - .iter() - .map(String::from) - .collect::>(); - - let likely_header = headers.iter().all(|s| { - let is_alphabetic = s.chars().all(|c| c.is_alphabetic() || c.is_whitespace() || c == '_'); - let no_duplicates = headers.iter().filter(|&item| item == s).count() == 1; - let no_prohibited_chars = !s.contains(&['@', '#', '$', '%', '^', '&', '*']); - - is_alphabetic && no_duplicates && no_prohibited_chars - }); - - Self::parse_csv(&buffer, likely_header) - } - - // /// Parse CSV data from a buffer. - // /// * `header` - A boolean indicating whether to prepend column headers to - // /// values. - pub fn parse_csv(buffer: &[u8], header: bool) -> Result, VRError> { - let mut reader = ReaderBuilder::new() - .flexible(true) - .has_headers(header) - .from_reader(Cursor::new(buffer)); - let headers = if header { - reader - .headers() - .map_err(|_| VRError::FailedCSVParsing)? - .iter() - .map(String::from) - .collect::>() - } else { - Vec::new() - }; - - let mut result = Vec::new(); - for record in reader.records() { - let record = record.map_err(|_| VRError::FailedCSVParsing)?; - let row: Vec = if header { - record - .iter() - .enumerate() - .map(|(i, e)| format!("{}: {}", headers[i], e)) - .collect() - } else { - record.iter().map(String::from).collect() - }; - let row_string = row.join("|"); - result.push(row_string); - } - - Ok(result) - } -} diff --git a/shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/docx_parsing.rs b/shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/docx_parsing.rs deleted file mode 100644 index 9939f8242..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/docx_parsing.rs +++ /dev/null @@ -1,188 +0,0 @@ -use std::io::Cursor; - -use docx_rust::{ - document::{BodyContent, ParagraphContent, TableCellContent, TableRowContent}, - formatting::JustificationVal, - DocxFile, -}; - -use crate::{ - file_parser::{file_parser::ShinkaiFileParser, file_parser_types::TextGroup}, - resource_errors::VRError, -}; - -use super::LocalFileParser; - -impl LocalFileParser { - pub fn process_docx_file(file_buffer: Vec, max_node_text_size: u64) -> Result, VRError> { - let docx = DocxFile::from_reader(Cursor::new(file_buffer)).map_err(|_| VRError::FailedDOCXParsing)?; - let docx = docx.parse().map_err(|_| VRError::FailedDOCXParsing)?; - - let mut text_groups = Vec::new(); - let mut current_text = "".to_string(); - let mut heading_depth: usize = 0; - - docx.document.body.content.iter().for_each(|node| match node { - BodyContent::Paragraph(paragraph) => { - let text = paragraph.text(); - if text.is_empty() { - return; - } - - let style = if let Some(property) = paragraph.property.as_ref() { - let style_value = if let Some(style_id) = property.style_id.as_ref() { - style_id.value.to_string() - } else { - "".to_string() - }; - - let is_centered = if let Some(justification) = property.justification.as_ref() { - matches!(justification.value, JustificationVal::Center) - } else { - false - }; - - let is_bold = if paragraph.content.iter().any(|content| match content { - ParagraphContent::Run(run) => run.property.as_ref().map_or(false, |p| p.bold.is_some()), - _ => false, - }) { - true - } else { - // Cloning r_pr because of pyo3 build error using as_ref() - property - .r_pr - .clone() - .into_iter() - .fold(false, |acc, p| acc || p.bold.is_some()) - }; - - let has_size = if paragraph.content.iter().any(|content| match content { - ParagraphContent::Run(run) => run.property.as_ref().map_or(false, |p| p.size.is_some()), - _ => false, - }) { - true - } else { - // Cloning r_pr because of pyo3 build error using as_ref() - property - .r_pr - .clone() - .into_iter() - .fold(false, |acc, p| acc || p.size.is_some()) - }; - - if style_value == "Title" || style_value.starts_with("Heading") { - style_value - } else { - let likely_heading = is_bold && has_size; - let likely_title = likely_heading && is_centered; - - if likely_title { - "Title".to_string() - } else if likely_heading { - "Heading".to_string() - } else { - "".to_string() - } - } - } else { - "".to_string() - }; - - if style == "Title" || style.starts_with("Heading") { - ShinkaiFileParser::push_text_group_by_depth( - &mut text_groups, - heading_depth, - current_text.clone(), - max_node_text_size, - None, - ); - current_text = "".to_string(); - - if style == "Title" { - heading_depth = 0; - } else if style.starts_with("Heading") { - heading_depth = if heading_depth == 0 { 0 } else { 1 }; - } - - ShinkaiFileParser::push_text_group_by_depth( - &mut text_groups, - heading_depth, - text, - max_node_text_size, - None, - ); - heading_depth += 1; - return; - } - - let is_list_item = if let Some(property) = paragraph.property.as_ref() { - property.numbering.is_some() - } else { - false - }; - - if is_list_item { - current_text.push_str(format!("\n- {}", text).as_str()); - } else { - ShinkaiFileParser::push_text_group_by_depth( - &mut text_groups, - heading_depth, - current_text.clone(), - max_node_text_size, - None, - ); - current_text = text; - } - } - BodyContent::Table(table) => { - let mut row_text = Vec::new(); - table.rows.iter().for_each(|row| { - let mut cell_text = Vec::new(); - - row.cells.iter().for_each(|cell| match cell { - TableRowContent::TableCell(cell) => { - cell.content.iter().for_each(|content| match content { - TableCellContent::Paragraph(paragraph) => { - let text = paragraph.text(); - cell_text.push(text); - } - }); - } - _ => {} - }); - - row_text.push(cell_text.join("; ")); - }); - - ShinkaiFileParser::push_text_group_by_depth( - &mut text_groups, - heading_depth, - current_text.clone(), - max_node_text_size, - None, - ); - current_text = "".to_string(); - - let table_text = row_text.join("\n"); - ShinkaiFileParser::push_text_group_by_depth( - &mut text_groups, - heading_depth, - table_text, - max_node_text_size, - None, - ); - } - _ => {} - }); - - ShinkaiFileParser::push_text_group_by_depth( - &mut text_groups, - heading_depth, - current_text, - max_node_text_size, - None, - ); - - Ok(text_groups) - } -} diff --git a/shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/json_parsing.rs b/shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/json_parsing.rs deleted file mode 100644 index 15ef2224e..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/json_parsing.rs +++ /dev/null @@ -1,79 +0,0 @@ -use std::collections::HashMap; - -use super::LocalFileParser; -use crate::file_parser::file_parser::ShinkaiFileParser; -use crate::file_parser::file_parser_types::TextGroup; -use crate::resource_errors::VRError; -use serde_json::Value as JsonValue; - -impl LocalFileParser { - /// Attempts to process the provided json file into a list of TextGroups. - pub fn process_json_file(file_buffer: Vec, max_node_text_size: u64) -> Result, VRError> { - let json_string = String::from_utf8(file_buffer.clone()).map_err(|_| VRError::FailedJSONParsing)?; - let json: JsonValue = serde_json::from_str(&json_string)?; - - let text_groups = Self::process_container_json_value(&json, max_node_text_size); - - Ok(text_groups) - } - - /// Recursively processes a JSON value to build a hierarchy of TextGroups. - pub fn process_container_json_value(json: &JsonValue, max_node_text_size: u64) -> Vec { - let fn_merge_groups = |mut acc: Vec, current_group: TextGroup| { - if let Some(prev_group) = acc.last_mut() { - if prev_group.sub_groups.is_empty() - && current_group.sub_groups.is_empty() - && prev_group.text.len() + current_group.text.len() < max_node_text_size as usize - { - prev_group.text.push_str(format!("\n{}", current_group.text).as_str()); - return acc; - } - } - - acc.push(current_group); - acc - }; - - match json { - JsonValue::Object(map) => map - .iter() - .flat_map(|(key, value)| match value { - JsonValue::Object(_) | JsonValue::Array(_) => { - let mut text_group = TextGroup::new_empty(); - text_group.text = key.clone(); - text_group.sub_groups = Self::process_container_json_value(value, max_node_text_size); - - vec![text_group] - } - _ => Self::process_content_json_value(Some(key), value, max_node_text_size), - }) - .fold(Vec::new(), fn_merge_groups), - JsonValue::Array(arr) => arr - .iter() - .flat_map(|value| Self::process_container_json_value(value, max_node_text_size)) - .fold(Vec::new(), fn_merge_groups), - _ => Self::process_content_json_value(None, json, max_node_text_size), - } - } - - fn process_content_json_value(key: Option<&str>, value: &JsonValue, max_node_text_size: u64) -> Vec { - let mut text_groups = Vec::new(); - - let text = match key { - Some(key) => format!("{}: {}", key, value.to_string()), - None => value.to_string(), - }; - - if text.len() as u64 > max_node_text_size { - let chunks = ShinkaiFileParser::split_into_chunks(&text, max_node_text_size as usize); - - for chunk in chunks { - text_groups.push(TextGroup::new(chunk, HashMap::new(), vec![], None)); - } - } else { - text_groups.push(TextGroup::new(text, HashMap::new(), vec![], None)); - } - - text_groups - } -} diff --git a/shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/local_parsing.rs b/shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/local_parsing.rs deleted file mode 100644 index d72fb4f92..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/local_parsing.rs +++ /dev/null @@ -1,61 +0,0 @@ -use crate::file_parser::file_parser_types::TextGroup; -use crate::resource_errors::VRError; -use crate::source::VRSourceReference; -use crate::vector_resource::DocumentFileType; -use crate::vector_resource::SourceFileType; -use crate::vector_resource::SourceReference; - -pub struct LocalFileParser {} - -impl LocalFileParser { - /// Attempts to process a file into a list of TextGroups using local processing logic - /// implemented in Rust directly without relying on external services. - /// If local processing is not available for the provided source, then returns Err. - pub fn process_file_into_grouped_text( - file_buffer: Vec, - file_name: String, - max_node_text_size: u64, - source: VRSourceReference, - ) -> Result, VRError> { - let source_base = source; - - match &source_base { - VRSourceReference::None => Err(VRError::UnsupportedFileType(file_name.to_string())), - VRSourceReference::Standard(source) => match source { - SourceReference::Other(_) => Err(VRError::UnsupportedFileType(file_name.to_string())), - SourceReference::FileRef(file_source) => match file_source.clone().file_type { - SourceFileType::Image(_) - | SourceFileType::Code(_) - | SourceFileType::ConfigFileType(_) - | SourceFileType::Video(_) - | SourceFileType::Audio(_) - | SourceFileType::Shinkai(_) => Err(VRError::UnsupportedFileType(file_name.to_string())), - SourceFileType::Document(doc) => match doc { - DocumentFileType::Txt => LocalFileParser::process_txt_file(file_buffer, max_node_text_size), - DocumentFileType::Json => LocalFileParser::process_json_file(file_buffer, max_node_text_size), - DocumentFileType::Csv => LocalFileParser::process_csv_file(file_buffer, max_node_text_size), - DocumentFileType::Docx => LocalFileParser::process_docx_file(file_buffer, max_node_text_size), - DocumentFileType::Html => { - LocalFileParser::process_html_file(file_buffer, &file_name, max_node_text_size) - } - - #[cfg(feature = "desktop-only")] - DocumentFileType::Md => LocalFileParser::process_md_file(file_buffer, max_node_text_size), - - #[cfg(feature = "desktop-only")] - DocumentFileType::Pdf => LocalFileParser::process_pdf_file(file_buffer, max_node_text_size), - - #[cfg(feature = "desktop-only")] - DocumentFileType::Xlsx | DocumentFileType::Xls => { - LocalFileParser::process_xlsx_file(file_buffer, max_node_text_size) - } - - _ => Err(VRError::UnsupportedFileType(file_name.to_string())), - }, - }, - SourceReference::ExternalURI(_) => Err(VRError::UnsupportedFileType(file_name.to_string())), - }, - VRSourceReference::Notarized(_) => Err(VRError::UnsupportedFileType(file_name.to_string())), - } - } -} diff --git a/shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/xlsx_parsing.rs b/shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/xlsx_parsing.rs deleted file mode 100644 index f96db0b06..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/file_parser/local_parsing/xlsx_parsing.rs +++ /dev/null @@ -1,115 +0,0 @@ -use num_traits::cast::ToPrimitive; -use std::{collections::HashMap, io::Cursor}; - -use crate::{ - file_parser::{file_parser::ShinkaiFileParser, file_parser_types::TextGroup}, - resource_errors::VRError, -}; - -use super::LocalFileParser; - -impl LocalFileParser { - #[cfg(feature = "desktop-only")] - pub fn process_xlsx_file(file_buffer: Vec, max_node_text_size: u64) -> Result, VRError> { - let spreadsheet = umya_spreadsheet::reader::xlsx::read_reader(Cursor::new(file_buffer), true) - .map_err(|_| VRError::FailedXLSXParsing)?; - - let mut table_rows = Vec::new(); - if let Some(worksheet) = spreadsheet.get_sheet(&0) { - for row_index in 1..u32::MAX { - let row_cells = worksheet.get_collection_by_row(&row_index); - let is_empty_row = - row_cells.is_empty() || row_cells.iter().all(|cell| cell.get_cell_value().is_empty()); - - if is_empty_row { - break; - } - - let mut cell_values = Vec::new(); - let num_columns = row_cells.len(); - for col_index in 1..=num_columns { - if let Some(cell) = worksheet.get_cell((col_index.to_u32().unwrap_or_default(), row_index)) { - let cell_value = cell.get_value().to_string(); - cell_values.push(cell_value); - } - } - - let row_string = cell_values.join("|"); - - table_rows.push(row_string); - } - } - - Self::process_table_rows(table_rows, max_node_text_size) - } - - pub fn process_table_rows(table_rows: Vec, max_node_text_size: u64) -> Result, VRError> { - // Join as many rows as possible into a text group. - let mut table_rows_split = Vec::new(); - let mut current_group = Vec::new(); - let mut current_length = 0; - - for row in table_rows { - let line_length = row.len() as u64; - if current_length + line_length > max_node_text_size { - table_rows_split.push(current_group); - current_group = Vec::new(); - current_length = 0; - } - current_group.push(row); - current_length += line_length; - } - - if !current_group.is_empty() { - table_rows_split.push(current_group); - } - - let joined_lines = table_rows_split - .into_iter() - .map(|group| group.join("\n")) - .collect::>(); - - let mut text_groups = Vec::new(); - for line in joined_lines { - let (parsed_line, metadata, parsed_any_metadata) = ShinkaiFileParser::parse_and_extract_metadata(&line); - - if parsed_line.len() as u64 > max_node_text_size { - // If the line itself exceeds max_node_text_size, split it into chunks - // Split the unparsed line into chunks and parse metadata in each chunk - let chunks = if parsed_any_metadata { - ShinkaiFileParser::split_into_chunks_with_metadata(&line, max_node_text_size as usize) - } else { - ShinkaiFileParser::split_into_chunks(&line, max_node_text_size as usize) - }; - - if let Some(first_chunk) = chunks.first() { - let (parsed_chunk, metadata, _) = if parsed_any_metadata { - ShinkaiFileParser::parse_and_extract_metadata(&first_chunk) - } else { - (first_chunk.to_owned(), HashMap::new(), false) - }; - - let mut line_group = TextGroup::new(parsed_chunk, metadata, vec![], None); - - if chunks.len() > 1 { - for chunk in chunks.into_iter().skip(1) { - let (parsed_chunk, metadata, _) = if parsed_any_metadata { - ShinkaiFileParser::parse_and_extract_metadata(&chunk) - } else { - (chunk.to_owned(), HashMap::new(), false) - }; - - line_group.push_sub_group(TextGroup::new(parsed_chunk, metadata, vec![], None)); - } - } - - text_groups.push(line_group); - } - } else { - text_groups.push(TextGroup::new(parsed_line, metadata, vec![], None)); - } - } - - Ok(text_groups) - } -} diff --git a/shinkai-libs/shinkai-vector-resources/src/file_parser/mod.rs b/shinkai-libs/shinkai-vector-resources/src/file_parser/mod.rs deleted file mode 100644 index 2ef0305f8..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/file_parser/mod.rs +++ /dev/null @@ -1,5 +0,0 @@ -pub mod file_parser; -pub mod file_parser_grouping; -pub mod file_parser_helper; -pub mod file_parser_types; -pub mod local_parsing; diff --git a/shinkai-libs/shinkai-vector-resources/src/lib.rs b/shinkai-libs/shinkai-vector-resources/src/lib.rs deleted file mode 100644 index 798381b08..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/lib.rs +++ /dev/null @@ -1,11 +0,0 @@ -pub mod data_tags; -pub mod embedding_generator; -pub mod embeddings; -pub mod file_parser; -pub mod metadata_index; -pub mod model_type; -pub mod resource_errors; -pub mod shinkai_time; -pub mod source; -pub mod utils; -pub mod vector_resource; diff --git a/shinkai-libs/shinkai-vector-resources/src/metadata_index.rs b/shinkai-libs/shinkai-vector-resources/src/metadata_index.rs deleted file mode 100644 index 74ff0a539..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/metadata_index.rs +++ /dev/null @@ -1,81 +0,0 @@ -use super::vector_resource::Node; -use serde::{Deserialize, Serialize}; -use utoipa::ToSchema; -use std::collections::HashMap; - -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, ToSchema)] -pub struct MetadataIndex { - index: HashMap>, -} - -impl MetadataIndex { - /// Initializes an empty MetadataIndex - pub fn new() -> Self { - Self { index: HashMap::new() } - } - - /// Adds id of node to the index using all of the node's - /// metadata keys - pub fn add_node(&mut self, node: &Node) { - if let Some(keys) = node.metadata_keys() { - self.add_node_id_multi_keys(&node.id, &keys); - } - } - - /// Removes the node from the index - pub fn remove_node(&mut self, node: &Node) { - if let Some(keys) = node.metadata_keys() { - self.remove_node_id_multi_keys(&node.id, &keys); - } - } - - /// Deletes the old_node from the index replacing it with the new_node - pub fn replace_node(&mut self, old_node: &Node, new_node: &Node) { - self.remove_node(&old_node); - self.add_node(&new_node); - } - - /// Add a node id under several Metadata keys in the index - fn add_node_id_multi_keys(&mut self, id: &str, metadata_keys: &Vec) { - for key in metadata_keys { - self.add_node_id(id, key) - } - } - - /// Removes a node id under several Metadata keys in the index - fn remove_node_id_multi_keys(&mut self, id: &str, metadata_keys: &Vec) { - for key in metadata_keys { - self.remove_node_id(id, key) - } - } - - /// Add a node id under a Metadata key in the index - fn add_node_id(&mut self, id: &str, metadata_key: &str) { - let entry = self.index.entry(metadata_key.to_string()).or_insert_with(Vec::new); - if !entry.contains(&id.to_string()) { - entry.push(id.to_string()); - } - } - - /// Remove a node id associated with a Metadata in the index - fn remove_node_id(&mut self, id: &str, metadata_key: &str) { - if let Some(ids) = self.index.get_mut(metadata_key) { - ids.retain(|x| x != id); - } - } - - /// Get node ids associated with a specific metadata key - pub fn get_node_ids(&self, metadata_key: &str) -> Option<&Vec> { - self.index.get(metadata_key) - } - - /// Returns list of all metadata keys part of the index - pub fn get_all_metadata_keys(&self) -> Vec { - self.index.keys().cloned().collect() - } - - /// Returns a reference to the internal index Hashmap for reading - pub fn get_metdata_index_hashmap(&self) -> &HashMap> { - &self.index - } -} diff --git a/shinkai-libs/shinkai-vector-resources/src/model_type.rs b/shinkai-libs/shinkai-vector-resources/src/model_type.rs deleted file mode 100644 index 4f62b7762..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/model_type.rs +++ /dev/null @@ -1,322 +0,0 @@ -use crate::resource_errors::VRError; -// pub use llm::ModelArchitecture; -use std::fmt; -use std::hash::Hash; - -// Alias for embedding model type string -pub type EmbeddingModelTypeString = String; - -#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize, Hash)] -pub enum EmbeddingModelType { - TextEmbeddingsInference(TextEmbeddingsInference), - OpenAI(OpenAIModelType), - OllamaTextEmbeddingsInference(OllamaTextEmbeddingsInference), -} - -impl EmbeddingModelType { - /// Parses a string into an embedding model type - pub fn from_string(s: &str) -> Result { - if let Ok(model) = TextEmbeddingsInference::from_string(s) { - return Ok(EmbeddingModelType::TextEmbeddingsInference(model)); - } - if let Ok(model) = OpenAIModelType::from_string(s) { - return Ok(EmbeddingModelType::OpenAI(model)); - } - if let Ok(model) = OllamaTextEmbeddingsInference::from_string(s) { - return Ok(EmbeddingModelType::OllamaTextEmbeddingsInference(model)); - } - Err(VRError::InvalidModelArchitecture) - } - - /// Returns the maximum allowed token count for an input string to be embedded, based on the embedding model - - /// Returns the maximum allowed token count for an input string to be embedded, based on the embedding model - pub fn max_input_token_count(&self) -> usize { - static CONTEXT_512: usize = 400; - static CONTEXT_1024: usize = 9000; - static CONTEXT_8200: usize = 7800; - - match self { - EmbeddingModelType::TextEmbeddingsInference(model) => match model { - TextEmbeddingsInference::AllMiniLML6v2 => CONTEXT_512, - TextEmbeddingsInference::AllMiniLML12v2 => CONTEXT_512, - TextEmbeddingsInference::MultiQAMiniLML6 => CONTEXT_512, - TextEmbeddingsInference::BgeLargeEnv1_5 => CONTEXT_512, - TextEmbeddingsInference::BgeBaseEn1_5 => CONTEXT_512, - TextEmbeddingsInference::EmberV1 => CONTEXT_512, - TextEmbeddingsInference::GteLarge => CONTEXT_512, - TextEmbeddingsInference::GteBase => CONTEXT_512, - TextEmbeddingsInference::E5LargeV2 => CONTEXT_512, - TextEmbeddingsInference::BgeSmallEn1_5 => CONTEXT_512, - TextEmbeddingsInference::E5BaseV2 => CONTEXT_512, - TextEmbeddingsInference::MultilingualE5Large => CONTEXT_512, - TextEmbeddingsInference::NomicEmbedText1_5 => CONTEXT_8200, - TextEmbeddingsInference::Other(_) => CONTEXT_512, - }, - EmbeddingModelType::OpenAI(model) => match model { - OpenAIModelType::OpenAITextEmbeddingAda002 => CONTEXT_8200, - }, - EmbeddingModelType::OllamaTextEmbeddingsInference(model) => match model { - OllamaTextEmbeddingsInference::AllMiniLML6v2 => CONTEXT_512, - OllamaTextEmbeddingsInference::SnowflakeArcticEmbed_M => CONTEXT_512, - OllamaTextEmbeddingsInference::JinaEmbeddingsV2BaseEs => CONTEXT_1024, // it's really 8200, but we're using 1024 for now - OllamaTextEmbeddingsInference::Other(_) => CONTEXT_512, - }, - } - } - - // Returns the normalization factor for the embedding model to calibrate vector search with different embedding model types - // The reference model is snowflake-arctic-embed:xs - pub fn embedding_normalization_factor(&self) -> f32 { - match self { - EmbeddingModelType::TextEmbeddingsInference(_) => 1.0, - EmbeddingModelType::OpenAI(_) => 1.0, - EmbeddingModelType::OllamaTextEmbeddingsInference(model) => match model { - OllamaTextEmbeddingsInference::AllMiniLML6v2 => 1.0, - OllamaTextEmbeddingsInference::SnowflakeArcticEmbed_M => 1.0, - OllamaTextEmbeddingsInference::JinaEmbeddingsV2BaseEs => 1.5, - OllamaTextEmbeddingsInference::Other(_) => 1.0, - }, - } - } - - pub fn vector_dimensions(&self) -> Result { - match self { - EmbeddingModelType::TextEmbeddingsInference(model) => { - Err(VRError::UnimplementedModelDimensions(format!("TextEmbeddingsInference: {}", model))) - }, - EmbeddingModelType::OpenAI(model) => { - Err(VRError::UnimplementedModelDimensions(format!("OpenAI: {}", model))) - }, - EmbeddingModelType::OllamaTextEmbeddingsInference(model) => model.vector_dimensions(), - } - } -} - -impl fmt::Display for EmbeddingModelType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match self { - EmbeddingModelType::TextEmbeddingsInference(model) => write!(f, "{}", model), - EmbeddingModelType::OpenAI(model) => write!(f, "{}", model), - EmbeddingModelType::OllamaTextEmbeddingsInference(model) => write!(f, "{}", model), - } - } -} - -/// Hugging Face's Text Embeddings Inference -/// (https://github.com/huggingface/text-embeddings-inference) -#[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)] -pub enum TextEmbeddingsInference { - AllMiniLML6v2, - AllMiniLML12v2, - MultiQAMiniLML6, - BgeLargeEnv1_5, - BgeBaseEn1_5, - EmberV1, - GteLarge, - GteBase, - E5LargeV2, - BgeSmallEn1_5, - E5BaseV2, - MultilingualE5Large, - NomicEmbedText1_5, - Other(String), -} -impl TextEmbeddingsInference { - const ALL_MINI_LML6V2: &'static str = - "sentence-transformers/all-MiniLM-L6-v2#0b6dc4ef7c29dba0d2e99a5db0c855c3102310d8"; - const ALL_MINI_LML12V2: &'static str = - "sentence-transformers/all-MiniLM-L12-v2#a05860a77cef7b37e0048a7864658139bc18a854"; - const MULTI_QA_MINI_LML6: &'static str = - "sentence-transformers/multi-qa-MiniLM-L6-cos-v1#2430568290bb832d22ad5064f44dd86cf0240142"; - const BGE_LARGE_ENV1_5: &'static str = "BAAI/bge-large-en-v1.5#d4aa6901d3a41ba39fb536a557fa166f842b0e09"; - const BGE_BASE_EN1_5: &'static str = "BAAI/bge-base-en-v1.5#a5beb1e3e68b9ab74eb54cfd186867f64f240e1a"; - const BGE_SMALL_EN1_5: &'static str = "BAAI/bge-small-en-v1.5#5c38ec7c405ec4b44b94cc5a9bb96e735b38267a"; - const EMBER_V1: &'static str = "llmrails/ember-v1#9e76885bed0dcfa38cbf01e1e27b3a0e8d36d4e4"; - const GTE_LARGE: &'static str = "thenlper/gte-large#58578616559541da766b9b993734f63bcfcfc057"; - const GTE_BASE: &'static str = "thenlper/gte-base#5e95d41db6721e7cbd5006e99c7508f0083223d6"; - const E5_LARGE_V2: &'static str = "intfloat/e5-large-v2#b322e09026e4ea05f42beadf4d661fb4e101d311"; - const E5_BASE_V2: &'static str = "intfloat/e5-base-v2#1c644c92ad3ba1efdad3f1451a637716616a20e8"; - const MULTILINGUAL_E5_LARGE: &'static str = - "intfloat/multilingual-e5-large#ab10c1a7f42e74530fe7ae5be82e6d4f11a719eb"; - const NOMIC_EMBED_TEXT_1_5: &'static str = - "nomic-ai/nomic-embed-text-v1.5#7a5549b77c439ed64573143699547131d4218046"; - - pub const SUPPORTED_MODELS: [&'static str; 13] = [ - Self::ALL_MINI_LML6V2, - Self::ALL_MINI_LML12V2, - Self::MULTI_QA_MINI_LML6, - Self::BGE_LARGE_ENV1_5, - Self::BGE_BASE_EN1_5, - Self::BGE_SMALL_EN1_5, - Self::EMBER_V1, - Self::GTE_LARGE, - Self::GTE_BASE, - Self::E5_LARGE_V2, - Self::E5_BASE_V2, - Self::MULTILINGUAL_E5_LARGE, - Self::NOMIC_EMBED_TEXT_1_5, - ]; - - /// Parses a string in the format of "hftei/#" into a TextEmbeddingsInference - fn from_string(s: &str) -> Result { - let stripped = s.strip_prefix("hftei/").ok_or(VRError::InvalidModelArchitecture)?; - match stripped { - Self::ALL_MINI_LML6V2 => Ok(TextEmbeddingsInference::AllMiniLML6v2), - Self::ALL_MINI_LML12V2 => Ok(TextEmbeddingsInference::AllMiniLML12v2), - Self::MULTI_QA_MINI_LML6 => Ok(TextEmbeddingsInference::MultiQAMiniLML6), - Self::BGE_LARGE_ENV1_5 => Ok(TextEmbeddingsInference::BgeLargeEnv1_5), - Self::BGE_BASE_EN1_5 => Ok(TextEmbeddingsInference::BgeBaseEn1_5), - Self::BGE_SMALL_EN1_5 => Ok(TextEmbeddingsInference::BgeSmallEn1_5), - Self::EMBER_V1 => Ok(TextEmbeddingsInference::EmberV1), - Self::GTE_LARGE => Ok(TextEmbeddingsInference::GteLarge), - Self::GTE_BASE => Ok(TextEmbeddingsInference::GteBase), - Self::E5_LARGE_V2 => Ok(TextEmbeddingsInference::E5LargeV2), - Self::E5_BASE_V2 => Ok(TextEmbeddingsInference::E5BaseV2), - Self::MULTILINGUAL_E5_LARGE => Ok(TextEmbeddingsInference::MultilingualE5Large), - Self::NOMIC_EMBED_TEXT_1_5 => Ok(TextEmbeddingsInference::NomicEmbedText1_5), - _ => Ok(TextEmbeddingsInference::Other(stripped.to_string())), - } - } -} - -impl fmt::Display for TextEmbeddingsInference { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let model_str = match self { - TextEmbeddingsInference::AllMiniLML6v2 => Self::ALL_MINI_LML6V2, - TextEmbeddingsInference::AllMiniLML12v2 => Self::ALL_MINI_LML12V2, - TextEmbeddingsInference::MultiQAMiniLML6 => Self::MULTI_QA_MINI_LML6, - TextEmbeddingsInference::BgeLargeEnv1_5 => Self::BGE_LARGE_ENV1_5, - TextEmbeddingsInference::BgeBaseEn1_5 => Self::BGE_BASE_EN1_5, - TextEmbeddingsInference::BgeSmallEn1_5 => Self::BGE_SMALL_EN1_5, - TextEmbeddingsInference::EmberV1 => Self::EMBER_V1, - TextEmbeddingsInference::GteLarge => Self::GTE_LARGE, - TextEmbeddingsInference::GteBase => Self::GTE_BASE, - TextEmbeddingsInference::E5LargeV2 => Self::E5_LARGE_V2, - TextEmbeddingsInference::E5BaseV2 => Self::E5_BASE_V2, - TextEmbeddingsInference::MultilingualE5Large => Self::MULTILINGUAL_E5_LARGE, - TextEmbeddingsInference::NomicEmbedText1_5 => Self::NOMIC_EMBED_TEXT_1_5, - TextEmbeddingsInference::Other(name) => name, - }; - write!(f, "hftei/{}", model_str) - } -} - -/// OpenAIModelType -#[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)] -pub enum OpenAIModelType { - OpenAITextEmbeddingAda002, -} - -impl OpenAIModelType { - const OPENAI_TEXT_EMBEDDING_ADA_002: &'static str = "openai/text-embedding-ada-002"; - - fn from_string(s: &str) -> Result { - match s { - Self::OPENAI_TEXT_EMBEDDING_ADA_002 => Ok(OpenAIModelType::OpenAITextEmbeddingAda002), - _ => Err(VRError::InvalidModelArchitecture), - } - } -} - -impl fmt::Display for OpenAIModelType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match self { - OpenAIModelType::OpenAITextEmbeddingAda002 => write!(f, "{}", Self::OPENAI_TEXT_EMBEDDING_ADA_002), - } - } -} - -// Ollama Text Embeddings Inference -#[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)] -pub enum OllamaTextEmbeddingsInference { - AllMiniLML6v2, - #[allow(non_camel_case_types)] - SnowflakeArcticEmbed_M, - JinaEmbeddingsV2BaseEs, - Other(String), // Added variant to handle other cases -} - -impl OllamaTextEmbeddingsInference { - const ALL_MINI_LML6V2: &'static str = "all-minilm:l6-v2"; - const SNOWFLAKE_ARCTIC_EMBED_M: &'static str = "snowflake-arctic-embed:xs"; - const JINA_EMBEDDINGS_V2_BASE_ES: &'static str = "jina/jina-embeddings-v2-base-es:latest"; - - /// Parses a string into an OllamaTextEmbeddingsInference - fn from_string(s: &str) -> Result { - match s { - Self::ALL_MINI_LML6V2 => Ok(OllamaTextEmbeddingsInference::AllMiniLML6v2), - Self::SNOWFLAKE_ARCTIC_EMBED_M => Ok(OllamaTextEmbeddingsInference::SnowflakeArcticEmbed_M), - Self::JINA_EMBEDDINGS_V2_BASE_ES => Ok(OllamaTextEmbeddingsInference::JinaEmbeddingsV2BaseEs), - _ => Err(VRError::InvalidModelArchitecture), - } - } - - /// Returns the vector dimensions for the embedding model - pub fn vector_dimensions(&self) -> Result { - match self { - OllamaTextEmbeddingsInference::SnowflakeArcticEmbed_M => Ok(384), - OllamaTextEmbeddingsInference::JinaEmbeddingsV2BaseEs => Ok(768), - OllamaTextEmbeddingsInference::AllMiniLML6v2 => { - Err(VRError::UnimplementedModelDimensions(format!("{}", self))) - } - OllamaTextEmbeddingsInference::Other(model_name) => { - Err(VRError::UnimplementedModelDimensions(model_name.clone())) - } - } - } -} - -impl fmt::Display for OllamaTextEmbeddingsInference { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match self { - OllamaTextEmbeddingsInference::AllMiniLML6v2 => write!(f, "{}", Self::ALL_MINI_LML6V2), - OllamaTextEmbeddingsInference::SnowflakeArcticEmbed_M => write!(f, "{}", Self::SNOWFLAKE_ARCTIC_EMBED_M), - OllamaTextEmbeddingsInference::JinaEmbeddingsV2BaseEs => write!(f, "{}", Self::JINA_EMBEDDINGS_V2_BASE_ES), - OllamaTextEmbeddingsInference::Other(name) => write!(f, "{}", name), - } - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_parse_snowflake_arctic_embed_xs() { - let model_str = "snowflake-arctic-embed:xs"; - let parsed_model = OllamaTextEmbeddingsInference::from_string(model_str); - assert_eq!(parsed_model, Ok(OllamaTextEmbeddingsInference::SnowflakeArcticEmbed_M)); - } - - #[test] - fn test_parse_jina_embeddings_v2_base_es() { - let model_str = "jina/jina-embeddings-v2-base-es:latest"; - let parsed_model = OllamaTextEmbeddingsInference::from_string(model_str); - assert_eq!(parsed_model, Ok(OllamaTextEmbeddingsInference::JinaEmbeddingsV2BaseEs)); - } - - #[test] - fn test_parse_snowflake_arctic_embed_xs_as_embedding_model_type() { - let model_str = "snowflake-arctic-embed:xs"; - let parsed_model = EmbeddingModelType::from_string(model_str); - assert_eq!( - parsed_model, - Ok(EmbeddingModelType::OllamaTextEmbeddingsInference( - OllamaTextEmbeddingsInference::SnowflakeArcticEmbed_M - )) - ); - } - - #[test] - fn test_parse_jina_embeddings_v2_base_es_as_embedding_model_type() { - let model_str = "jina/jina-embeddings-v2-base-es:latest"; - let parsed_model = EmbeddingModelType::from_string(model_str); - assert_eq!( - parsed_model, - Ok(EmbeddingModelType::OllamaTextEmbeddingsInference( - OllamaTextEmbeddingsInference::JinaEmbeddingsV2BaseEs - )) - ); - } -} diff --git a/shinkai-libs/shinkai-vector-resources/src/resource_errors.rs b/shinkai-libs/shinkai-vector-resources/src/resource_errors.rs deleted file mode 100644 index 947c291a0..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/resource_errors.rs +++ /dev/null @@ -1,133 +0,0 @@ -use crate::vector_resource::VRPath; - -use serde_json::Error as SerdeError; -use std::error::Error; -use std::fmt; - -#[derive(Debug, PartialEq)] -pub enum VRError { - InvalidNodeId(String), - VectorResourceEmpty, - FailedEmbeddingGeneration(String), - NoNodeFound, - InvalidModelArchitecture, - FailedJSONParsing, - FailedCSVParsing, - FailedDOCXParsing, - FailedPDFParsing, - FailedMDParsing, - FailedTXTParsing, - FailedXLSXParsing, - InvalidVRBaseType, - RegexError(regex::Error), - RequestFailed(String), - NoEmbeddingProvided, - ContentIsNonMatchingType, - InvalidVRPath(VRPath), - FailedParsingUnstructedAPIJSON(String), - FileTypeNotSupported(String), - InvalidReferenceString(String), - InvalidDateTimeString(String), - LockAcquisitionFailed(String), - MissingKey(String), - InvalidPathString(String), - ResourceDoesNotSupportOrderedOperations(String), - InvalidNodeType(String), - InvalidMerkleHashString(String), - MerkleRootNotFound(String), - MerkleHashNotFoundInNode(String), - VectorResourceIsNotMerkelized(String), - VRKaiParsingError(String), - VRPackParsingError(String), - UnsupportedVRKaiVersion(String), - UnsupportedVRPackVersion(String), - InvalidSimplifiedFSEntryType(String), - VRPackEmbeddingModelError(String), - UnsupportedFileType(String), - UnimplementedModelDimensions(String), -} - -impl fmt::Display for VRError { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match *self { - VRError::InvalidNodeId(ref s) => write!(f, "Invalid node id: {}", s), - VRError::VectorResourceEmpty => write!(f, "VectorResource is empty"), - VRError::FailedEmbeddingGeneration(ref s) => write!(f, "Failed to generate embeddings: {}", s), - VRError::NoNodeFound => write!(f, "No matching node found"), - VRError::InvalidModelArchitecture => { - write!(f, "An unsupported model architecture was specified.") - } - VRError::FailedJSONParsing => write!(f, "Failed JSON parsing."), - VRError::FailedCSVParsing => write!(f, "Failed CSV parsing."), - VRError::FailedDOCXParsing => write!(f, "Failed DOCX parsing."), - VRError::FailedPDFParsing => write!(f, "Failed PDF parsing."), - VRError::FailedMDParsing => write!(f, "Failed MD parsing."), - VRError::FailedTXTParsing => write!(f, "Failed TXT parsing."), - VRError::FailedXLSXParsing => write!(f, "Failed XLSX parsing."), - VRError::NoEmbeddingProvided => write!(f, "No embedding provided."), - VRError::InvalidVRBaseType => { - write!(f, "The resource type does not match any of the VRBaseTypes.") - } - VRError::RegexError(ref e) => write!(f, "Regex error: {}", e), - VRError::RequestFailed(ref e) => write!(f, "HTTP request failed: {}", e), - VRError::ContentIsNonMatchingType => { - write!(f, "Content inside of the Node is of a different type than requested.") - } - VRError::InvalidVRPath(ref p) => write!(f, "Vector Resource Path is invalid: {}", p), - VRError::FailedParsingUnstructedAPIJSON(ref s) => { - write!(f, "Failed to parse Unstructed API response json: {}", s) - } - VRError::FileTypeNotSupported(ref s) => { - write!(f, "File type not supported: {}", s) - } - VRError::InvalidReferenceString(ref s) => { - write!(f, "Vector Resource reference string is invalid: {}", s) - } - VRError::InvalidDateTimeString(ref s) => { - write!(f, "Provided datetime string does not match RFC3339: {}", s) - } - VRError::LockAcquisitionFailed(ref s) => write!(f, "Failed to acquire lock for: {}", s), - VRError::MissingKey(ref s) => write!(f, "Missing key not found in hashmap: {}", s), - VRError::InvalidPathString(ref s) => write!(f, "String is not formatted as a proper path string: {}", s), - VRError::ResourceDoesNotSupportOrderedOperations(ref s) => write!(f, "Attempted to perform ordered operations on a resource that does not implement OrderedVectorResource: {}", s), - VRError::InvalidNodeType(ref s) => write!(f, "Unexpected/unsupported NodeContent type for Node with id: {}", s), - VRError::InvalidMerkleHashString(ref s) => write!(f, "The provided merkle hash String is not a validly encoded Blake3 hash: {}", s), - VRError::MerkleRootNotFound(ref s) => write!(f, "The Vector Resource does not contain a merkle root: {}", s), - VRError::MerkleHashNotFoundInNode(ref s) => write!(f, "The Node does not contain a merkle root: {}", s), - VRError::VectorResourceIsNotMerkelized(ref s) => write!(f, "The Vector Resource is not merkelized, and thus cannot perform merkel-related functionality: {}", s), - VRError::VRKaiParsingError(ref s) => write!(f, "Failed to parse contents into VRKai struct: {}", s), - VRError::VRPackParsingError(ref s) => write!(f, "Failed to parse contents into VRKai struct: {}", s), - VRError::UnsupportedVRKaiVersion(ref s) => write!(f, "Unsupported VRKai version: {}", s), - VRError::UnsupportedVRPackVersion(ref s) => write!(f, "Unsupported VRPack version: {}", s), - VRError::InvalidSimplifiedFSEntryType(ref s) => write!(f, "Failed to convert SimplifiedFSEntry at path: {}", s), - VRError::VRPackEmbeddingModelError(ref s) => write!(f, "Embedding Model Error: {}", s), - VRError::UnsupportedFileType(ref s) => write!(f, "Unsupported file type: {}", s), - VRError::UnimplementedModelDimensions(ref s) => write!(f, "Model dimensions are not implemented: {}", s), - } - } -} - -impl Error for VRError {} - -impl From for VRError { - fn from(err: regex::Error) -> VRError { - VRError::RegexError(err) - } -} - -impl From for VRError { - fn from(error: SerdeError) -> Self { - match error.classify() { - serde_json::error::Category::Io => VRError::FailedJSONParsing, - serde_json::error::Category::Syntax => VRError::FailedJSONParsing, - serde_json::error::Category::Data => VRError::FailedJSONParsing, - serde_json::error::Category::Eof => VRError::FailedJSONParsing, - } - } -} - -impl From for VRError { - fn from(error: reqwest::Error) -> Self { - VRError::RequestFailed(error.to_string()) - } -} diff --git a/shinkai-libs/shinkai-vector-resources/src/source/distribution.rs b/shinkai-libs/shinkai-vector-resources/src/source/distribution.rs deleted file mode 100644 index a9f1ee9c7..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/source/distribution.rs +++ /dev/null @@ -1,83 +0,0 @@ -use crate::vector_resource::VRPath; -use chrono::{DateTime, Utc}; -use utoipa::ToSchema; - -pub type ShinkaiNameString = String; - -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, ToSchema)] -/// Info about where the source data was acquired from, and when it was originally distributed -pub struct DistributionInfo { - pub origin: Option, - #[schema(value_type = String, format = Date)] - pub datetime: Option>, -} - -impl DistributionInfo { - /// Creates a new instance of DistributionInfo with specified origin and datetime - pub fn new(origin: Option, datetime: Option>) -> Self { - Self { origin, datetime } - } - - /// Creates a new instance of DistributionInfo with auto-detecting origin based on file name - pub fn new_auto(file_name: &str, datetime: Option>) -> Self { - let origin = DistributionOrigin::new_auto(file_name); - - Self { origin, datetime } - } - - /// Creates a new, empty instance of DistributionInfo with no origin and no datetime - pub fn new_empty() -> Self { - Self { - origin: None, - datetime: None, - } - } -} - -/// The origin where the original data was acquired from. -/// Based on source file that was used to create the VR if one exists (ie. pdf/webpage), or based on the VR where/when it was released -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, ToSchema)] -pub enum DistributionOrigin { - Uri(String), - #[schema(value_type = (String, VRPath))] - ShinkaiNode((ShinkaiNameString, VRPath)), - Other(String), -} - -impl DistributionOrigin { - /// Creates a new instance with auto-detecting origin based on input name/source string - pub fn new_auto(input: &str) -> Option { - if input.starts_with("http://") - || input.starts_with("https://") - || input.starts_with("ipfs://") - || input.starts_with("ar://") - { - Some(DistributionOrigin::Uri(input.to_string())) - } else if input.starts_with("@@") { - let parts: Vec<&str> = input.splitn(2, '/').collect(); - if parts.len() == 2 { - let name_string = parts[0].to_string(); - let vr_path_part = parts[1]; - if let Some(vr_path_index) = vr_path_part.find("/vec_fs") { - let vr_path = vr_path_part[vr_path_index..].to_string(); - if let Ok(path) = VRPath::from_string(&vr_path) { - return Some(DistributionOrigin::ShinkaiNode((name_string, path))); - } - } - } - None - } else { - None - } - } - - // Converts the DistributionOrigin to a JSON string - pub fn to_json(&self) -> Result { - serde_json::to_string(self) - } - - // Creates a DistributionOrigin from a JSON string - pub fn from_json(json: &str) -> Result { - serde_json::from_str(json) - } -} diff --git a/shinkai-libs/shinkai-vector-resources/src/source/mod.rs b/shinkai-libs/shinkai-vector-resources/src/source/mod.rs deleted file mode 100644 index ab123ad0e..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/source/mod.rs +++ /dev/null @@ -1,9 +0,0 @@ -pub mod distribution; -pub mod notary_source; -pub mod source; -pub mod source_file_map; - -pub use distribution::*; -pub use notary_source::*; -pub use source::*; -pub use source_file_map::*; diff --git a/shinkai-libs/shinkai-vector-resources/src/source/notary_source.rs b/shinkai-libs/shinkai-vector-resources/src/source/notary_source.rs deleted file mode 100644 index 95e331ecd..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/source/notary_source.rs +++ /dev/null @@ -1,111 +0,0 @@ -use super::DistributionInfo; - -use crate::resource_errors::VRError; -use crate::source::TextChunkingStrategy; -use crate::vector_resource::SourceFileType; - -use serde::{Deserialize, Serialize}; -use std::fmt; -use utoipa::ToSchema; - -/// Struct which holds the contents of the TLSNotary proof for the source file -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] -pub struct TLSNotaryProof {} - -impl TLSNotaryProof { - pub fn new() -> Self { - TLSNotaryProof {} - } -} - -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] -/// The source file that data was extracted from to create a VectorResource -pub struct TLSNotarizedSourceFile { - pub file_name: String, - pub file_type: SourceFileType, - pub file_content: Vec, - pub distribution_info: Option, - pub proof: TLSNotaryProof, -} - -impl TLSNotarizedSourceFile { - /// Returns the size of the file content in bytes - pub fn size(&self) -> usize { - self.file_content.len() - } - - /// Creates a new instance of SourceFile struct - pub fn new( - file_name: String, - file_type: SourceFileType, - file_content: Vec, - distribution_info: Option, - proof: TLSNotaryProof, - ) -> Self { - Self { - file_name, - file_type, - file_content, - distribution_info, - proof, - } - } - - pub fn format_source_string(&self) -> String { - format!("{}.{}", self.file_name, self.file_type) - } - - /// Serializes the SourceFile to a JSON string - pub fn to_json(&self) -> Result { - Ok(serde_json::to_string(self)?) - } - - /// Deserializes a SourceFile from a JSON string - pub fn from_json(json: &str) -> Result { - Ok(serde_json::from_str(json)?) - } -} - -/// Type that acts as a reference to a notarized source file -/// (meaning one that has some cryptographic proof/signature of origin) -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] -pub enum NotarizedSourceReference { - /// Reference to TLSNotary notarized web content - TLSNotarized(TLSNotarizedReference), -} - -impl NotarizedSourceReference { - pub fn format_source_string(&self) -> String { - match self { - NotarizedSourceReference::TLSNotarized(reference) => reference.format_source_string(), - } - } -} - -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] -pub struct TLSNotarizedReference { - pub file_name: String, - pub file_type: SourceFileType, - pub text_chunking_strategy: TextChunkingStrategy, -} - -impl TLSNotarizedReference { - pub fn format_source_string(&self) -> String { - format!("{}.{}", self.file_name, self.file_type()) - } - - pub fn file_type(&self) -> SourceFileType { - self.file_type.clone() - } -} - -impl fmt::Display for TLSNotarizedReference { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!( - f, - "TLS Notarized File Name: {}, File Type: {}", - self.file_name, - self.file_type() - ) - } -} diff --git a/shinkai-libs/shinkai-vector-resources/src/source/source.rs b/shinkai-libs/shinkai-vector-resources/src/source/source.rs deleted file mode 100644 index 980b1ddc1..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/source/source.rs +++ /dev/null @@ -1,897 +0,0 @@ -use super::DistributionInfo; - -use crate::resource_errors::VRError; -use crate::source::notary_source::{NotarizedSourceReference, TLSNotarizedSourceFile, TLSNotaryProof}; - -use regex::Regex; - -use serde::{Deserialize, Serialize}; -use std::fmt; -use std::path::Path; -use std::str::FromStr; -use utoipa::ToSchema; - -/// What text chunking strategy was used to create this VR from the source file. -/// This is required for performing content validation/that it matches the VR nodes. -/// TODO: Think about how to make this more explicit/specific and future support -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] -pub enum TextChunkingStrategy { - /// The default text chunking strategy implemented in VR lib using local parsing. - V1, -} - -/// Information about the source content a Vector Resource came from -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] -pub enum VRSourceReference { - Standard(SourceReference), - Notarized(NotarizedSourceReference), - None, -} - -impl VRSourceReference { - /// Formats a printable string based on the source - pub fn format_source_string(&self) -> String { - match self { - VRSourceReference::Standard(reference) => reference.format_source_string(), - VRSourceReference::Notarized(notarized_reference) => notarized_reference.format_source_string(), - VRSourceReference::None => String::from("None"), - } - } - - /// Creates a VRSourceReference from an external URI or URL - pub fn new_uri_ref(uri: &str) -> Self { - Self::Standard(SourceReference::new_external_uri(uri.to_string())) - } - - /// Creates a VRSourceReference reference to an original source file - pub fn new_source_file_ref( - file_name: String, - file_type: SourceFileType, - text_chunking_strategy: TextChunkingStrategy, - ) -> Self { - VRSourceReference::Standard(SourceReference::FileRef(SourceFileReference { - file_name, - file_type, - text_chunking_strategy, - })) - } - - /// Creates a VRSourceReference reference using an arbitrary String - pub fn new_other_ref(other: &str) -> Self { - Self::Standard(SourceReference::new_other(other.to_string())) - } - - /// Creates a VRSourceReference which represents no/unknown source. - pub fn none() -> Self { - VRSourceReference::None - } - - /// Serializes the VRSourceReference to a JSON string - pub fn to_json(&self) -> Result { - Ok(serde_json::to_string(self)?) - } - - /// Deserializes a VRSourceReference from a JSON string - pub fn from_json(json: &str) -> Result { - Ok(serde_json::from_str(json)?) - } - - /// Creates a VRSourceReference using file_name/content to auto-detect and create an instance of Self. - /// Errors if can not detect matching extension in file_name. - pub fn from_file(file_name: &str, text_chunking_strategy: TextChunkingStrategy) -> Result { - let file_name_without_extension = SourceFileType::clean_string_of_extension(file_name); - // Attempt to auto-detect, else use file extension - let file_type = SourceFileType::detect_file_type(file_name)?; - let file_name_without_extension = file_name_without_extension.trim_start_matches("file://"); - Ok(VRSourceReference::new_source_file_ref( - file_name_without_extension.to_string(), - file_type, - text_chunking_strategy, - )) - } - - /// Checks if the VRSourceReference is of type Standard - pub fn is_standard(&self) -> bool { - matches!(self, VRSourceReference::Standard(_)) - } - - /// Checks if the VRSourceReference is of type Notarized - pub fn is_notarized(&self) -> bool { - matches!(self, VRSourceReference::Notarized(_)) - } - - /// Checks if the VRSourceReference is of type None - pub fn is_none(&self) -> bool { - matches!(self, VRSourceReference::None) - } -} - -/// Struct which holds the data of a source file which a VR was generated from -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] -pub enum SourceFile { - Standard(StandardSourceFile), - TLSNotarized(TLSNotarizedSourceFile), -} - -impl SourceFile { - pub fn new_standard_source_file( - file_name: String, - file_type: SourceFileType, - file_content: Vec, - distribution_info: Option, - ) -> Self { - Self::Standard(StandardSourceFile { - file_name, - file_type, - file_content, - distribution_info, - }) - } - - pub fn new_tls_notarized_source_file( - file_name: String, - file_type: SourceFileType, - file_content: Vec, - distribution_info: Option, - proof: TLSNotaryProof, - ) -> Self { - Self::TLSNotarized(TLSNotarizedSourceFile { - file_name, - file_type, - file_content, - distribution_info, - proof, - }) - } - - /// Serializes the SourceFile to a JSON string - pub fn to_json(&self) -> Result { - serde_json::to_string(self) - } - - /// Deserializes a SourceFile from a JSON string - pub fn from_json(json: &str) -> Result { - serde_json::from_str(json) - } -} - -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] -/// A standard source file that data was extracted from to create a VectorResource. -pub struct StandardSourceFile { - pub file_name: String, - pub file_type: SourceFileType, - pub file_content: Vec, - // Creation/publication time of the original content which is inside this struct - pub distribution_info: Option, -} - -impl StandardSourceFile { - /// Returns the size of the file content in bytes - pub fn size(&self) -> usize { - self.file_content.len() - } - - /// Creates a new instance of SourceFile struct - pub fn new( - file_name: String, - file_type: SourceFileType, - file_content: Vec, - distribution_info: Option, - ) -> Self { - Self { - file_name, - file_type, - file_content, - distribution_info, - } - } - - pub fn format_source_string(&self) -> String { - format!("{}.{}", self.file_name, self.file_type) - } - - /// Serializes the SourceFile to a JSON string - pub fn to_json(&self) -> Result { - Ok(serde_json::to_string(self)?) - } - - /// Deserializes a SourceFile from a JSON string - pub fn from_json(json: &str) -> Result { - Ok(serde_json::from_str(json)?) - } -} - -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] -/// Type that acts as a reference to external file/content/data -pub enum SourceReference { - /// A typed specific file - FileRef(SourceFileReference), - /// An arbitrary external URI - ExternalURI(ExternalURIReference), - Other(String), -} - -/// Struct that represents an external URI like a website URL which -/// has not been downloaded into a SourceFile, but is just referenced. -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] -pub struct ExternalURIReference { - pub uri: String, -} - -impl SourceReference { - pub fn format_source_string(&self) -> String { - match self { - SourceReference::FileRef(reference) => reference.format_source_string(), - SourceReference::ExternalURI(uri) => uri.uri.clone(), - SourceReference::Other(s) => s.clone(), - } - } - - /// Creates a new SourceReference for a file, auto-detecting the file type - /// by attempting to parse the extension in the file_name. - /// Errors if extension is not found or not implemented yet. - pub fn new_file_reference_auto_detect( - file_name: String, - text_chunking_strategy: TextChunkingStrategy, - ) -> Result { - let file_type = SourceFileType::detect_file_type(&file_name)?; - Ok(SourceReference::FileRef(SourceFileReference { - file_name, - file_type, - text_chunking_strategy, - })) - } - - /// Creates a new SourceReference for an image file - pub fn new_file_image_reference( - file_name: String, - image_type: ImageFileType, - text_chunking_strategy: TextChunkingStrategy, - ) -> Self { - SourceReference::FileRef(SourceFileReference { - file_name, - file_type: SourceFileType::Image(image_type), - text_chunking_strategy, - }) - } - - /// Creates a new SourceReference for a document file - pub fn new_file_doc_reference( - file_name: String, - doc_type: DocumentFileType, - text_chunking_strategy: TextChunkingStrategy, - ) -> Self { - SourceReference::FileRef(SourceFileReference { - file_name, - file_type: SourceFileType::Document(doc_type), - text_chunking_strategy, - }) - } - - /// Creates a new SourceReference for a code file - pub fn new_file_code_reference( - file_name: String, - code_type: CodeFileType, - text_chunking_strategy: TextChunkingStrategy, - ) -> Self { - SourceReference::FileRef(SourceFileReference { - file_name, - file_type: SourceFileType::Code(code_type), - text_chunking_strategy, - }) - } - - /// Creates a new SourceReference for a config file - pub fn new_file_config_reference( - file_name: String, - config_type: ConfigFileType, - text_chunking_strategy: TextChunkingStrategy, - ) -> Self { - SourceReference::FileRef(SourceFileReference { - file_name, - file_type: SourceFileType::ConfigFileType(config_type), - text_chunking_strategy, - }) - } - - /// Creates a new SourceReference for a video file - pub fn new_file_video_reference( - file_name: String, - video_type: VideoFileType, - text_chunking_strategy: TextChunkingStrategy, - ) -> Self { - SourceReference::FileRef(SourceFileReference { - file_name, - file_type: SourceFileType::Video(video_type), - text_chunking_strategy, - }) - } - - /// Creates a new SourceReference for an audio file - pub fn new_file_audio_reference( - file_name: String, - audio_type: AudioFileType, - text_chunking_strategy: TextChunkingStrategy, - ) -> Self { - SourceReference::FileRef(SourceFileReference { - file_name, - file_type: SourceFileType::Audio(audio_type), - text_chunking_strategy, - }) - } - - /// Creates a new SourceReference for a Shinkai file - pub fn new_file_shinkai_reference( - file_name: String, - shinkai_type: ShinkaiFileType, - text_chunking_strategy: TextChunkingStrategy, - ) -> Self { - SourceReference::FileRef(SourceFileReference { - file_name, - file_type: SourceFileType::Shinkai(shinkai_type), - text_chunking_strategy, - }) - } - - /// Creates a new SourceReference for an external URI - pub fn new_external_uri(uri: String) -> Self { - SourceReference::ExternalURI(ExternalURIReference { uri }) - } - - /// Creates a new SourceReference for custom use cases - pub fn new_other(s: String) -> Self { - SourceReference::Other(s) - } -} - -impl fmt::Display for SourceReference { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match self { - SourceReference::FileRef(reference) => write!(f, "{}", reference), - SourceReference::ExternalURI(uri) => write!(f, "{}", uri.uri), - SourceReference::Other(s) => write!(f, "{}", s), - } - } -} - -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] -pub struct SourceFileReference { - pub file_name: String, - pub file_type: SourceFileType, - pub text_chunking_strategy: TextChunkingStrategy, -} - -impl SourceFileReference { - pub fn format_source_string(&self) -> String { - format!("{}.{}", self.file_name, self.file_type) - } -} - -impl fmt::Display for SourceFileReference { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "File Name: {}, File Type: {}", self.file_name, self.file_type) - } -} - -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] -pub enum SourceFileType { - Document(DocumentFileType), - Image(ImageFileType), - Code(CodeFileType), - ConfigFileType(ConfigFileType), - Video(VideoFileType), - Audio(AudioFileType), - Shinkai(ShinkaiFileType), -} - -impl SourceFileType { - /// Given an input file_name with an extension, outputs the correct SourceFileType - /// or an error if the extension cannot be found or is not supported yet - pub fn detect_file_type(file_name: &str) -> Result { - let path = Path::new(file_name); - let extension = path - .extension() - .and_then(|ext| ext.to_str()) - .ok_or_else(|| VRError::FileTypeNotSupported(file_name.to_string()))?; - - let ext = extension; - { - if let Ok(doc_type) = DocumentFileType::from_str(ext) { - return Ok(SourceFileType::Document(doc_type)); - } - if let Ok(code_type) = CodeFileType::from_str(ext) { - return Ok(SourceFileType::Code(code_type)); - } - // Config support will be added once we implement parsers for them all - if let Ok(_config_type) = ConfigFileType::from_str(ext) { - // return Ok(SourceFileType::ConfigFileType(config_type)); - return Err(VRError::FileTypeNotSupported(file_name.to_string())); - } - if let Ok(shinkai_type) = ShinkaiFileType::from_str(ext) { - return Ok(SourceFileType::Shinkai(shinkai_type)); - } - // Video/audio/image support will come in the future by first converting to text. - if let Ok(_video_type) = VideoFileType::from_str(ext) { - // return Ok(SourceFileType::Video(video_type)); - return Err(VRError::FileTypeNotSupported(file_name.to_string())); - } - if let Ok(_audio_type) = AudioFileType::from_str(ext) { - // return Ok(SourceFileType::Audio(audio_type)); - return Err(VRError::FileTypeNotSupported(file_name.to_string())); - } - if let Ok(_img_type) = ImageFileType::from_str(ext) { - // return Ok(SourceFileType::Image(img_type)); - return Err(VRError::FileTypeNotSupported(file_name.to_string())); - } - } - - Err(VRError::FileTypeNotSupported(file_name.to_string())) - } - - /// Clones and cleans the input string of its file extension at the end, if it exists. - pub fn clean_string_of_extension(file_name: &str) -> String { - // If the file extension is not detected/supported, return the original file_name - if SourceFileType::detect_file_type(file_name).is_err() { - file_name.to_string() - } else { - let re = Regex::new(r"\.[^.]+$").unwrap(); - let file_name_without_extension = re.replace(file_name, "").to_string(); - - // Check if the result is empty, return the original file_name if so as a backup - if file_name_without_extension.is_empty() { - file_name.to_string() - } else { - file_name_without_extension - } - } - } -} - -impl fmt::Display for SourceFileType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match self { - SourceFileType::Document(doc_type) => write!(f, "{}", doc_type), - SourceFileType::Image(img_type) => write!(f, "{}", img_type), - SourceFileType::Code(code_type) => write!(f, "{}", code_type), - SourceFileType::ConfigFileType(config_type) => write!(f, "{}", config_type), - SourceFileType::Video(video_type) => write!(f, "{}", video_type), - SourceFileType::Audio(audio_type) => write!(f, "{}", audio_type), - SourceFileType::Shinkai(shinkai_type) => write!(f, "{}", shinkai_type), - } - } -} - -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] -pub enum ImageFileType { - Png, - Jpeg, - Gif, - Bmp, - Tiff, - Svg, - Webp, - Ico, - Heic, - Raw, - Other(String), -} - -impl fmt::Display for ImageFileType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!( - f, - "{}", - match self { - ImageFileType::Png => "png", - ImageFileType::Jpeg => "jpeg", - ImageFileType::Gif => "gif", - ImageFileType::Bmp => "bmp", - ImageFileType::Tiff => "tiff", - ImageFileType::Svg => "svg", - ImageFileType::Webp => "webp", - ImageFileType::Ico => "ico", - ImageFileType::Heic => "heic", - ImageFileType::Raw => "raw", - ImageFileType::Other(s) => s.as_str(), - } - ) - } -} - -impl FromStr for ImageFileType { - type Err = (); - - fn from_str(s: &str) -> Result { - match s { - "png" => Ok(ImageFileType::Png), - "jpeg" => Ok(ImageFileType::Jpeg), - "gif" => Ok(ImageFileType::Gif), - "bmp" => Ok(ImageFileType::Bmp), - "tiff" => Ok(ImageFileType::Tiff), - "svg" => Ok(ImageFileType::Svg), - "webp" => Ok(ImageFileType::Webp), - "ico" => Ok(ImageFileType::Ico), - "heic" => Ok(ImageFileType::Heic), - "raw" => Ok(ImageFileType::Raw), - _ => Err(()), - } - } -} - -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] -pub enum DocumentFileType { - Pdf, - Md, - Txt, - Epub, - Doc, - Docx, - Rtf, - Odt, - Html, - Csv, - Xls, - Xlsx, - Ppt, - Pptx, - Xml, - Json, - Ps, - Tex, - Latex, - Ods, - Odp, - Other(String), -} - -impl fmt::Display for DocumentFileType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!( - f, - "{}", - match self { - DocumentFileType::Pdf => "pdf", - DocumentFileType::Md => "md", - DocumentFileType::Txt => "txt", - DocumentFileType::Epub => "epub", - DocumentFileType::Doc => "doc", - DocumentFileType::Docx => "docx", - DocumentFileType::Rtf => "rtf", - DocumentFileType::Odt => "odt", - DocumentFileType::Html => "html", - DocumentFileType::Csv => "csv", - DocumentFileType::Xls => "xls", - DocumentFileType::Xlsx => "xlsx", - DocumentFileType::Ppt => "ppt", - DocumentFileType::Pptx => "pptx", - DocumentFileType::Xml => "xml", - DocumentFileType::Json => "json", - DocumentFileType::Ps => "ps", - DocumentFileType::Tex => "tex", - DocumentFileType::Latex => "latex", - DocumentFileType::Ods => "ods", - DocumentFileType::Odp => "odp", - DocumentFileType::Other(s) => s.as_str(), - } - ) - } -} - -impl FromStr for DocumentFileType { - type Err = (); - - fn from_str(s: &str) -> Result { - match s { - "pdf" => Ok(DocumentFileType::Pdf), - "md" => Ok(DocumentFileType::Md), - "txt" => Ok(DocumentFileType::Txt), - "epub" => Ok(DocumentFileType::Epub), - "doc" => Ok(DocumentFileType::Doc), - "docx" => Ok(DocumentFileType::Docx), - "rtf" => Ok(DocumentFileType::Rtf), - "odt" => Ok(DocumentFileType::Odt), - "html" => Ok(DocumentFileType::Html), - "csv" => Ok(DocumentFileType::Csv), - "xls" => Ok(DocumentFileType::Xls), - "xlsx" => Ok(DocumentFileType::Xlsx), - "ppt" => Ok(DocumentFileType::Ppt), - "pptx" => Ok(DocumentFileType::Pptx), - "xml" => Ok(DocumentFileType::Xml), - "json" => Ok(DocumentFileType::Json), - "ps" => Ok(DocumentFileType::Ps), - "tex" => Ok(DocumentFileType::Tex), - "latex" => Ok(DocumentFileType::Latex), - "ods" => Ok(DocumentFileType::Ods), - "odp" => Ok(DocumentFileType::Odp), - _ => Err(()), - } - } -} - -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] -pub enum CodeFileType { - Python, - Java, - JavaScript, - TypeScript, - C, - Cpp, - CppHeader, - CSharp, - Go, - Rust, - Swift, - Kotlin, - Php, - Ruby, - Other(String), -} - -impl fmt::Display for CodeFileType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!( - f, - "{}", - match self { - CodeFileType::Python => "py", - CodeFileType::Java => "java", - CodeFileType::JavaScript => "js", - CodeFileType::TypeScript => "ts", - CodeFileType::C => "c", - CodeFileType::Cpp => "cpp", - CodeFileType::CppHeader => "h", - CodeFileType::CSharp => "cs", - CodeFileType::Go => "go", - CodeFileType::Rust => "rs", - CodeFileType::Swift => "swift", - CodeFileType::Kotlin => "kt", - CodeFileType::Php => "php", - CodeFileType::Ruby => "rb", - CodeFileType::Other(s) => s.as_str(), - } - ) - } -} - -impl FromStr for CodeFileType { - type Err = (); - - fn from_str(s: &str) -> Result { - match s { - "py" => Ok(CodeFileType::Python), - "java" => Ok(CodeFileType::Java), - "js" => Ok(CodeFileType::JavaScript), - "ts" => Ok(CodeFileType::TypeScript), - "c" => Ok(CodeFileType::C), - "cpp" => Ok(CodeFileType::Cpp), - "h" => Ok(CodeFileType::CppHeader), - "cs" => Ok(CodeFileType::CSharp), - "go" => Ok(CodeFileType::Go), - "rs" => Ok(CodeFileType::Rust), - "swift" => Ok(CodeFileType::Swift), - "kt" => Ok(CodeFileType::Kotlin), - "php" => Ok(CodeFileType::Php), - "rb" => Ok(CodeFileType::Ruby), - _ => Err(()), - } - } -} - -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] -pub enum ConfigFileType { - Toml, - Ini, - Yaml, - Eslint, - Prettier, - Webpack, - Dockerfile, - Gitignore, - Other(String), -} - -impl fmt::Display for ConfigFileType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!( - f, - "{}", - match self { - ConfigFileType::Toml => "toml", - ConfigFileType::Ini => "ini", - ConfigFileType::Eslint => ".eslintrc", - ConfigFileType::Yaml => "yaml", - ConfigFileType::Prettier => ".prettierrc", - ConfigFileType::Webpack => "webpack.config.js", - ConfigFileType::Dockerfile => "Dockerfile", - ConfigFileType::Gitignore => ".gitignore", - ConfigFileType::Other(s) => s.as_str(), - } - ) - } -} - -impl FromStr for ConfigFileType { - type Err = (); - - fn from_str(s: &str) -> Result { - match s { - "yaml" => Ok(ConfigFileType::Yaml), - "toml" => Ok(ConfigFileType::Toml), - "ini" => Ok(ConfigFileType::Ini), - ".eslintrc" => Ok(ConfigFileType::Eslint), - ".prettierrc" => Ok(ConfigFileType::Prettier), - "webpack.config.js" => Ok(ConfigFileType::Webpack), - "Dockerfile" => Ok(ConfigFileType::Dockerfile), - ".gitignore" => Ok(ConfigFileType::Gitignore), - _ => Err(()), - } - } -} - -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] -pub enum AudioFileType { - Mp3, - Wav, - Ogg, - Flac, - Aac, - Wma, - Alac, - Ape, - Dsf, - M4a, - Opus, - Ra, - Au, - Aiff, - Other(String), -} - -impl fmt::Display for AudioFileType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!( - f, - "{}", - match self { - AudioFileType::Mp3 => "mp3", - AudioFileType::Wav => "wav", - AudioFileType::Ogg => "ogg", - AudioFileType::Flac => "flac", - AudioFileType::Aac => "aac", - AudioFileType::Wma => "wma", - AudioFileType::Alac => "alac", - AudioFileType::Ape => "ape", - AudioFileType::Dsf => "dsf", - AudioFileType::M4a => "m4a", - AudioFileType::Opus => "opus", - AudioFileType::Ra => "ra", - AudioFileType::Au => "au", - AudioFileType::Aiff => "aiff", - AudioFileType::Other(s) => s.as_str(), - } - ) - } -} - -impl FromStr for AudioFileType { - type Err = (); - - fn from_str(s: &str) -> Result { - match s { - "mp3" => Ok(AudioFileType::Mp3), - "wav" => Ok(AudioFileType::Wav), - "ogg" => Ok(AudioFileType::Ogg), - "flac" => Ok(AudioFileType::Flac), - "aac" => Ok(AudioFileType::Aac), - "wma" => Ok(AudioFileType::Wma), - "alac" => Ok(AudioFileType::Alac), - "ape" => Ok(AudioFileType::Ape), - "dsf" => Ok(AudioFileType::Dsf), - "m4a" => Ok(AudioFileType::M4a), - "opus" => Ok(AudioFileType::Opus), - "ra" => Ok(AudioFileType::Ra), - "au" => Ok(AudioFileType::Au), - "aiff" => Ok(AudioFileType::Aiff), - _ => Err(()), - } - } -} - -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] -pub enum VideoFileType { - Mp4, - Mkv, - Avi, - Flv, - Mov, - Wmv, - Mpeg, - Webm, - Ogv, - Vob, - M4v, - Mpg, - Other(String), -} - -impl fmt::Display for VideoFileType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!( - f, - "{}", - match self { - VideoFileType::Mp4 => "mp4", - VideoFileType::Mkv => "mkv", - VideoFileType::Avi => "avi", - VideoFileType::Flv => "flv", - VideoFileType::Mov => "mov", - VideoFileType::Wmv => "wmv", - VideoFileType::Mpeg => "mpeg", - VideoFileType::Webm => "webm", - VideoFileType::Ogv => "ogv", - VideoFileType::Vob => "vob", - VideoFileType::M4v => "m4v", - VideoFileType::Mpg => "mpg", - VideoFileType::Other(s) => s.as_str(), - } - ) - } -} - -impl FromStr for VideoFileType { - type Err = (); - - fn from_str(s: &str) -> Result { - match s { - "mp4" => Ok(VideoFileType::Mp4), - "mkv" => Ok(VideoFileType::Mkv), - "avi" => Ok(VideoFileType::Avi), - "flv" => Ok(VideoFileType::Flv), - "mov" => Ok(VideoFileType::Mov), - "wmv" => Ok(VideoFileType::Wmv), - "mpeg" => Ok(VideoFileType::Mpeg), - "webm" => Ok(VideoFileType::Webm), - "ogv" => Ok(VideoFileType::Ogv), - "vob" => Ok(VideoFileType::Vob), - "m4v" => Ok(VideoFileType::M4v), - "mpg" => Ok(VideoFileType::Mpg), - _ => Err(()), - } - } -} - -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] -pub enum ShinkaiFileType { - ShinkaiJobKai, - ShinkaiVRKai, - ShinkaiVRPack, - Other(String), -} - -impl fmt::Display for ShinkaiFileType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!( - f, - "{}", - match self { - ShinkaiFileType::ShinkaiJobKai => "jobkai", - ShinkaiFileType::ShinkaiVRKai => "vrkai", - ShinkaiFileType::ShinkaiVRPack => "vrpack", - ShinkaiFileType::Other(s) => s.as_str(), - } - ) - } -} - -impl FromStr for ShinkaiFileType { - type Err = (); - - fn from_str(s: &str) -> Result { - match s { - "jobkai" => Ok(ShinkaiFileType::ShinkaiJobKai), - "vrkai" => Ok(ShinkaiFileType::ShinkaiVRKai), - "vrpack" => Ok(ShinkaiFileType::ShinkaiVRPack), - _ => Err(()), - } - } -} diff --git a/shinkai-libs/shinkai-vector-resources/src/source/source_file_map.rs b/shinkai-libs/shinkai-vector-resources/src/source/source_file_map.rs deleted file mode 100644 index 159b72239..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/source/source_file_map.rs +++ /dev/null @@ -1,64 +0,0 @@ -use super::SourceFile; -use crate::{resource_errors::VRError, vector_resource::VRPath}; -use serde::{Deserialize, Serialize}; -use std::collections::HashMap; -use utoipa::ToSchema; - -/// A map which stores SourceFiles based on VRPaths within a VectorResource. -/// A SourceFile at root represents the single source file for the whole VR. -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] -pub struct SourceFileMap { - pub map: HashMap, - pub source_files_count: u64, -} - -impl SourceFileMap { - /// Creates a new SourceFileMap using the given HashMap and automatically counts the number of entries. - pub fn new(map: HashMap) -> Self { - let source_files_count = map.len() as u64; - SourceFileMap { - map, - source_files_count, - } - } - - /// Returns the size of the whole SourceFileMap after being encoded as JSON. - pub fn encoded_size(&self) -> Result { - let json = self.to_json()?; - Ok(json.as_bytes().len()) - } - - /// Checks if the map contains only a single root SourceFile. - pub fn contains_only_single_root_sourcefile(&self) -> bool { - self.source_files_count == 1 && self.map.contains_key(&VRPath::root()) - } - - /// Returns the source file at the given VRPath if it exists. - pub fn get_source_file(&self, vr_path: VRPath) -> Option<&SourceFile> { - self.map.get(&vr_path) - } - - /// Adds a source file to the map and increases the count. - /// Overwrites any existing SourceFile which already is stored at the same VRPath. - pub fn add_source_file(&mut self, path: VRPath, source_file: SourceFile) { - self.map.insert(path, source_file); - self.source_files_count += 1; - } - - /// Removes a source file from the map and decreases the count. - pub fn remove_source_file(&mut self, path: VRPath) -> Option { - let res = self.map.remove(&path); - self.source_files_count -= 1; - res - } - - /// Converts the SourceFileMap into a JSON string. - pub fn to_json(&self) -> Result { - serde_json::to_string(&self) - } - - /// Creates a SourceFileMap from a JSON string. - pub fn from_json(json: &str) -> Result { - serde_json::from_str(json) - } -} diff --git a/shinkai-libs/shinkai-vector-resources/src/utils.rs b/shinkai-libs/shinkai-vector-resources/src/utils.rs deleted file mode 100644 index 069a6dca9..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/utils.rs +++ /dev/null @@ -1,65 +0,0 @@ -use blake3::Hasher; -use rand::RngCore; - -/// Hashes a String using Blake3, returning the hash as an output String -pub fn hash_string(input: &str) -> String { - let mut hasher = blake3::Hasher::new(); - hasher.update(input.as_bytes()); - let result = hasher.finalize(); - hex::encode(result.as_bytes()) -} - -/// Generates a random hex String -pub fn random_string() -> String { - let mut key = [0u8; 32]; - rand::rngs::OsRng.fill_bytes(&mut key); - - let mut hasher = Hasher::new(); - hasher.update(&key); - let hash = hasher.finalize(); - - hex::encode(hash.as_bytes()) -} - -/// Counts the number of tokens from a single message string for llama3 model, -/// where every three normal letters (a-zA-Z) allow an empty space to not be counted, -/// and other symbols are counted as 1 token. -/// This implementation avoids floating point arithmetic by scaling counts. -pub fn count_tokens_from_message_llama3(message: &str) -> u64 { - let mut token_count = 0; - let mut alphabetic_count = 0; // Total count of alphabetic characters - let mut space_count = 0; // Total count of spaces - // ^ need to fix this - - // First pass: count alphabetic characters and spaces - for c in message.chars() { - if c.is_ascii_alphabetic() { - alphabetic_count += 1; - } else if c.is_whitespace() { - space_count += 1; - } - } - - // Calculate how many spaces can be ignored - let spaces_to_ignore = alphabetic_count / 3; - - // Determine the alphabetic token weight based on the number of alphabetic characters - let alphabetic_token_weight = if alphabetic_count > 500 { 8 } else { 10 }; - - // Second pass: count tokens, adjusting for spaces that can be ignored - for c in message.chars() { - if c.is_ascii_alphabetic() { - token_count += alphabetic_token_weight; // Counting as 1/3, so add 1 to the scaled count - } else if c.is_whitespace() { - if spaces_to_ignore > 0 { - space_count -= 10; // Reduce the count of spaces to ignore by the scaling factor - } else { - token_count += 30; // Count the space as a full token if not enough alphabetic characters - } - } else { - token_count += 30; // Non-alphabetic characters count as a full token, add 3 to the scaled count - } - } - - (token_count / 30) + 1 // Divide the scaled count by 30 and floor the result, add 1 to account for any remainder -} diff --git a/shinkai-libs/shinkai-vector-resources/src/vector_resource/base_vector_resources.rs b/shinkai-libs/shinkai-vector-resources/src/vector_resource/base_vector_resources.rs deleted file mode 100644 index 48251dacd..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/vector_resource/base_vector_resources.rs +++ /dev/null @@ -1,182 +0,0 @@ -use super::vector_resource::VectorResource; -use super::{DocumentVectorResource, MapVectorResource, VRKai}; -use crate::resource_errors::VRError; -use crate::vector_resource::OrderedVectorResource; -use serde_json::Value as JsonValue; -use std::str::FromStr; -use utoipa::ToSchema; - -/// The list of base/core VectorResource types which are fully -/// composable within one another -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, ToSchema)] -pub enum BaseVectorResource { - Document(DocumentVectorResource), - Map(MapVectorResource), -} - -impl BaseVectorResource { - /// Converts into a Box<&dyn VectorResource>. - /// Used to access all of the VectorResource trait's methods, ie. - /// self.as_trait_object().vector_search(...); - /// Note this is not a mutable reference, so do not use mutating methods. - pub fn as_trait_object(&self) -> Box<&dyn VectorResource> { - match self { - BaseVectorResource::Document(resource) => Box::new(resource), - BaseVectorResource::Map(resource) => Box::new(resource), - } - } - - /// Converts into a Box<&mut dyn VectorResource>, which provides ability - /// to mutate the BaseVectorResource using the VectorResource trait's methods. - pub fn as_trait_object_mut(&mut self) -> Box<&mut dyn VectorResource> { - match self { - BaseVectorResource::Document(resource) => Box::new(resource), - BaseVectorResource::Map(resource) => Box::new(resource), - } - } - - //// Attempts to cast into a OrderedVectorResource. Fails if - /// the Resource does not support the OrderedVectorResource trait. - pub fn as_ordered_vector_resource(&self) -> Result<&dyn OrderedVectorResource, VRError> { - self.as_trait_object().as_ordered_vector_resource() - } - - //// Attempts to cast into a OrderedVectorResource. Fails if - /// the Resource does not support the OrderedVectorResource trait. - pub fn as_ordered_vector_resource_mut(&mut self) -> Result<&mut dyn OrderedVectorResource, VRError> { - self.as_trait_object_mut().as_ordered_vector_resource_mut() - } - - /// Converts the BaseVectorResource into a VRKai instance using the previously defined new method. - pub fn to_vrkai(self) -> VRKai { - VRKai::new(self, None) - } - - /// Converts the BaseVectorResource into a JSON string (without the enum wrapping JSON) - pub fn to_json(&self) -> Result { - self.as_trait_object().to_json() - } - - /// Converts the BaseVectorResource into a JSON Value (without the enum wrapping JSON) - pub fn to_json_value(&self) -> Result { - self.as_trait_object().to_json_value() - } - - /// Creates a BaseVectorResource from a JSON string - pub fn from_json(json: &str) -> Result { - let value: JsonValue = serde_json::from_str(json)?; - - match value.get("resource_base_type") { - Some(serde_json::Value::String(resource_type)) => match VRBaseType::from_str(resource_type) { - Ok(VRBaseType::Document) => { - let document_resource = DocumentVectorResource::from_json(json)?; - Ok(BaseVectorResource::Document(document_resource)) - } - Ok(VRBaseType::Map) => { - let map_resource = MapVectorResource::from_json(json)?; - Ok(BaseVectorResource::Map(map_resource)) - } - _ => Err(VRError::InvalidVRBaseType), - }, - _ => Err(VRError::InvalidVRBaseType), - } - } - - /// Attempts to convert the BaseVectorResource into a DocumentVectorResource - pub fn as_document_resource(&mut self) -> Result<&mut DocumentVectorResource, VRError> { - match self { - BaseVectorResource::Document(resource) => Ok(resource), - _ => Err(VRError::InvalidVRBaseType), - } - } - - /// Attempts to convert the BaseVectorResource into a MapVectorResource - pub fn as_map_resource(&mut self) -> Result<&mut MapVectorResource, VRError> { - match self { - BaseVectorResource::Map(resource) => Ok(resource), - _ => Err(VRError::InvalidVRBaseType), - } - } - - /// Attempts to convert the BaseVectorResource into a DocumentVectorResource - pub fn as_document_resource_cloned(&self) -> Result { - match self { - BaseVectorResource::Document(resource) => Ok(resource.clone()), - _ => Err(VRError::InvalidVRBaseType), - } - } - - /// Attempts to convert the BaseVectorResource into a MapVectorResource - pub fn as_map_resource_cloned(&self) -> Result { - match self { - BaseVectorResource::Map(resource) => Ok(resource.clone()), - _ => Err(VRError::InvalidVRBaseType), - } - } - - /// Returns the base type of the VectorResource - pub fn resource_base_type(&self) -> VRBaseType { - self.as_trait_object().resource_base_type() - } - - pub fn resource_contents_by_hierarchy_to_string(&self) -> String { - self.as_trait_object() - .retrieve_all_nodes_contents_by_hierarchy(None, false, false, false) - .join("\n") - } -} - -impl From for BaseVectorResource { - fn from(resource: DocumentVectorResource) -> Self { - BaseVectorResource::Document(resource) - } -} - -impl From for BaseVectorResource { - fn from(resource: MapVectorResource) -> Self { - BaseVectorResource::Map(resource) - } -} - -/// Enum used for VectorResources to self-attest their base type. -/// -/// `CustomUnsupported(s)` allows for devs to implement custom VectorResources that fulfill the trait, -/// but which aren't composable with any of the base resources (we are open to PRs for adding new base types as well). -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, ToSchema)] -pub enum VRBaseType { - Document, - Map, - CustomUnsupported(String), -} - -impl VRBaseType { - pub fn to_str(&self) -> &str { - match self { - VRBaseType::Document => "Document", - VRBaseType::Map => "Map", - VRBaseType::CustomUnsupported(s) => s, - } - } - - /// Check if the given resource type is one of the supported types. - /// Does this by using to/from_str to reuse the `match`es and keep code cleaner. - pub fn is_base_vector_resource(resource_base_type: VRBaseType) -> Result<(), VRError> { - let resource_type_str = resource_base_type.to_str(); - match Self::from_str(resource_type_str) { - Ok(_) => Ok(()), - Err(_) => Err(VRError::InvalidVRBaseType), - } - } -} - -impl FromStr for VRBaseType { - type Err = VRError; - - fn from_str(s: &str) -> Result { - match s { - "Document" => Ok(VRBaseType::Document), - "Map" => Ok(VRBaseType::Map), - _ => Err(VRError::InvalidVRBaseType), - } - } -} diff --git a/shinkai-libs/shinkai-vector-resources/src/vector_resource/document_resource.rs b/shinkai-libs/shinkai-vector-resources/src/vector_resource/document_resource.rs deleted file mode 100644 index e2b5635c2..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/vector_resource/document_resource.rs +++ /dev/null @@ -1,872 +0,0 @@ -use super::{BaseVectorResource, VRBaseType, VRHeader, VRKeywords, VectorResourceSearch}; -use crate::data_tags::{DataTag, DataTagIndex}; -use crate::embeddings::Embedding; -use crate::metadata_index::MetadataIndex; -use crate::model_type::{EmbeddingModelType, EmbeddingModelTypeString, OllamaTextEmbeddingsInference}; -use crate::resource_errors::VRError; -use crate::shinkai_time::ShinkaiTime; -use crate::source::{DistributionInfo, SourceReference, VRSourceReference}; -use crate::vector_resource::{Node, NodeContent, OrderedVectorResource, VRPath, VectorResource, VectorResourceCore}; - -use chrono::{DateTime, Utc}; -use serde_json; -use std::any::Any; -use std::collections::HashMap; -use utoipa::ToSchema; - -/// A VectorResource which uses an internal numbered/ordered list data model, -/// thus providing an ideal interface for document-like content such as PDFs, -/// epubs, web content, written works, and more. -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, ToSchema)] -pub struct DocumentVectorResource { - pub name: String, - pub description: Option, - pub source: VRSourceReference, - pub resource_id: String, - pub resource_embedding: Embedding, - #[schema(value_type = String)] - pub embedding_model_used_string: EmbeddingModelTypeString, - pub resource_base_type: VRBaseType, - pub embeddings: Vec, - pub node_count: u64, - pub nodes: Vec, - pub data_tag_index: DataTagIndex, - #[schema(value_type = String, format = Date)] - pub created_datetime: DateTime, - #[schema(value_type = String, format = Date)] - pub last_written_datetime: DateTime, - pub metadata_index: MetadataIndex, - pub merkle_root: Option, - pub keywords: VRKeywords, - pub distribution_info: DistributionInfo, -} -impl VectorResource for DocumentVectorResource {} -impl VectorResourceSearch for DocumentVectorResource {} - -impl OrderedVectorResource for DocumentVectorResource { - /// Id of the first node held internally - fn first_node_id(&self) -> Option { - if self.node_count > 0 { - Some("1".to_string()) - } else { - None - } - } - - /// Id of the last node held internally - fn last_node_id(&self) -> Option { - if self.node_count > 0 { - Some(self.node_count.to_string()) - } else { - None - } - } - - /// Retrieve the first node held internally - fn get_first_node(&self) -> Option { - self.nodes.first().cloned() - } - - /// Retrieve the second node held internally - fn get_second_node(&self) -> Option { - if self.nodes.len() >= 2 { - Some(self.nodes[1].clone()) - } else { - None - } - } - - /// Retrieve the third node held internally - fn get_third_node(&self) -> Option { - if self.nodes.len() >= 3 { - Some(self.nodes[2].clone()) - } else { - None - } - } - - /// Retrieve the last node held internally - fn get_last_node(&self) -> Option { - self.nodes.last().cloned() - } - - /// Id to be used when pushing a new node - fn new_push_node_id(&self) -> String { - (self.node_count + 1).to_string() - } - - /// Takes the first N nodes held internally and returns them as references - fn take(&self, n: usize) -> Vec<&Node> { - self.nodes.iter().take(n).collect() - } - - /// Takes the first N nodes held internally and returns cloned copies of them - fn take_cloned(&self, n: usize) -> Vec { - self.nodes.iter().take(n).cloned().collect() - } - - /// Attempts to fetch a node (using the provided id) and proximity_window before/after, at root depth. - /// Returns the nodes in its default ordering as determined by the internal VR struct. - fn get_node_and_embedding_proximity( - &self, - id: String, - proximity_window: u64, - ) -> Result, VRError> { - let id = id.parse::().map_err(|_| VRError::InvalidNodeId(id.to_string()))?; - - // Check if id is within valid range - if id == 0 || id > self.node_count { - return Err(VRError::InvalidNodeId(id.to_string())); - } - - // Calculate Start/End ids - let start_id = if id > proximity_window { - id - proximity_window - } else { - 1 - }; - let end_id = if let Some(potential_end_id) = id.checked_add(proximity_window) { - potential_end_id.min(self.node_count) - } else { - self.node_count - }; - - // Acquire all nodes - let mut nodes_and_embeddings = Vec::new(); - for id in start_id..=end_id { - if let Ok(node) = self.get_root_node(id.to_string()) { - if let Ok(embedding) = self.get_root_embedding(id.to_string()) { - nodes_and_embeddings.push((node, embedding)); - } - } - } - - Ok(nodes_and_embeddings) - } -} - -impl VectorResourceCore for DocumentVectorResource { - fn as_any(&self) -> &dyn Any { - self - } - - fn as_any_mut(&mut self) -> &mut dyn Any { - self - } - - /// Attempts to cast the VectorResource into an OrderedVectorResource. Fails if - /// the struct does not support the OrderedVectorResource trait. - fn as_ordered_vector_resource(&self) -> Result<&dyn OrderedVectorResource, VRError> { - Ok(self as &dyn OrderedVectorResource) - } - - /// Attempts to cast the VectorResource into an mut OrderedVectorResource. Fails if - /// the struct does not support the OrderedVectorResource trait. - fn as_ordered_vector_resource_mut(&mut self) -> Result<&mut dyn OrderedVectorResource, VRError> { - Ok(self as &mut dyn OrderedVectorResource) - } - - /// Returns the merkle root of the Vector Resource (if it is not None). - fn get_merkle_root(&self) -> Result { - self.merkle_root - .clone() - .ok_or(VRError::MerkleRootNotFound(self.reference_string())) - } - - /// Sets the merkle root of the Vector Resource, errors if provided hash is not a valid Blake3 hash. - fn set_merkle_root(&mut self, merkle_hash: String) -> Result<(), VRError> { - // Validate the hash format - if blake3::Hash::from_hex(&merkle_hash).is_ok() { - self.merkle_root = Some(merkle_hash); - Ok(()) - } else { - Err(VRError::InvalidMerkleHashString(merkle_hash)) - } - } - - /// RFC3339 Datetime when then Vector Resource was created - fn created_datetime(&self) -> DateTime { - self.created_datetime.clone() - } - /// RFC3339 Datetime when then Vector Resource was last written - fn last_written_datetime(&self) -> DateTime { - self.last_written_datetime.clone() - } - /// Set a RFC Datetime of when then Vector Resource was last written - fn set_last_written_datetime(&mut self, datetime: DateTime) { - self.last_written_datetime = datetime; - } - - fn data_tag_index(&self) -> &DataTagIndex { - &self.data_tag_index - } - - fn metadata_index(&self) -> &MetadataIndex { - &self.metadata_index - } - - fn distribution_info(&self) -> &DistributionInfo { - &self.distribution_info - } - - fn set_distribution_info(&mut self, dist_info: DistributionInfo) { - self.distribution_info = dist_info; - } - - fn embedding_model_used_string(&self) -> EmbeddingModelTypeString { - self.embedding_model_used_string.clone() - } - - fn name(&self) -> &str { - &self.name - } - - fn description(&self) -> Option<&str> { - self.description.as_deref() - } - - fn source(&self) -> VRSourceReference { - self.source.clone() - } - - fn keywords(&self) -> &VRKeywords { - &self.keywords - } - - fn keywords_mut(&mut self) -> &mut VRKeywords { - &mut self.keywords - } - - fn set_name(&mut self, new_name: String) { - self.name = new_name; - } - - fn set_description(&mut self, new_description: Option) { - self.description = new_description; - } - - fn set_source(&mut self, new_source: VRSourceReference) { - self.source = new_source; - } - - fn resource_id(&self) -> &str { - &self.resource_id - } - - fn resource_embedding(&self) -> &Embedding { - &self.resource_embedding - } - - fn resource_base_type(&self) -> VRBaseType { - self.resource_base_type.clone() - } - - fn get_root_embeddings(&self) -> Vec { - self.embeddings.clone() - } - - fn to_json(&self) -> Result { - Ok(serde_json::to_string(self)?) - } - - fn to_json_value(&self) -> Result { - Ok(serde_json::to_value(self)?) - } - - fn set_embedding_model_used(&mut self, model_type: EmbeddingModelType) { - self.update_last_written_to_now(); - self.embedding_model_used_string = model_type.to_string(); - } - - fn set_resource_embedding(&mut self, embedding: Embedding) { - self.update_last_written_to_now(); - self.resource_embedding = embedding; - } - - fn node_count(&self) -> u64 { - self.node_count - } - - fn set_resource_id(&mut self, id: String) { - self.update_last_written_to_now(); - self.resource_id = id; - } - - fn get_data_tag_index(&self) -> &DataTagIndex { - &self.data_tag_index - } - - fn set_data_tag_index(&mut self, data_tag_index: DataTagIndex) { - self.data_tag_index = data_tag_index; - } - - fn get_metadata_index(&self) -> &MetadataIndex { - &self.metadata_index - } - - fn set_metadata_index(&mut self, metadata_index: MetadataIndex) { - self.metadata_index = metadata_index; - } - - /// Efficiently retrieves a Node's matching embedding given its id by fetching it via index. - fn get_root_embedding(&self, id: String) -> Result { - let id = id.parse::().map_err(|_| VRError::InvalidNodeId(id.to_string()))?; - if id == 0 || id > self.node_count { - return Err(VRError::InvalidNodeId(id.to_string())); - } - let index = id.checked_sub(1).ok_or(VRError::InvalidNodeId(id.to_string()))? as usize; - Ok(self.embeddings[index].clone()) - } - - /// Efficiently retrieves a node given its id by fetching it via index. - fn get_root_node(&self, id: String) -> Result { - let id = id.parse::().map_err(|_| VRError::InvalidNodeId(id.to_string()))?; - if id == 0 || id > self.node_count { - return Err(VRError::InvalidNodeId(id.to_string())); - } - let index = id.checked_sub(1).ok_or(VRError::InvalidNodeId(id.to_string()))? as usize; - self.nodes - .get(index) - .cloned() - .ok_or(VRError::InvalidNodeId(id.to_string())) - } - - /// Returns all nodes in the DocumentVectorResource - fn get_root_nodes(&self) -> Vec { - self.nodes.iter().cloned().collect() - } - - /// Returns all nodes in the DocumentVectorResource as references to nodes - fn get_root_nodes_ref(&self) -> Vec<&Node> { - self.nodes.iter().collect() - } - - /// Returns all embeddings in the DocumentVectorResource as references to embeddings - fn get_root_embeddings_ref(&self) -> Vec<&Embedding> { - self.embeddings.iter().collect() - } - - /// Insert a Node/Embedding into the VR using the provided id (root level depth). Overwrites existing data. - fn insert_node_dt_specified( - &mut self, - id: String, - node: Node, - embedding: Embedding, - new_written_datetime: Option>, - update_merkle_hashes: bool, - ) -> Result<(), VRError> { - let current_datetime = if let Some(dt) = new_written_datetime { - dt - } else { - ShinkaiTime::generate_time_now() - }; - - // Id + index logic - let mut integer_id = id.parse::().map_err(|_| VRError::InvalidNodeId(id.to_string()))?; - integer_id = if integer_id == 0 { 1 } else { integer_id }; - if integer_id > self.node_count + 1 { - // We do +1 since we resize the vectors explicitly in this method - return Err(VRError::InvalidNodeId(id.to_string())); - } - let index = if integer_id == 0 { 0 } else { (integer_id - 1) as usize }; - - // Resize the vectors to accommodate the new node and embedding - let node_default = self - .nodes - .last() - .cloned() - .unwrap_or_else(|| Node::new_text("".to_string(), "".to_string(), None, &vec![])); - let embedding_default = self.embeddings.last().cloned().unwrap_or_else(Embedding::new_empty); - self.nodes - .resize_with((self.node_count + 1) as usize, || node_default.clone()); - self.embeddings - .resize_with((self.node_count + 1) as usize, || embedding_default.clone()); - - // Shift all nodes and embeddings one index up - for i in (index..self.node_count as usize).rev() { - self.nodes[i + 1] = self.nodes[i].clone(); - self.embeddings[i + 1] = self.embeddings[i].clone(); - self.nodes[i + 1].id = format!("{}", i + 2); - self.embeddings[i + 1].set_id_with_integer((i + 2) as u64); - } - - // Update ids to match supplied id - let mut updated_node = node; - updated_node.id = id.to_string(); - updated_node.set_last_written(current_datetime); - let mut embedding = embedding.clone(); - embedding.set_id(id.to_string()); - // Update the node merkle hash if the VR is merkelized. This guarantees merkle hash is always up to date. - if self.is_merkelized() && update_merkle_hashes { - updated_node.update_merkle_hash()?; - } - - // Insert the new node and embedding - self.nodes[index] = updated_node.clone(); - self.embeddings[index] = embedding; - - self.data_tag_index.add_node(&updated_node); - self.metadata_index.add_node(&updated_node); - - self.node_count += 1; - self.set_last_written_datetime(current_datetime); - - // Regenerate the Vector Resource's merkle root after updating its contents - if self.is_merkelized() && update_merkle_hashes { - self.update_merkle_root()?; - } - - Ok(()) - } - - /// Replace a Node/Embedding in the VR using the provided id (root level depth) - fn replace_node_dt_specified( - &mut self, - id: String, - node: Node, - embedding: Embedding, - new_written_datetime: Option>, - update_merkle_hashes: bool, - ) -> Result<(Node, Embedding), VRError> { - let current_datetime = if let Some(dt) = new_written_datetime { - dt - } else { - ShinkaiTime::generate_time_now() - }; - - // Id + index logic - let mut integer_id = id.parse::().map_err(|_| VRError::InvalidNodeId(id.to_string()))?; - integer_id = if integer_id == 0 { 1 } else { integer_id }; - if integer_id > self.node_count { - return Err(VRError::InvalidNodeId(id.to_string())); - } - let index = if integer_id == 0 { 0 } else { (integer_id - 1) as usize }; - - // Update ids to match supplied id - let mut new_node = node; - new_node.id = id.to_string(); - let mut embedding = embedding.clone(); - embedding.set_id(id.to_string()); - new_node.set_last_written(current_datetime); - // Update the node merkle hash if the VR is merkelized. This guarantees merkle hash is always up to date. - if self.is_merkelized() && update_merkle_hashes { - new_node.update_merkle_hash()?; - } - - // Replace the old node and fetch old embedding - let old_node = std::mem::replace(&mut self.nodes[index], new_node.clone()); - let old_embedding = self.get_root_embedding(id.clone())?; - - // Replacing the embedding - self.embeddings[index] = embedding; - self.set_last_written_datetime(current_datetime); - - // Then deletion of old node from indexes and addition of new node - if old_node.data_tag_names != new_node.data_tag_names { - self.data_tag_index.remove_node(&old_node); - self.data_tag_index.add_node(&new_node); - } - if old_node.metadata_keys() != new_node.metadata_keys() { - self.metadata_index.remove_node(&old_node); - self.metadata_index.add_node(&new_node); - } - - // Regenerate the Vector Resource's merkle root after updating its contents - if self.is_merkelized() && update_merkle_hashes { - self.update_merkle_root()?; - } - - Ok((old_node, old_embedding)) - } - - /// Remove a Node/Embedding in the VR using the provided id (root level depth) - fn remove_node_dt_specified( - &mut self, - id: String, - new_written_datetime: Option>, - update_merkle_hashes: bool, - ) -> Result<(Node, Embedding), VRError> { - let current_datetime = if let Some(dt) = new_written_datetime { - dt - } else { - ShinkaiTime::generate_time_now() - }; - // Id + index logic - let mut integer_id = id.parse::().map_err(|_| VRError::InvalidNodeId(id.to_string()))?; - integer_id = if integer_id == 0 { 1 } else { integer_id }; - if integer_id > self.node_count { - return Err(VRError::InvalidNodeId(id.to_string())); - } - let results = self.remove_node_with_integer(integer_id); - self.set_last_written_datetime(current_datetime); - - // Regenerate the Vector Resource's merkle root after updating its contents - if self.is_merkelized() && update_merkle_hashes { - self.update_merkle_root()?; - } - - results - } - - /// Removes all Nodes/Embeddings at the root level depth. - fn remove_root_nodes_dt_specified( - &mut self, - new_written_datetime: Option>, - update_merkle_hashes: bool, - ) -> Result, VRError> { - let mut ids: Vec = (0..self.node_count()).collect(); - ids.reverse(); - let mut results = vec![]; - - for id in ids { - let result = - self.remove_node_dt_specified(id.to_string(), new_written_datetime.clone(), update_merkle_hashes)?; - results.push(result); - } - - Ok(results) - } - - fn count_total_tokens(&self) -> u64 { - self.nodes.iter().map(|node| node.count_total_tokens()).sum() - } -} - -impl DocumentVectorResource { - /// Create a new MapVectorResource - /// If is_merkelized == true, then this VR will automatically generate a merkle root - /// & merkle hashes for all nodes. - pub fn new( - name: &str, - desc: Option<&str>, - source: VRSourceReference, - resource_embedding: Embedding, - embeddings: Vec, - nodes: Vec, - embedding_model_used: EmbeddingModelType, - is_merkelized: bool, - distribution_info: DistributionInfo, - ) -> Self { - let current_time = ShinkaiTime::generate_time_now(); - let merkle_root = if is_merkelized { - let empty_hash = blake3::Hasher::new().finalize(); - Some(empty_hash.to_hex().to_string()) - } else { - None - }; - - let mut resource = DocumentVectorResource { - name: String::from(name), - description: desc.map(String::from), - source: source, - resource_id: String::from("default"), - resource_embedding, - embeddings, - node_count: nodes.len() as u64, - nodes: nodes, - embedding_model_used_string: embedding_model_used.to_string(), - resource_base_type: VRBaseType::Document, - data_tag_index: DataTagIndex::new(), - created_datetime: current_time.clone(), - last_written_datetime: current_time, - metadata_index: MetadataIndex::new(), - merkle_root, - keywords: VRKeywords::new(), - distribution_info, - }; - - // Generate a unique resource_id - resource.generate_and_update_resource_id(); - resource - } - - /// Initializes an empty `DocumentVectorResource` with empty defaults. Of note, make sure EmbeddingModelType - /// is correct before adding any nodes into the VR. - pub fn new_empty(name: &str, desc: Option<&str>, source: VRSourceReference, is_merkelized: bool) -> Self { - DocumentVectorResource::new( - name, - desc, - source, - Embedding::new(&String::new(), vec![]), - Vec::new(), - Vec::new(), - EmbeddingModelType::OllamaTextEmbeddingsInference(OllamaTextEmbeddingsInference::SnowflakeArcticEmbed_M), - is_merkelized, - DistributionInfo::new_empty(), - ) - } - - /// Appends a new node (with a BaseVectorResource) to the document at the root depth. - pub fn append_vector_resource_node( - &mut self, - resource: BaseVectorResource, - metadata: Option>, - embedding: Embedding, - ) -> Result<(), VRError> { - let path = VRPath::from_string("/")?; - self.append_vector_resource_node_at_path(path, resource, metadata, embedding) - } - - /// Appends a new node (with a BaseVectorResource) at a specific path in the document. - pub fn append_vector_resource_node_at_path( - &mut self, - path: VRPath, - resource: BaseVectorResource, - metadata: Option>, - embedding: Embedding, - ) -> Result<(), VRError> { - let tag_names = resource.as_trait_object().data_tag_index().data_tag_names(); - let node_content = NodeContent::Resource(resource); - let new_node = Node::from_node_content("".to_string(), node_content, metadata, tag_names); - self.append_node_at_path(path, new_node, embedding, true) - } - - /// Appends a new node (with a BaseVectorResource) to the document at the root depth. - /// Automatically uses the existing resource embedding. - pub fn append_vector_resource_node_auto( - &mut self, - resource: BaseVectorResource, - metadata: Option>, - ) -> Result<(), VRError> { - let embedding = resource.as_trait_object().resource_embedding().clone(); - self.append_vector_resource_node(resource, metadata, embedding.clone()) - } - - /// Appends a new text node to the document at the root depth. - pub fn append_text_node( - &mut self, - text: &str, - metadata: Option>, - embedding: Embedding, - parsing_tags: &Vec, // list of datatags you want to parse the data with - ) -> Result<(), VRError> { - let path = VRPath::from_string("/")?; - self.append_text_node_at_path(path, text, metadata, embedding, parsing_tags) - } - - /// Appends a new text node at a specific path in the document. - pub fn append_text_node_at_path( - &mut self, - path: VRPath, - text: &str, - metadata: Option>, - embedding: Embedding, - parsing_tags: &Vec, // list of datatags you want to parse the data with - ) -> Result<(), VRError> { - let validated_data_tags = DataTag::validate_tag_list(text, parsing_tags); - let data_tag_names = validated_data_tags.iter().map(|tag| tag.name.clone()).collect(); - let node_content = NodeContent::Text(text.to_string()); - let new_node = Node::from_node_content("".to_string(), node_content, metadata, data_tag_names); - self.append_node_at_path(path, new_node, embedding, true) - } - - /// Appends a new node (with ExternalContent) to the document at root path. - pub fn append_external_content_node( - &mut self, - external_content: SourceReference, - metadata: Option>, - embedding: Embedding, - ) -> Result<(), VRError> { - let path = VRPath::from_string("/")?; - self.append_external_content_node_at_path(path, external_content, metadata, embedding) - } - - /// Appends a new node (with ExternalContent) at a specific path in the document. - pub fn append_external_content_node_at_path( - &mut self, - path: VRPath, - external_content: SourceReference, - metadata: Option>, - embedding: Embedding, - ) -> Result<(), VRError> { - let node_content = NodeContent::ExternalContent(external_content); - let new_node = Node::from_node_content("".to_string(), node_content, metadata, vec![]); - self.append_node_at_path(path, new_node, embedding, true) - } - - /// Appends a new node (with VRHeader) to the document at root depth. - pub fn append_vr_header_node( - &mut self, - vr_header: VRHeader, - metadata: Option>, - embedding: Embedding, - ) -> Result<(), VRError> { - let path = VRPath::from_string("/")?; - self.append_vr_header_node_at_path(path, vr_header, metadata, embedding) - } - - /// Appends a new node (with VRHeader) at a specific path in the document. - pub fn append_vr_header_node_at_path( - &mut self, - path: VRPath, - vr_header: VRHeader, - metadata: Option>, - embedding: Embedding, - ) -> Result<(), VRError> { - let data_tag_names = vr_header.data_tag_names.clone(); - let node_content = NodeContent::VRHeader(vr_header); - let new_node = Node::from_node_content("".to_string(), node_content, metadata, data_tag_names); - self.append_node_at_path(path, new_node, embedding, true) - } - - /// Replaces an existing node and associated embedding in the Document resource at root depth, - /// with a BaseVectorResource in the new Node. - pub fn replace_with_vector_resource_node( - &mut self, - id: u64, - new_resource: BaseVectorResource, - new_metadata: Option>, - embedding: Embedding, - ) -> Result<(Node, Embedding), VRError> { - let path = VRPath::from_string(&("/".to_string() + &id.to_string()))?; - self.replace_with_vector_resource_node_at_path(path, new_resource, new_metadata, embedding) - } - - /// Replaces an existing node and associated embedding at a specific path in the Document resource - /// with a BaseVectorResource in the new Node. - pub fn replace_with_vector_resource_node_at_path( - &mut self, - path: VRPath, - new_resource: BaseVectorResource, - new_metadata: Option>, - embedding: Embedding, - ) -> Result<(Node, Embedding), VRError> { - let tag_names = new_resource.as_trait_object().data_tag_index().data_tag_names(); - let node_content = NodeContent::Resource(new_resource); - let new_node = Node::from_node_content("".to_string(), node_content, new_metadata, tag_names); - self.replace_node_at_path(path, new_node, embedding, true) - } - - /// Replaces an existing node & associated embedding at the root depth, - /// with a text node. - pub fn replace_with_text_node( - &mut self, - id: u64, - new_text: &str, - new_metadata: Option>, - embedding: Embedding, - parsing_tags: Vec, // List of datatags you want to parse the new data with. - ) -> Result<(Node, Embedding), VRError> { - let path = VRPath::from_string(&("/".to_string() + &id.to_string()))?; - self.replace_with_text_node_at_path(path, new_text, new_metadata, embedding, parsing_tags) - } - - /// Replaces an existing node & associated embedding at a specific path in the Document resource - /// with a text node. - pub fn replace_with_text_node_at_path( - &mut self, - path: VRPath, - new_text: &str, - new_metadata: Option>, - embedding: Embedding, - parsing_tags: Vec, // List of datatags you want to parse the new data with. - ) -> Result<(Node, Embedding), VRError> { - // Validate which tags will be saved with the new data - let validated_data_tags = DataTag::validate_tag_list(&new_text, &parsing_tags); - let data_tag_names = validated_data_tags.iter().map(|tag| tag.name.clone()).collect(); - let node_content = NodeContent::Text(new_text.to_string()); - let new_node = Node::from_node_content("".to_string(), node_content, new_metadata, data_tag_names); - self.replace_node_at_path(path, new_node, embedding, true) - } - - /// Replaces an existing node & associated embedding with a new ExternalContent node at root depth. - pub fn replace_with_external_content_node( - &mut self, - id: u64, - new_external_content: SourceReference, - new_metadata: Option>, - embedding: Embedding, - ) -> Result<(Node, Embedding), VRError> { - let path = VRPath::from_string(&("/".to_string() + &id.to_string()))?; - self.replace_with_external_content_node_at_path(path, new_external_content, new_metadata, embedding) - } - - /// Replaces an existing node & associated embedding with a new ExternalContent node at a specific path. - pub fn replace_with_external_content_node_at_path( - &mut self, - path: VRPath, - new_external_content: SourceReference, - new_metadata: Option>, - embedding: Embedding, - ) -> Result<(Node, Embedding), VRError> { - let node_content = NodeContent::ExternalContent(new_external_content); - let new_node = Node::from_node_content("".to_string(), node_content, new_metadata, vec![]); - self.replace_node_at_path(path, new_node, embedding, true) - } - - /// Replaces an existing node & associated embedding with a new VRHeader node at root depth. - pub fn replace_with_vr_header_node( - &mut self, - id: u64, - new_vr_header: VRHeader, - new_metadata: Option>, - embedding: Embedding, - ) -> Result<(Node, Embedding), VRError> { - let path = VRPath::from_string(&("/".to_string() + &id.to_string()))?; - self.replace_with_vr_header_node_at_path(path, new_vr_header, new_metadata, embedding) - } - - /// Replaces an existing node & associated embedding with a new VRHeader node at a specific path. - pub fn replace_with_vr_header_node_at_path( - &mut self, - path: VRPath, - new_vr_header: VRHeader, - new_metadata: Option>, - embedding: Embedding, - ) -> Result<(Node, Embedding), VRError> { - let data_tag_names = new_vr_header.data_tag_names.clone(); - let node_content = NodeContent::VRHeader(new_vr_header); - let new_node = Node::from_node_content("".to_string(), node_content, new_metadata, data_tag_names); - self.replace_node_at_path(path, new_node, embedding, true) - } - - /// Pops and returns the last node and associated embedding. - pub fn pop_node(&mut self) -> Result<(Node, Embedding), VRError> { - let path = VRPath::from_string("/")?; - self.pop_node_at_path(path, true) - } - - /// Deletes a node and associated embedding from the resource. - pub fn remove_node_with_integer(&mut self, id: u64) -> Result<(Node, Embedding), VRError> { - // Remove the node + adjust remaining node ids - let deleted_node = self._remove_root_node(id)?; - self.data_tag_index.remove_node(&deleted_node); - self.metadata_index.remove_node(&deleted_node); - - // Remove the embedding - let index = if id == 0 { 0 } else { (id - 1) as usize }; - let deleted_embedding = self.embeddings.remove(index); - - // Adjust the ids of the remaining embeddings - for i in index..self.embeddings.len() { - self.embeddings[i].set_id_with_integer((i + 1) as u64); - } - - Ok((deleted_node, deleted_embedding)) - } - - /// Internal node deletion - fn _remove_root_node(&mut self, id: u64) -> Result { - if id > self.node_count { - return Err(VRError::InvalidNodeId(id.to_string())); - } - let index = if id == 0 { 0 } else { (id - 1) as usize }; - let removed_node = self.nodes.remove(index); - self.node_count -= 1; - for node in self.nodes.iter_mut().skip(index) { - let node_id: u64 = node.id.parse().unwrap(); - node.id = format!("{}", node_id - 1); - } - self.update_last_written_to_now(); - Ok(removed_node) - } - - pub fn from_json(json: &str) -> Result { - Ok(serde_json::from_str(json)?) - } - - pub fn set_resource_id(&mut self, resource_id: String) { - self.resource_id = resource_id; - self.update_last_written_to_now(); - } -} diff --git a/shinkai-libs/shinkai-vector-resources/src/vector_resource/map_resource.rs b/shinkai-libs/shinkai-vector-resources/src/vector_resource/map_resource.rs deleted file mode 100644 index 6962defb0..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/vector_resource/map_resource.rs +++ /dev/null @@ -1,786 +0,0 @@ -use super::{VRKeywords, VectorResourceSearch}; -use crate::data_tags::{DataTag, DataTagIndex}; -use crate::embeddings::Embedding; -use crate::metadata_index::MetadataIndex; -use crate::model_type::{EmbeddingModelType, EmbeddingModelTypeString, OllamaTextEmbeddingsInference}; -use crate::resource_errors::VRError; -use crate::shinkai_time::ShinkaiTime; -use crate::source::{DistributionInfo, SourceReference, VRSourceReference}; -use crate::vector_resource::base_vector_resources::{BaseVectorResource, VRBaseType}; -use crate::vector_resource::vector_search_traversal::VRHeader; -use crate::vector_resource::{Node, NodeContent, OrderedVectorResource, VRPath, VectorResource, VectorResourceCore}; -use chrono::{DateTime, Utc}; -use serde_json; -use std::any::Any; -use std::collections::HashMap; -use utoipa::ToSchema; - -/// A VectorResource which uses a HashMap data model, thus providing a -/// native key-value interface. Ideal for use cases such as field-based data sources, classical DBs, -/// constantly-updating data streams, or any unordered/mutating source data. -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, ToSchema)] -pub struct MapVectorResource { - pub name: String, - pub description: Option, - pub source: VRSourceReference, - pub resource_id: String, - pub resource_embedding: Embedding, - pub resource_base_type: VRBaseType, - #[schema(value_type = String)] - pub embedding_model_used_string: EmbeddingModelTypeString, - pub embeddings: HashMap, - pub node_count: u64, - pub nodes: HashMap, - pub data_tag_index: DataTagIndex, - #[schema(value_type = String, format = Date)] - pub created_datetime: DateTime, - #[schema(value_type = String, format = Date)] - pub last_written_datetime: DateTime, - pub metadata_index: MetadataIndex, - pub merkle_root: Option, - pub keywords: VRKeywords, - pub distribution_info: DistributionInfo, -} -impl VectorResource for MapVectorResource {} -impl VectorResourceSearch for MapVectorResource {} - -impl VectorResourceCore for MapVectorResource { - fn as_any(&self) -> &dyn Any { - self - } - - fn as_any_mut(&mut self) -> &mut dyn Any { - self - } - - /// OrderedVectorResource trait not supported. Simply returns error . - fn as_ordered_vector_resource(&self) -> Result<&dyn OrderedVectorResource, VRError> { - Err(VRError::ResourceDoesNotSupportOrderedOperations( - self.resource_base_type().to_str().to_string(), - )) - } - - /// OrderedVectorResource trait not supported. Simply returns error . - fn as_ordered_vector_resource_mut(&mut self) -> Result<&mut dyn OrderedVectorResource, VRError> { - Err(VRError::ResourceDoesNotSupportOrderedOperations( - self.resource_base_type().to_str().to_string(), - )) - } - - /// Returns the merkle root of the Vector Resource (if it is not None). - fn get_merkle_root(&self) -> Result { - self.merkle_root - .clone() - .ok_or(VRError::MerkleRootNotFound(self.reference_string())) - } - - /// Sets the merkle root of the Vector Resource, errors if provided hash is not a valid Blake3 hash. - fn set_merkle_root(&mut self, merkle_hash: String) -> Result<(), VRError> { - // Validate the hash format - if blake3::Hash::from_hex(&merkle_hash).is_ok() { - self.merkle_root = Some(merkle_hash); - Ok(()) - } else { - Err(VRError::InvalidMerkleHashString(merkle_hash)) - } - } - - /// RFC3339 Datetime when then Vector Resource was created - fn created_datetime(&self) -> DateTime { - self.created_datetime - } - /// RFC3339 Datetime when then Vector Resource was last written - fn last_written_datetime(&self) -> DateTime { - self.last_written_datetime - } - /// Set a RFC Datetime of when then Vector Resource was last written - fn set_last_written_datetime(&mut self, datetime: DateTime) { - self.last_written_datetime = datetime; - } - - fn data_tag_index(&self) -> &DataTagIndex { - &self.data_tag_index - } - - fn metadata_index(&self) -> &MetadataIndex { - &self.metadata_index - } - - fn distribution_info(&self) -> &DistributionInfo { - &self.distribution_info - } - - fn set_distribution_info(&mut self, dist_info: DistributionInfo) { - self.distribution_info = dist_info; - } - - fn embedding_model_used_string(&self) -> EmbeddingModelTypeString { - self.embedding_model_used_string.to_string() - } - - fn name(&self) -> &str { - &self.name - } - - fn description(&self) -> Option<&str> { - self.description.as_deref() - } - - fn source(&self) -> VRSourceReference { - self.source.clone() - } - - fn keywords(&self) -> &VRKeywords { - &self.keywords - } - - fn keywords_mut(&mut self) -> &mut VRKeywords { - &mut self.keywords - } - - fn set_name(&mut self, new_name: String) { - self.name = new_name; - } - - fn set_description(&mut self, new_description: Option) { - self.description = new_description; - } - - fn set_source(&mut self, new_source: VRSourceReference) { - self.source = new_source; - } - - fn resource_id(&self) -> &str { - &self.resource_id - } - - fn resource_embedding(&self) -> &Embedding { - &self.resource_embedding - } - - fn resource_base_type(&self) -> VRBaseType { - self.resource_base_type.clone() - } - - fn get_root_embeddings(&self) -> Vec { - self.embeddings.values().cloned().collect() - } - - fn to_json(&self) -> Result { - Ok(serde_json::to_string(self)?) - } - - fn to_json_value(&self) -> Result { - Ok(serde_json::to_value(self)?) - } - - fn set_embedding_model_used(&mut self, model_type: EmbeddingModelType) { - self.update_last_written_to_now(); - self.embedding_model_used_string = model_type.to_string(); - } - - fn set_resource_embedding(&mut self, embedding: Embedding) { - self.update_last_written_to_now(); - self.resource_embedding = embedding; - } - - fn node_count(&self) -> u64 { - self.node_count - } - - fn set_resource_id(&mut self, id: String) { - self.update_last_written_to_now(); - self.resource_id = id; - } - - fn get_data_tag_index(&self) -> &DataTagIndex { - &self.data_tag_index - } - - fn set_data_tag_index(&mut self, data_tag_index: DataTagIndex) { - self.data_tag_index = data_tag_index; - } - - fn get_metadata_index(&self) -> &MetadataIndex { - &self.metadata_index - } - - fn set_metadata_index(&mut self, metadata_index: MetadataIndex) { - self.metadata_index = metadata_index; - } - - /// Retrieves a node's embedding given its key (id) - fn get_root_embedding(&self, key: String) -> Result { - let key = VRPath::clean_string(&key); - Ok(self - .embeddings - .get(&key) - .ok_or(VRError::InvalidNodeId(key.to_string()))? - .clone()) - } - - /// Retrieves a node given its key (id) - fn get_root_node(&self, key: String) -> Result { - let key = VRPath::clean_string(&key); - self.nodes - .get(&key) - .cloned() - .ok_or(VRError::InvalidNodeId(key.to_string())) - } - - /// Returns all nodes in the MapVectorResource - fn get_root_nodes(&self) -> Vec { - self.nodes.values().cloned().collect() - } - - /// Returns all nodes in the DocumentVectorResource as references to nodes - fn get_root_nodes_ref(&self) -> Vec<&Node> { - self.nodes.iter().map(|(_, node)| node).collect() - } - - /// Returns all embeddings in the DocumentVectorResource as references to embeddings - fn get_root_embeddings_ref(&self) -> Vec<&Embedding> { - self.embeddings.iter().map(|(_, embedding)| embedding).collect() - } - - /// Insert a Node/Embedding into the VR using the provided id (root level depth). Overwrites existing data. - fn insert_node_dt_specified( - &mut self, - id: String, - node: Node, - embedding: Embedding, - new_written_datetime: Option>, - update_merkle_hashes: bool, - ) -> Result<(), VRError> { - let current_datetime = if let Some(dt) = new_written_datetime { - dt - } else { - ShinkaiTime::generate_time_now() - }; - - let id = VRPath::clean_string(&id); - // Update ids to match supplied id - let mut updated_node = node; - updated_node.id = id.to_string(); - updated_node.set_last_written(current_datetime); - let mut embedding = embedding.clone(); - embedding.set_id(id.to_string()); - // Update the node merkle hash if the VR is merkelized. This guarantees merkle hash is always up to date. - if self.is_merkelized() && update_merkle_hashes { - updated_node.update_merkle_hash()?; - } - - // Insert node/embeddings - self._insert_root_node(updated_node.clone()); - self.embeddings.insert(updated_node.id.clone(), embedding); - - // Update indices - self.data_tag_index.add_node(&updated_node); - self.metadata_index.add_node(&updated_node); - - self.set_last_written_datetime(current_datetime); - // Regenerate the Vector Resource's merkle root after updating its contents - if self.is_merkelized() && update_merkle_hashes { - self.update_merkle_root()?; - } - Ok(()) - } - - /// Replace a Node/Embedding in the VR using the provided id (root level depth) - fn replace_node_dt_specified( - &mut self, - id: String, - node: Node, - embedding: Embedding, - new_written_datetime: Option>, - update_merkle_hashes: bool, - ) -> Result<(Node, Embedding), VRError> { - let id = VRPath::clean_string(&id); - let current_datetime = if let Some(dt) = new_written_datetime { - dt - } else { - ShinkaiTime::generate_time_now() - }; - - // Update new_node id/last written - let mut new_node = node; - new_node.id = id.clone(); - new_node.set_last_written(current_datetime); - // Update the node merkle hash if the VR is merkelized. This guarantees merkle hash is always up to date. - if self.is_merkelized() && update_merkle_hashes { - new_node.update_merkle_hash()?; - } - - // Replace old node, and get old embedding - let old_node = self - .nodes - .insert(id.to_string(), new_node.clone()) - .ok_or(VRError::InvalidNodeId(id.to_string()))?; - let old_embedding = self.get_root_embedding(id.clone())?; - - // Then deletion of old node from indexes and addition of new node - if old_node.data_tag_names != new_node.data_tag_names { - self.data_tag_index.remove_node(&old_node); - self.data_tag_index.add_node(&new_node); - } - if old_node.metadata_keys() != new_node.metadata_keys() { - self.metadata_index.remove_node(&old_node); - self.metadata_index.add_node(&new_node); - } - - // Finally replacing the embedding - let mut embedding = embedding.clone(); - embedding.set_id(id.to_string()); - self.embeddings.insert(id.to_string(), embedding); - self.set_last_written_datetime(current_datetime); - - // Regenerate the Vector Resource's merkle root after updating its contents - if self.is_merkelized() && update_merkle_hashes { - self.update_merkle_root()?; - } - - Ok((old_node, old_embedding)) - } - - /// Remove a Node/Embedding in the VR using the provided id (root level depth) - fn remove_node_dt_specified( - &mut self, - id: String, - new_written_datetime: Option>, - update_merkle_hashes: bool, - ) -> Result<(Node, Embedding), VRError> { - let current_datetime = if let Some(dt) = new_written_datetime { - dt - } else { - ShinkaiTime::generate_time_now() - }; - - let id = VRPath::clean_string(&id); - let results = self.remove_root_node(&id); - self.set_last_written_datetime(current_datetime); - - // Regenerate the Vector Resource's merkle root after updating its contents - if self.is_merkelized() && update_merkle_hashes { - self.update_merkle_root()?; - } - - results - } - - /// Removes all Nodes/Embeddings at the root level depth. - fn remove_root_nodes_dt_specified( - &mut self, - new_written_datetime: Option>, - update_merkle_hashes: bool, - ) -> Result, VRError> { - let ids: Vec = self.nodes.keys().cloned().collect(); - let mut results = vec![]; - - for id in ids { - let result = self.remove_node_dt_specified(id.to_string(), new_written_datetime, update_merkle_hashes)?; - results.push(result); - } - - Ok(results) - } - - fn count_total_tokens(&self) -> u64 { - self.nodes.values().map(|node| node.count_total_tokens()).sum() - } -} - -impl MapVectorResource { - /// Create a new MapVectorResource. - /// If is_merkelized == true, then this VR will automatically generate a merkle root - /// & merkle hashes for all nodes. - #[allow(clippy::too_many_arguments)] - pub fn new( - name: &str, - desc: Option<&str>, - source: VRSourceReference, - resource_embedding: Embedding, - embeddings: HashMap, - nodes: HashMap, - embedding_model_used: EmbeddingModelType, - is_merkelized: bool, - distribution_info: DistributionInfo, - ) -> Self { - let current_time = ShinkaiTime::generate_time_now(); - let merkle_root = if is_merkelized { - let empty_hash = blake3::Hasher::new().finalize(); - Some(empty_hash.to_hex().to_string()) - } else { - None - }; - - let mut resource = MapVectorResource { - name: String::from(name), - description: desc.map(String::from), - source, - resource_id: String::from("default"), - resource_embedding, - embeddings, - node_count: nodes.len() as u64, - resource_base_type: VRBaseType::Map, - nodes, - embedding_model_used_string: embedding_model_used.to_string(), - data_tag_index: DataTagIndex::new(), - created_datetime: current_time, - last_written_datetime: current_time, - metadata_index: MetadataIndex::new(), - merkle_root, - keywords: VRKeywords::new(), - distribution_info, - }; - // Generate a unique resource_id: - resource.generate_and_update_resource_id(); - resource - } - - /// Initializes an empty `MapVectorResource` with empty defaults. Of note, make sure EmbeddingModelType - /// is correct before adding any nodes into the VR. - pub fn new_empty(name: &str, desc: Option<&str>, source: VRSourceReference, is_merkelized: bool) -> Self { - MapVectorResource::new( - name, - desc, - source, - Embedding::new(&String::new(), vec![]), - HashMap::new(), - HashMap::new(), - EmbeddingModelType::OllamaTextEmbeddingsInference(OllamaTextEmbeddingsInference::SnowflakeArcticEmbed_M), - is_merkelized, - DistributionInfo::new_empty(), - ) - } - - /// Inserts a new node (with a BaseVectorResource) with the provided embedding - /// at the specified key in the Map resource root. - pub fn insert_vector_resource_node( - &mut self, - key: &str, - resource: BaseVectorResource, - metadata: Option>, - embedding: Embedding, - ) -> Result<(), VRError> { - self.insert_vector_resource_node_at_path(VRPath::new(), key, resource, metadata, embedding) - } - - /// Inserts a new node (with a BaseVectorResource) into the specified parent_path using the provided key. - pub fn insert_vector_resource_node_at_path( - &mut self, - parent_path: VRPath, - key: &str, - resource: BaseVectorResource, - metadata: Option>, - embedding: Embedding, - ) -> Result<(), VRError> { - let tag_names = resource.as_trait_object().data_tag_index().data_tag_names(); - let node_content = NodeContent::Resource(resource.clone()); - let new_internal_node = Node::from_node_content(key.to_string(), node_content, metadata.clone(), tag_names); - - self.insert_node_at_path(parent_path, key.to_string(), new_internal_node, embedding, true) - } - - /// Inserts a new node (with a BaseVectorResource) using the resource's included embedding - /// at the specified key in the Map resource root. - pub fn insert_vector_resource_node_auto( - &mut self, - key: &str, - resource: BaseVectorResource, - metadata: Option>, - ) -> Result<(), VRError> { - let embedding = resource.as_trait_object().resource_embedding().clone(); - self.insert_vector_resource_node(key, resource, metadata, embedding) - } - - /// Inserts a new text node and associated embedding at the specified key in the Map resource root. - pub fn insert_text_node( - &mut self, - key: String, - text_value: String, - metadata: Option>, - embedding: Embedding, - parsing_tags: &Vec, // list of datatags you want to parse the data with - ) -> Result<(), VRError> { - self.insert_text_node_at_path(VRPath::new(), key, text_value, metadata, embedding, parsing_tags) - } - - /// Inserts a new text node and associated embedding into the specified parent_path using the provided key. - pub fn insert_text_node_at_path( - &mut self, - parent_path: VRPath, - key: String, - text_value: String, - metadata: Option>, - embedding: Embedding, - parsing_tags: &Vec, // list of datatags you want to parse the data with - ) -> Result<(), VRError> { - let validated_data_tags = DataTag::validate_tag_list(&text_value, parsing_tags); - let data_tag_names = validated_data_tags.iter().map(|tag| tag.name.clone()).collect(); - let node_content = NodeContent::Text(text_value); - let new_node = Node::from_node_content(key.clone(), node_content, metadata.clone(), data_tag_names); - - self.insert_node_at_path(parent_path, key, new_node, embedding, true) - } - - /// Inserts a new node (with ExternalContent) at the specified key in the Map resource root. - /// Uses the supplied Embedding. - pub fn insert_external_content_node( - &mut self, - key: String, - external_content: SourceReference, - metadata: Option>, - embedding: Embedding, - ) -> Result<(), VRError> { - self.insert_external_content_node_at_path(VRPath::new(), key, external_content, metadata, embedding) - } - - /// Inserts a new node (with ExternalContent) into the specified parent_path using the provided key. - /// Uses the supplied Embedding. - pub fn insert_external_content_node_at_path( - &mut self, - parent_path: VRPath, - key: String, - external_content: SourceReference, - metadata: Option>, - embedding: Embedding, - ) -> Result<(), VRError> { - // As ExternalContent doesn't have data tags, we pass an empty vector - let node_content = NodeContent::ExternalContent(external_content); - let new_node = Node::from_node_content(key.clone(), node_content, metadata.clone(), Vec::new()); - - self.insert_node_at_path(parent_path, key, new_node, embedding, true) - } - - /// Inserts a new node (with VRHeader) at the specified key in the Map resource root. - /// Uses the supplied Embedding. - pub fn insert_vr_header_node( - &mut self, - key: String, - vr_header: VRHeader, - metadata: Option>, - embedding: Embedding, - ) -> Result<(), VRError> { - self.insert_vr_header_node_at_path(VRPath::new(), key, vr_header, metadata, embedding) - } - - /// Inserts a new node (with VRHeader) into the specified parent_path using the provided key. - /// Uses the supplied Embedding. - pub fn insert_vr_header_node_at_path( - &mut self, - parent_path: VRPath, - key: String, - vr_header: VRHeader, - metadata: Option>, - embedding: Embedding, - ) -> Result<(), VRError> { - let data_tag_names = vr_header.data_tag_names.clone(); - let node_content = NodeContent::VRHeader(vr_header); - let new_node = Node::from_node_content(key.clone(), node_content, metadata.clone(), data_tag_names); - - self.insert_node_at_path(parent_path, key, new_node, embedding, true) - } - - /// Insert a new node and associated embeddings to the Map resource - /// without checking if tags are valid. - pub fn _insert_kv_without_tag_validation( - &mut self, - key: &str, - data: NodeContent, - metadata: Option>, - embedding: &Embedding, - tag_names: &Vec, - ) { - let node = Node::from_node_content(key.to_string(), data.clone(), metadata.clone(), tag_names.clone()); - let _ = self.insert_root_node(key.to_string(), node, embedding.clone()); - } - - /// Replaces an existing node & associated embedding with a new BaseVectorResource at the specified key at root depth. - pub fn replace_with_vector_resource_node( - &mut self, - key: String, - new_resource: BaseVectorResource, - new_metadata: Option>, - embedding: &Embedding, - ) -> Result<(Node, Embedding), VRError> { - let path = VRPath::from_string(&("/".to_owned() + &key))?; - self.replace_with_vector_resource_node_at_path(path, new_resource, new_metadata, embedding) - } - - /// Replaces an existing node & associated embedding with a new BaseVectorResource at the specified path. - /// Of note, path must include the node's id as the final part of the path. - pub fn replace_with_vector_resource_node_at_path( - &mut self, - path: VRPath, - new_resource: BaseVectorResource, - new_metadata: Option>, - embedding: &Embedding, - ) -> Result<(Node, Embedding), VRError> { - let tag_names = new_resource.as_trait_object().data_tag_index().data_tag_names(); - let node_content = NodeContent::Resource(new_resource); - - if let Some(key) = path.path_ids.last() { - let new_node = Node::from_node_content(key.clone(), node_content, new_metadata.clone(), tag_names); - self.replace_node_at_path(path, new_node, embedding.clone(), true) - } else { - Err(VRError::InvalidVRPath(path.clone())) - } - } - - /// Replaces an existing node & associated embedding with a new text node at the specified key at root depth. - pub fn replace_with_text_node( - &mut self, - key: String, - new_text: String, - new_metadata: Option>, - embedding: Embedding, - parsing_tags: Vec, // List of datatags you want to parse the new data with. - ) -> Result<(Node, Embedding), VRError> { - let path = VRPath::from_string(&("/".to_owned() + &key))?; - self.replace_with_text_node_at_path(path, new_text, new_metadata, embedding, parsing_tags) - } - - /// Replaces an existing node & associated embedding with a new text node at the specified path. - /// Of note, path must include the node's id as the final part of the path. - pub fn replace_with_text_node_at_path( - &mut self, - path: VRPath, - new_text: String, - new_metadata: Option>, - embedding: Embedding, - parsing_tags: Vec, // List of datatags you want to parse the new data with. - ) -> Result<(Node, Embedding), VRError> { - // Validate which tags will be saved with the new data - let validated_data_tags = DataTag::validate_tag_list(&new_text, &parsing_tags); - let data_tag_names = validated_data_tags.iter().map(|tag| tag.name.clone()).collect(); - - if let Some(key) = path.path_ids.last() { - let node_content = NodeContent::Text(new_text); - let new_node = Node::from_node_content(key.clone(), node_content, new_metadata.clone(), data_tag_names); - self.replace_node_at_path(path, new_node, embedding.clone(), true) - } else { - Err(VRError::InvalidVRPath(path.clone())) - } - } - - /// Replaces an existing node & associated embedding with a new ExternalContent node at the specified key at root depth. - pub fn replace_with_external_content_node( - &mut self, - key: String, - new_external_content: SourceReference, - new_metadata: Option>, - embedding: &Embedding, - ) -> Result<(Node, Embedding), VRError> { - let path = VRPath::from_string(&("/".to_owned() + &key))?; - self.replace_with_external_content_node_at_path(path, new_external_content, new_metadata, embedding) - } - - /// Replaces an existing node & associated embedding with a new ExternalContent node at the specified path. - /// Of note, path must include the node's id as the final part of the path. - pub fn replace_with_external_content_node_at_path( - &mut self, - path: VRPath, - new_external_content: SourceReference, - new_metadata: Option>, - embedding: &Embedding, - ) -> Result<(Node, Embedding), VRError> { - let node_content = NodeContent::ExternalContent(new_external_content); - - if let Some(key) = path.path_ids.last() { - let new_node = Node::from_node_content(key.clone(), node_content, new_metadata.clone(), Vec::new()); - self.replace_node_at_path(path, new_node, embedding.clone(), true) - } else { - Err(VRError::InvalidVRPath(path.clone())) - } - } - - /// Replaces an existing node & associated embedding with a new VRHeader node at the specified key at root depth. - pub fn replace_with_vr_header_node( - &mut self, - key: String, - new_vr_header: VRHeader, - new_metadata: Option>, - embedding: &Embedding, - ) -> Result<(Node, Embedding), VRError> { - let path = VRPath::from_string(&("/".to_owned() + &key))?; - self.replace_with_vr_header_node_at_path(path, new_vr_header, new_metadata, embedding) - } - - /// Replaces an existing node & associated embedding with a new VRHeader node at the specified path. - /// Of note, path must include the node's id as the final part of the path. - pub fn replace_with_vr_header_node_at_path( - &mut self, - path: VRPath, - new_vr_header: VRHeader, - new_metadata: Option>, - embedding: &Embedding, - ) -> Result<(Node, Embedding), VRError> { - let data_tag_names = new_vr_header.data_tag_names.clone(); - let node_content = NodeContent::VRHeader(new_vr_header); - - if let Some(key) = path.path_ids.last() { - let new_node = Node::from_node_content(key.clone(), node_content, new_metadata.clone(), data_tag_names); - self.replace_node_at_path(path, new_node, embedding.clone(), true) - } else { - Err(VRError::InvalidVRPath(path.clone())) // Replace with your actual error - } - } - - /// Replaces an existing node & associated embeddings in the Map resource - /// without checking if tags are valid. - pub fn _replace_kv_without_tag_validation( - &mut self, - key: &str, - new_data: NodeContent, - new_metadata: Option>, - embedding: &Embedding, - new_tag_names: &Vec, - ) -> Result<(Node, Embedding), VRError> { - let new_node = Node::from_node_content( - key.to_string(), - new_data.clone(), - new_metadata.clone(), - new_tag_names.clone(), - ); - self.replace_root_node(key.to_string(), new_node, embedding.clone()) - } - - /// Internal method for removing root node/embedding, and updating indexes. - fn remove_root_node(&mut self, key: &str) -> Result<(Node, Embedding), VRError> { - let deleted_node = self._remove_root_node(key)?; - let deleted_embedding = self - .embeddings - .remove(key) - .ok_or(VRError::InvalidNodeId(key.to_string()))?; - - self.data_tag_index.remove_node(&deleted_node); - self.metadata_index.remove_node(&deleted_node); - - self.update_last_written_to_now(); - Ok((deleted_node, deleted_embedding)) - } - - /// Internal method. Node deletion from the hashmap - fn _remove_root_node(&mut self, key: &str) -> Result { - self.node_count -= 1; - let removed_node = self.nodes.remove(key).ok_or(VRError::InvalidNodeId(key.to_string()))?; - self.update_last_written_to_now(); - Ok(removed_node) - } - - // Internal method. Inserts a node into the nodes hashmap - fn _insert_root_node(&mut self, node: Node) { - self.node_count += 1; - self.nodes.insert(node.id.clone(), node); - self.update_last_written_to_now(); - } - - pub fn from_json(json: &str) -> Result { - Ok(serde_json::from_str(json)?) - } - - pub fn set_resource_id(&mut self, resource_id: String) { - self.resource_id = resource_id; - self.update_last_written_to_now(); - } -} diff --git a/shinkai-libs/shinkai-vector-resources/src/vector_resource/mod.rs b/shinkai-libs/shinkai-vector-resources/src/vector_resource/mod.rs deleted file mode 100644 index e0d1f2153..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/vector_resource/mod.rs +++ /dev/null @@ -1,23 +0,0 @@ -pub mod base_vector_resources; -pub mod document_resource; -pub mod map_resource; -pub mod simplified_fs_types; -pub mod vector_resource; -pub mod vector_resource_extensions; -pub mod vector_resource_search; -pub mod vector_resource_types; -pub mod vector_search_traversal; -pub mod vrkai; -pub mod vrpack; - -pub use base_vector_resources::*; -pub use document_resource::*; -pub use map_resource::*; -pub use simplified_fs_types::*; -pub use vector_resource::*; -pub use vector_resource_extensions::*; -pub use vector_resource_search::*; - - -pub use vrkai::*; -pub use vrpack::*; diff --git a/shinkai-libs/shinkai-vector-resources/src/vector_resource/simplified_fs_types.rs b/shinkai-libs/shinkai-vector-resources/src/vector_resource/simplified_fs_types.rs deleted file mode 100644 index e229bb6f5..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/vector_resource/simplified_fs_types.rs +++ /dev/null @@ -1,181 +0,0 @@ - -use crate::resource_errors::VRError; - -pub use crate::source::{DistributionInfo, VRSourceReference}; -pub use crate::vector_resource::vector_resource_types::*; -pub use crate::vector_resource::vector_search_traversal::*; -use chrono::{DateTime, Utc}; - -/// Enum that holds the simplified representation of file system entries used in the VectorFS -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub enum SimplifiedFSEntry { - Folder(SimplifiedFSFolder), - Item(SimplifiedFSItem), - Root(SimplifiedFSRoot), -} - -impl SimplifiedFSEntry { - // Attempts to parse the SimplifiedFSEntry into an SimplifiedFSFolder - pub fn as_folder(self) -> Result { - match self { - SimplifiedFSEntry::Folder(folder) => Ok(folder), - SimplifiedFSEntry::Item(i) => Err(VRError::InvalidSimplifiedFSEntryType(i.path.to_string())), - SimplifiedFSEntry::Root(root) => Err(VRError::InvalidSimplifiedFSEntryType(root.path.to_string())), - } - } - - // Attempts to parse the SimplifiedFSEntry into an SimplifiedFSItem - pub fn as_item(self) -> Result { - match self { - SimplifiedFSEntry::Item(item) => Ok(item), - SimplifiedFSEntry::Folder(f) => Err(VRError::InvalidSimplifiedFSEntryType(f.path.to_string())), - SimplifiedFSEntry::Root(root) => Err(VRError::InvalidSimplifiedFSEntryType(root.path.to_string())), - } - } - - // Attempts to parse the SimplifiedFSEntry into an SimplifiedFSItem - pub fn as_root(self) -> Result { - match self { - SimplifiedFSEntry::Root(root) => Ok(root), - SimplifiedFSEntry::Item(item) => Err(VRError::InvalidSimplifiedFSEntryType(item.path.to_string())), - SimplifiedFSEntry::Folder(f) => Err(VRError::InvalidSimplifiedFSEntryType(f.path.to_string())), - } - } - - /// Converts the SimplifiedFSEntry to a JSON string - pub fn to_json(&self) -> Result { - Ok(serde_json::to_string(self)?) - } - - /// Creates a SimplifiedFSEntry from a simplified FSEntry JSON string. - /// Attempts to parse all entry types directly, and then at the top level. - pub fn from_json(s: &str) -> Result { - if let Ok(folder) = SimplifiedFSFolder::from_json(s) { - return Ok(SimplifiedFSEntry::Folder(folder)); - } - if let Ok(item) = SimplifiedFSItem::from_json(s) { - return Ok(SimplifiedFSEntry::Item(item)); - } - if let Ok(root) = SimplifiedFSRoot::from_json(s) { - return Ok(SimplifiedFSEntry::Root(root)); - } - - // If its not any of the specific entries JSON, then fall back on top level parsing - Ok(serde_json::from_str(s)?) - } -} - -/// Struct that holds the simplified representation of the file system root in the VectorFS -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct SimplifiedFSRoot { - pub path: VRPath, - pub child_folders: Vec, - // Datetime when the profile's VectorSimplifiedFS was created - pub created_datetime: DateTime, - /// Datetime which is updated whenever any writes take place. In other words, when - /// a SimplifiedFSItem or SimplifiedFSFolder is updated/moved/renamed/deleted/etc., last written timestamp is updated. - pub last_written_datetime: DateTime, - /// Merkle root of the profile's SimplifiedFS - pub merkle_root: String, -} - -impl SimplifiedFSRoot { - /// Converts to a JSON string - pub fn to_json(&self) -> Result { - Ok(serde_json::to_string(self)?) - } - - /// Deserializes from a JSON string - pub fn from_json(s: &str) -> Result { - Ok(serde_json::from_str(s)?) - } -} - -/// Struct that holds the simplified representation of file system folders in the VectorFS -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct SimplifiedFSFolder { - /// Name of the SimplifiedFSFolder - pub name: String, - /// Path where the SimplifiedFSItem is held in the VectorSimplifiedFS - pub path: VRPath, - /// SimplifiedFSFolders which are held within this SimplifiedFSFolder - pub child_folders: Vec, - /// SimplifiedFSItems which are held within this SimplifiedFSFolder - pub child_items: Vec, - /// Datetime the SimplifiedFSFolder was first created - pub created_datetime: DateTime, - /// Datetime the SimplifiedFSFolder was last read by any ShinkaiName - pub last_read_datetime: DateTime, - /// Datetime the SimplifiedFSFolder was last modified, meaning contents of the directory were changed. - /// Ie. An SimplifiedFSEntry is moved/renamed/deleted/new one added. - pub last_modified_datetime: DateTime, - /// Datetime the SimplifiedFSFolder was last written to, meaning any write took place under the folder. In other words, even when - /// a VR is updated or moved/renamed, then last written is always updated. - pub last_written_datetime: DateTime, - /// Merkle hash comprised of all of the SimplifiedFSEntries within this folder - pub merkle_hash: String, -} - -impl SimplifiedFSFolder { - /// Converts to a JSON string - pub fn to_json(&self) -> Result { - Ok(serde_json::to_string(self)?) - } - - /// Deserializes from a JSON string - pub fn from_json(s: &str) -> Result { - Ok(serde_json::from_str(s)?) - } -} - -/// Struct that holds the simplified representation of file system items in the VectorFS -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct SimplifiedFSItem { - /// Name of the SimplifiedFSItem (based on Vector Resource name) - pub name: String, - /// Path where the SimplifiedFSItem is held in the VectorSimplifiedFS - pub path: VRPath, - /// The VRHeader matching the Vector Resource stored at this SimplifiedFSItem's path - pub vr_header: VRHeader, - /// Datetime the Vector Resource in the SimplifiedFSItem was first created - pub created_datetime: DateTime, - /// Datetime the Vector Resource in the SimplifiedFSItem was last written to, meaning any updates to its contents. - pub last_written_datetime: DateTime, - /// Datetime the SimplifiedFSItem was last read by any ShinkaiName - pub last_read_datetime: DateTime, - /// Datetime the Vector Resource in the SimplifiedFSItem was last saved/updated. - /// For example when saving a VR into the SimplifiedFS that someone else generated on their node, last_written and last_saved will be different. - pub vr_last_saved_datetime: DateTime, - /// Datetime the SourceFileMap in the SimplifiedFSItem was last saved/updated. None if no SourceFileMap was ever saved. - pub source_file_map_last_saved_datetime: Option>, - /// The original release location/date time where the VectorResource/SourceFileMap in this FSItem were made available from. - pub distribution_info: DistributionInfo, - /// The size of the Vector Resource in this SimplifiedFSItem - pub vr_size: usize, - /// The size of the SourceFileMap in this SimplifiedFSItem. Will be 0 if no SourceFiles are saved. - pub source_file_map_size: usize, - /// Merkle hash, which is in fact the merkle root of the Vector Resource stored in the SimplifiedFSItem - pub merkle_hash: String, -} - -impl SimplifiedFSItem { - /// Returns the name of the SimplifiedFSItem (based on the name in VRHeader) - pub fn name(&self) -> String { - self.name.clone() - } - - /// Checks the last saved datetime to determine if it was ever saved into the SimplifiedFSDB - pub fn is_source_file_map_saved(&self) -> bool { - self.source_file_map_last_saved_datetime.is_some() - } - - /// Converts to a JSON string - pub fn to_json(&self) -> Result { - Ok(serde_json::to_string(self)?) - } - - /// Deserializes from a JSON string - pub fn from_json(s: &str) -> Result { - Ok(serde_json::from_str(s)?) - } -} diff --git a/shinkai-libs/shinkai-vector-resources/src/vector_resource/vector_resource.rs b/shinkai-libs/shinkai-vector-resources/src/vector_resource/vector_resource.rs deleted file mode 100644 index c1f5b1c4e..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/vector_resource/vector_resource.rs +++ /dev/null @@ -1,931 +0,0 @@ -pub use super::vector_resource_search::VectorResourceSearch; -use super::OrderedVectorResource; -use crate::data_tags::DataTagIndex; -#[cfg(feature = "desktop-only")] -use crate::embedding_generator::EmbeddingGenerator; -#[cfg(feature = "desktop-only")] -use crate::embedding_generator::RemoteEmbeddingGenerator; -use crate::embeddings::Embedding; -use crate::metadata_index::MetadataIndex; -use crate::model_type::EmbeddingModelType; -use crate::model_type::EmbeddingModelTypeString; -use crate::model_type::OllamaTextEmbeddingsInference; -use crate::resource_errors::VRError; -use crate::shinkai_time::ShinkaiTime; -use crate::source::DistributionInfo; -pub use crate::source::VRSourceReference; -use crate::utils::{hash_string, random_string}; -use crate::vector_resource::base_vector_resources::VRBaseType; -pub use crate::vector_resource::vector_resource_types::*; -pub use crate::vector_resource::vector_search_traversal::*; -use async_trait::async_trait; -use chrono::{DateTime, Utc}; -use std::any::Any; - -#[async_trait] -pub trait VectorResource: Send + Sync + VectorResourceCore + VectorResourceSearch {} - -/// Represents a VectorResource as an abstract trait where new variants can be implemented as structs. -/// `resource_id` is expected to always be unique between different Resources. -#[async_trait] -pub trait VectorResourceCore: Send + Sync { - fn name(&self) -> &str; - fn description(&self) -> Option<&str>; - fn source(&self) -> VRSourceReference; - fn keywords(&self) -> &VRKeywords; - fn keywords_mut(&mut self) -> &mut VRKeywords; - fn set_name(&mut self, new_name: String); - fn set_description(&mut self, new_description: Option); - fn set_source(&mut self, new_source: VRSourceReference); - fn resource_id(&self) -> &str; - fn set_resource_id(&mut self, id: String); - fn resource_embedding(&self) -> &Embedding; - fn set_resource_embedding(&mut self, embedding: Embedding); - fn resource_base_type(&self) -> VRBaseType; - fn embedding_model_used_string(&self) -> EmbeddingModelTypeString; - fn set_embedding_model_used(&mut self, model_type: EmbeddingModelType); - fn node_count(&self) -> u64; - fn distribution_info(&self) -> &DistributionInfo; - fn set_distribution_info(&mut self, dist_info: DistributionInfo); - fn data_tag_index(&self) -> &DataTagIndex; - fn metadata_index(&self) -> &MetadataIndex; - /// Retrieves an Embedding given its id, at the root level depth. - fn get_root_embedding(&self, id: String) -> Result; - /// Retrieves all Embeddings at the root level depth of the Vector Resource. - fn get_root_embeddings(&self) -> Vec; - /// Retrieves references to all Embeddings at the root level of the Vector Resource - fn get_root_embeddings_ref(&self) -> Vec<&Embedding>; - /// Retrieves a copy of a Node given its id, at the root level depth. - fn get_root_node(&self, id: String) -> Result; - /// Retrieves copies of all Nodes at the root level of the Vector Resource - fn get_root_nodes(&self) -> Vec; - /// Retrieves references to all Nodes at the root level of the Vector Resource - fn get_root_nodes_ref(&self) -> Vec<&Node>; - /// Returns the merkle root of the Vector Resource (if it is not None). - fn get_merkle_root(&self) -> Result; - /// Sets the merkle root of the Vector Resource, errors if provided hash is not a Blake3 hash. - fn set_merkle_root(&mut self, merkle_hash: String) -> Result<(), VRError>; - /// Insert a Node/Embedding into the VR using the provided id (root level depth). Overwrites existing data. - /// If no new written datetime is provided, generates now. - fn insert_node_dt_specified( - &mut self, - id: String, - node: Node, - embedding: Embedding, - new_written_datetime: Option>, - update_merkle_hashes: bool, - ) -> Result<(), VRError>; - /// Replace a Node/Embedding in the VR using the provided id (root level depth). If no new written datetime is provided, generates now. - fn replace_node_dt_specified( - &mut self, - id: String, - node: Node, - embedding: Embedding, - new_written_datetime: Option>, - update_merkle_hashes: bool, - ) -> Result<(Node, Embedding), VRError>; - /// Remove a Node/Embedding in the VR using the provided id (root level depth). If no new written datetime is provided, generates now. - fn remove_node_dt_specified( - &mut self, - id: String, - new_written_datetime: Option>, - update_merkle_hashes: bool, - ) -> Result<(Node, Embedding), VRError>; - /// Removes all Nodes/Embeddings at the root level depth. If no new written datetime is provided, generates now. - fn remove_root_nodes_dt_specified( - &mut self, - new_written_datetime: Option>, - update_merkle_hashes: bool, - ) -> Result, VRError>; - /// ISO RFC3339 when then Vector Resource was created - fn created_datetime(&self) -> DateTime; - /// ISO RFC3339 when then Vector Resource was last written into (a node was modified) - fn last_written_datetime(&self) -> DateTime; - /// Set a RFC3339 Datetime of when then Vector Resource was last written - fn set_last_written_datetime(&mut self, datetime: DateTime); - // Returns the Vector Resource's DataTagIndex - fn get_data_tag_index(&self) -> &DataTagIndex; - // Sets the Vector Resource's DataTagIndex - fn set_data_tag_index(&mut self, data_tag_index: DataTagIndex); - // Returns the Vector Resource's MetadataIndex - fn get_metadata_index(&self) -> &MetadataIndex; - // Sets the Vector Resource's MetadataIndex - fn set_metadata_index(&mut self, metadata_index: MetadataIndex); - // Note we cannot add from_json in the trait due to trait object limitations - fn to_json(&self) -> Result; - // Note we cannot add from_json in the trait due to trait object limitations - fn to_json_value(&self) -> Result; - // Convert the VectorResource into a &dyn Any - fn as_any(&self) -> &dyn Any; - // Convert the VectorResource into a &dyn Any - fn as_any_mut(&mut self) -> &mut dyn Any; - //// Attempts to cast the VectorResource into an OrderedVectorResource. Fails if - /// the struct does not support the OrderedVectorResource trait. - fn as_ordered_vector_resource(&self) -> Result<&dyn OrderedVectorResource, VRError>; - /// Attempts to cast the VectorResource into an mut OrderedVectorResource. Fails if - /// the struct does not support the OrderedVectorResource trait. - fn as_ordered_vector_resource_mut(&mut self) -> Result<&mut dyn OrderedVectorResource, VRError>; - - fn count_total_tokens(&self) -> u64; - - /// Insert a Node/Embedding into the VR using the provided id (root level depth). Overwrites existing data. - fn insert_root_node(&mut self, id: String, node: Node, embedding: Embedding) -> Result<(), VRError> { - self.insert_node_dt_specified(id, node, embedding, None, true) - } - - /// Replace a Node/Embedding in the VR using the provided id (root level depth). - fn replace_root_node( - &mut self, - id: String, - node: Node, - embedding: Embedding, - ) -> Result<(Node, Embedding), VRError> { - self.replace_node_dt_specified(id, node, embedding, None, true) - } - - /// Remove a Node/Embedding in the VR using the provided id (root level depth). - fn remove_root_node(&mut self, id: String) -> Result<(Node, Embedding), VRError> { - self.remove_node_dt_specified(id, None, true) - } - - /// Removes all Nodes/Embeddings at the root level depth. - fn remove_root_nodes(&mut self) -> Result, VRError> { - self.remove_root_nodes_dt_specified(None, true) - } - - /// Retrieves all Nodes and their corresponding Embeddings at the root level depth of the Vector Resource. - fn get_root_nodes_and_embeddings(&self) -> Vec<(Node, Embedding)> { - let nodes = self.get_root_nodes(); - let embeddings = self.get_root_embeddings(); - nodes.into_iter().zip(embeddings.into_iter()).collect() - } - - /// Returns the size of the whole Vector Resource after being encoded as JSON. - /// Of note, encoding as JSON ensures we get accurate numbers when the user transfers/saves the VR to file. - fn encoded_size(&self) -> Result { - let json = self.to_json()?; - Ok(json.as_bytes().len()) - } - - /// Checks if the Vector Resource is merkelized. Some VRs may opt to not be merkelized - /// for specific use cases or for extremely large datasets where maximum performance is required. - fn is_merkelized(&self) -> bool { - self.get_merkle_root().is_ok() - } - - /// Returns the embedding model type used by the Vector Resource. - fn embedding_model_used(&self) -> EmbeddingModelType { - EmbeddingModelType::from_string(&self.embedding_model_used_string()).unwrap_or( - EmbeddingModelType::OllamaTextEmbeddingsInference(OllamaTextEmbeddingsInference::Other( - self.embedding_model_used_string().to_string(), - )), - ) - } - - /// Updates the merkle root of the Vector Resource by hashing the merkle hashes of all root nodes. - /// Errors if the Vector Resource is not merkelized. - fn update_merkle_root(&mut self) -> Result<(), VRError> { - if !self.is_merkelized() { - return Err(VRError::VectorResourceIsNotMerkelized(self.reference_string())); - } - - let nodes = self.get_root_nodes(); - let mut hashes = Vec::new(); - - // Collect the merkle hash of each node - for node in nodes { - let node_hash = node.get_merkle_hash()?; - hashes.push(node_hash); - } - - // Combine the hashes to create a root hash - let combined_hashes = hashes.join(""); - let root_hash = blake3::hash(combined_hashes.as_bytes()); - - // Set the new merkle root hash - self.set_merkle_root(root_hash.to_hex().to_string()) - } - - #[cfg(feature = "desktop-only")] - /// Regenerates and updates the resource's embedding using the name/description/source and the provided keywords. - /// If keyword_list is None, will use the resource's set keywords (enables flexibility of which keywords get added to which embedding) - async fn update_resource_embedding( - &mut self, - generator: &dyn EmbeddingGenerator, - keyword_list: Option>, - ) -> Result<(), VRError> { - let keywords = keyword_list.unwrap_or(self.keywords().keyword_list.clone()); - let formatted = self.format_embedding_string(keywords, generator.model_type()); - let new_embedding = generator.generate_embedding(&formatted, "RE").await?; - self.set_resource_embedding(new_embedding); - Ok(()) - } - - #[cfg(feature = "desktop-only")] - /// Regenerates and updates the resource's embedding using the name/description/source and the provided keywords. - /// If keyword_list is None, will use the resource's set keywords (enables flexibility of which keywords get added to which embedding) - fn update_resource_embedding_blocking( - &mut self, - generator: &dyn EmbeddingGenerator, - keyword_list: Option>, - ) -> Result<(), VRError> { - let keywords = keyword_list.unwrap_or(self.keywords().keyword_list.clone()); - let formatted = self.format_embedding_string(keywords, generator.model_type()); - let new_embedding = generator.generate_embedding_blocking(&formatted, "RE")?; - self.set_resource_embedding(new_embedding); - Ok(()) - } - - /// Updates the last_written_datetime to the current time - fn update_last_written_to_now(&mut self) { - let current_time = ShinkaiTime::generate_time_now(); - self.set_last_written_datetime(current_time); - } - - /// Generates a random new id string and sets it as the resource_id. - /// Used in the VectorFS to guarantee each VR stored has a unique id. - fn generate_and_update_resource_id(&mut self) { - let mut data_string = ShinkaiTime::generate_time_now().to_rfc3339(); - data_string = data_string + self.resource_id() + self.name() + &random_string(); - let hashed_string = hash_string(&data_string); - self.set_resource_id(hashed_string) - } - - #[cfg(feature = "desktop-only")] - /// Initializes a `RemoteEmbeddingGenerator` that is compatible with this VectorResource - /// (targets the same model and interface for embedding generation). Of note, you need - /// to make sure the api_url/api_key match for the model used. - fn initialize_compatible_embeddings_generator( - &self, - api_url: &str, - api_key: Option, - ) -> RemoteEmbeddingGenerator { - RemoteEmbeddingGenerator::new(self.embedding_model_used(), api_url, api_key) - } - - /// Generates a formatted string that represents the text to be used for - /// generating the resource embedding. - fn format_embedding_string(&self, keywords: Vec, model: EmbeddingModelType) -> String { - let name = format!("Name: {}", self.name()); - let desc = self - .description() - .map(|description| format!(", Description: {}", description)) - .unwrap_or_default(); - let source_string = format!("Source: {}", self.source().format_source_string()); - - // Take keywords until we hit an upper token cap to ensure - // we do not go past the embedding LLM window. - let pre_keyword_length = name.len() + desc.len() + source_string.len(); - let mut keyword_string = String::new(); - for phrase in keywords { - if pre_keyword_length + keyword_string.len() + phrase.len() <= model.max_input_token_count() { - keyword_string = format!("{}, {}", keyword_string, phrase); - } - } - - let mut result = format!("{}{}{}, Keywords: [{}]", name, source_string, desc, keyword_string); - if result.len() > model.max_input_token_count() { - result = result.chars().take(model.max_input_token_count()).collect(); - } - result - } - - /// Returns a "reference string" that uniquely identifies the VectorResource (formatted as: `{name}:::{resource_id}`). - /// This is also used as the unique identifier of the Vector Resource in the VectorFS. - fn reference_string(&self) -> String { - VRHeader::generate_resource_reference_string(self.name().to_string(), self.resource_id().to_string()) - } - - /// Generates a VRHeader out of the VectorResource. - /// Allows specifying a resource_location to identify where the VectorResource is - /// being stored. - fn generate_resource_header(&self) -> VRHeader { - // Fetch list of data tag names from the index - let tag_names = self.data_tag_index().data_tag_names(); - let embedding = self.resource_embedding().clone(); - let metadata_index_keys = self.metadata_index().get_all_metadata_keys(); - let merkle_root = self.get_merkle_root().ok(); - let keywords = self.keywords().clone(); - - VRHeader::new( - self.name(), - self.resource_id(), - self.resource_base_type(), - Some(embedding), - tag_names, - self.source(), - self.created_datetime(), - self.last_written_datetime(), - metadata_index_keys, - self.embedding_model_used(), - merkle_root, - keywords, - self.distribution_info().clone(), - ) - } - - /// Validates whether the VectorResource has a valid BaseVectorResourceType by checking its .resource_base_type() - fn is_base_vector_resource(&self) -> Result<(), VRError> { - VRBaseType::is_base_vector_resource(self.resource_base_type()) - } - - /// Retrieves a node and its embedding at any depth, given its path. - /// If the path is invalid at any part, or empty, then method will error. - fn retrieve_node_and_embedding_at_path( - &self, - path: VRPath, - query_embedding: Option, - ) -> Result<(RetrievedNode, Embedding), VRError> { - let results = self._internal_retrieve_node_at_path(path.clone(), None)?; - if results.is_empty() { - return Err(VRError::InvalidVRPath(path)); - } - - // Score the retrieved node if a query embedding is provided - let (mut ret_node, embedding) = results[0].clone(); - if let Some(query) = query_embedding { - let score = query.score_similarity(&embedding); - ret_node.score = score; - } - - Ok((results[0].0.clone(), results[0].1.clone())) - } - - /// Retrieves a node at any depth, given its path. - /// If the path is invalid at any part, or empty, then method will error. - fn retrieve_node_at_path( - &self, - path: VRPath, - query_embedding: Option, - ) -> Result { - let (node, _) = self.retrieve_node_and_embedding_at_path(path, query_embedding)?; - Ok(node) - } - - /// Retrieves the embedding of a node at any depth, given its path. - /// If the path is invalid at any part, or empty, then method will error. - fn retrieve_embedding_at_path(&self, path: VRPath) -> Result { - let (_, embedding) = self.retrieve_node_and_embedding_at_path(path, None)?; - Ok(embedding) - } - - /// Retrieves a node and `proximity_window` number of nodes before/after it, given a path. - /// If query_embedding is Some, also scores the retrieved nodes by using it (otherwise their scores default to 0.0); - /// If the path is invalid at any part, or empty, then method will error. - fn proximity_retrieve_nodes_at_path( - &self, - path: VRPath, - proximity_window: u64, - query_embedding: Option, - ) -> Result, VRError> { - self.proximity_retrieve_nodes_and_embeddings_at_path(path, proximity_window, query_embedding) - .map(|nodes| nodes.into_iter().map(|(node, _)| node).collect()) - } - - /// Retrieves a node and `proximity_window` number of nodes before/after it (including their embeddings), given a path. - /// If query_embedding is Some, also scores the retrieved nodes by using it (otherwise their scores default to 0.0); - /// If the path is invalid at any part, or empty, then method will error. - fn proximity_retrieve_nodes_and_embeddings_at_path( - &self, - path: VRPath, - proximity_window: u64, - query_embedding: Option, - ) -> Result, VRError> { - let mut ret_nodes_embeddings = self._internal_retrieve_node_at_path(path.clone(), Some(proximity_window))?; - - if let Some(query) = query_embedding { - for (ret_node, embedding) in ret_nodes_embeddings.iter_mut() { - let score = query.score_similarity(embedding); - ret_node.score = score; - } - } - - Ok(ret_nodes_embeddings) - } - - /// Internal method shared by retrieved node at path methods - fn _internal_retrieve_node_at_path( - &self, - path: VRPath, - proximity_window: Option, - ) -> Result, VRError> { - if path.path_ids.is_empty() { - return Err(VRError::InvalidVRPath(path.clone())); - } - // Fetch the node at root depth directly, then iterate through the rest - let self_header = self.generate_resource_header(); - let mut node = self.get_root_node(path.path_ids[0].clone())?; - let mut embedding = self.get_root_embedding(path.path_ids[0].clone())?; - let mut last_resource_header = self.generate_resource_header(); - let mut retrieved_nodes = Vec::new(); - - // Iterate through the path, going into each Vector Resource until end of path - let mut traversed_path = VRPath::from_string(&(String::from("/") + &path.path_ids[0]))?; - for id in path.path_ids.iter().skip(1) { - traversed_path.push(id.to_string()); - match &node.content { - NodeContent::Resource(resource) => { - let resource_obj = resource.as_trait_object(); - last_resource_header = resource_obj.generate_resource_header(); - - // If we have arrived at the final node, then perform node fetching/adding to results - if traversed_path == path { - // If returning proximity, then try to coerce into an OrderedVectorResource and perform proximity get - if let Some(prox_window) = proximity_window { - if let Ok(ord_res) = resource.as_ordered_vector_resource() { - retrieved_nodes = ord_res.get_node_and_embedding_proximity(id.clone(), prox_window)?; - } else { - return Err(VRError::ResourceDoesNotSupportOrderedOperations( - resource.as_trait_object().reference_string(), - )); - } - } - } - embedding = resource_obj.get_root_embedding(id.clone())?; - node = resource_obj.get_root_node(id.clone())?; - } - // If we hit a non VR-holding node before the end of the path, then the path is invalid - _ => { - return Err(VRError::InvalidVRPath(path.clone())); - } - } - } - - // If there are no retrieved nodes, then access via root - if retrieved_nodes.is_empty() { - // If returning proximity, then try to coerce into an OrderedVectorResource and perform proximity get - if let Some(prox_window) = proximity_window { - if let Ok(ord_res) = self.as_ordered_vector_resource() { - retrieved_nodes = ord_res.get_node_and_embedding_proximity(node.id.clone(), prox_window)?; - } else { - return Err(VRError::ResourceDoesNotSupportOrderedOperations( - self.reference_string(), - )); - } - } else { - retrieved_nodes.push((node, embedding)); - } - } - - // Convert the results into retrieved nodes - let mut final_nodes = vec![]; - for n in retrieved_nodes { - let mut node_path = path.pop_cloned(); - node_path.push(n.0.id.clone()); - final_nodes.push((RetrievedNode::new(n.0, 0.0, self_header.clone(), node_path), n.1)); - } - Ok(final_nodes) - } - - /// Boolean check to see if a node exists at a given path - fn check_node_exists_at_path(&self, path: VRPath) -> bool { - self.retrieve_node_at_path(path, None).is_ok() - } - - /// Applies a mutator function on a node and its embedding at a given path, thereby enabling updating data within a specific node. - /// If the path is invalid at any part, or is 0 length, then method will error, and no changes will be applied to the VR. - fn mutate_node_at_path( - &mut self, - path: VRPath, - mutator: &mut dyn Fn(&mut Node, &mut Embedding) -> Result<(), VRError>, - update_merkle_hashes: bool, - ) -> Result<(), VRError> { - let current_time = ShinkaiTime::generate_time_now(); - let mut deconstructed_nodes = self._deconstruct_nodes_along_path(path.clone(), update_merkle_hashes)?; - - // Update last written time for all nodes - for node in deconstructed_nodes.iter_mut() { - let (_, node, _) = node; - node.set_last_written(current_time); - } - - // Apply mutator to the last node - if let Some(last_node) = deconstructed_nodes.last_mut() { - let (_, node, embedding) = last_node; - mutator(node, embedding)?; - } - - let (node_key, node, embedding) = - self._rebuild_deconstructed_nodes(deconstructed_nodes, update_merkle_hashes)?; - self.replace_node_dt_specified(node_key, node, embedding, Some(current_time), update_merkle_hashes)?; - Ok(()) - } - - /// Removes a specific node from the Vector Resource, based on the provided path. Returns removed Node/Embedding. - /// If the path is invalid at any part, or is 0 length, then method will error, and no changes will be applied to the VR. - fn remove_node_at_path(&mut self, path: VRPath, update_merkle_hashes: bool) -> Result<(Node, Embedding), VRError> { - let current_time = ShinkaiTime::generate_time_now(); - let mut deconstructed_nodes = self._deconstruct_nodes_along_path(path.clone(), update_merkle_hashes)?; - let removed_node = deconstructed_nodes.pop().ok_or(VRError::InvalidVRPath(path))?; - - // Update last written time for all nodes - for node in deconstructed_nodes.iter_mut() { - let (_, node, _) = node; - node.set_last_written(current_time); - } - - // Rebuild the nodes after removing the target node - if !deconstructed_nodes.is_empty() { - let (node_key, node, embedding) = - self._rebuild_deconstructed_nodes(deconstructed_nodes, update_merkle_hashes)?; - self.replace_node_dt_specified(node_key, node, embedding, Some(current_time), update_merkle_hashes)?; - } else { - // Else remove the node directly if deleting at the root level - self.remove_node_dt_specified(removed_node.0, Some(current_time), update_merkle_hashes)?; - } - - Ok((removed_node.1, removed_node.2)) - } - - /// Replaces a specific node from the Vector Resource, based on the provided path. Returns removed Node/Embedding. - /// If the path is invalid at any part, or is 0 length, then method will error, and no changes will be applied to the VR. - fn replace_node_at_path( - &mut self, - path: VRPath, - new_node: Node, - new_embedding: Embedding, - update_merkle_hashes: bool, - ) -> Result<(Node, Embedding), VRError> { - let current_time = ShinkaiTime::generate_time_now(); - // Remove the node at the end of the deconstructed nodes - let mut deconstructed_nodes = self._deconstruct_nodes_along_path(path.clone(), update_merkle_hashes)?; - deconstructed_nodes.pop().ok_or(VRError::InvalidVRPath(path.clone()))?; - - // Insert the new node at the end of the deconstructed nodes - if let Some(key) = path.path_ids.last() { - deconstructed_nodes.push((key.clone(), new_node, new_embedding)); - - // Update last written time for all nodes - for node in deconstructed_nodes.iter_mut() { - let (_, node, _) = node; - node.set_last_written(current_time); - } - - // Rebuild the nodes after replacing the node - let (node_key, node, embedding) = - self._rebuild_deconstructed_nodes(deconstructed_nodes, update_merkle_hashes)?; - let result = - self.replace_node_dt_specified(node_key, node, embedding, Some(current_time), update_merkle_hashes)?; - - Ok(result) - } else { - Err(VRError::InvalidVRPath(path.clone())) - } - } - - /// Inserts a node underneath the provided parent_path, using the supplied id. Supports inserting at root level `/`. - /// If the parent_path is invalid at any part, then method will error, and no changes will be applied to the VR. - fn insert_node_at_path( - &mut self, - parent_path: VRPath, - node_to_insert_id: String, - node_to_insert: Node, - node_to_insert_embedding: Embedding, - update_merkle_hashes: bool, - ) -> Result<(), VRError> { - let current_time = ShinkaiTime::generate_time_now(); - // If inserting at root, just do it directly - if parent_path.path_ids.is_empty() { - self.insert_node_dt_specified( - node_to_insert_id, - node_to_insert, - node_to_insert_embedding, - Some(current_time), - update_merkle_hashes, - )?; - return Ok(()); - } - // Insert the new node at the end of the deconstructed nodes - let mut deconstructed_nodes = self._deconstruct_nodes_along_path(parent_path.clone(), update_merkle_hashes)?; - deconstructed_nodes.push((node_to_insert_id, node_to_insert, node_to_insert_embedding)); - - // Update last written time for all nodes - for node in deconstructed_nodes.iter_mut() { - let (_, node, _) = node; - node.set_last_written(current_time); - } - - // Rebuild the nodes after inserting the new node - let (node_key, node, embedding) = - self._rebuild_deconstructed_nodes(deconstructed_nodes, update_merkle_hashes)?; - self.replace_node_dt_specified(node_key, node, embedding, Some(current_time), update_merkle_hashes)?; - Ok(()) - } - - /// Appends a node underneath the provided parent_path if the resource held there implements OrderedVectorResource trait. - /// If the parent_path is invalid at any part then method will error, and no changes will be applied to the VR. - fn append_node_at_path( - &mut self, - parent_path: VRPath, - new_node: Node, - new_embedding: Embedding, - update_merkle_hashes: bool, - ) -> Result<(), VRError> { - // If the path is root, then immediately insert into self at root path. - // This is required since retrieve_node_at_path() cannot retrieved self as a node and will error. - if parent_path.path_ids.len() == 0 { - let ord_resource = self.as_ordered_vector_resource()?; - return self.insert_node_at_path( - parent_path.clone(), - ord_resource.new_push_node_id(), - new_node, - new_embedding, - update_merkle_hashes, - ); - } else { - // Get the resource node at parent_path - let mut retrieved_node = self.retrieve_node_at_path(parent_path.clone(), None)?; - if let NodeContent::Resource(resource) = &mut retrieved_node.node.content { - let ord_resource = resource.as_ordered_vector_resource()?; - return self.insert_node_at_path( - parent_path.clone(), - ord_resource.new_push_node_id(), - new_node, - new_embedding, - update_merkle_hashes, - ); - } - Err(VRError::InvalidVRPath(parent_path.clone())) - } - } - - /// Pops a node underneath the provided parent_path if the resource held there implements OrderedVectorResource trait. - /// If the parent_path is invalid at any part, or is 0 length, then method will error, and no changes will be applied to the VR. - fn pop_node_at_path( - &mut self, - parent_path: VRPath, - update_merkle_hashes: bool, - ) -> Result<(Node, Embedding), VRError> { - // If the path is root, then immediately pop from self at root path to avoid error. - if parent_path.is_empty() { - let ord_resource = self.as_ordered_vector_resource_mut()?; - if let Some(last_node_id) = ord_resource.last_node_id() { - let node_path = parent_path.push_cloned(last_node_id); - self.remove_node_at_path(node_path, update_merkle_hashes) - } else { - Err(VRError::InvalidNodeId("Last node id not found".to_string())) - } - } else { - // Get the resource node at parent_path - let mut retrieved_node = self.retrieve_node_at_path(parent_path.clone(), None)?; - // Check if its a DocumentVectorResource - if let NodeContent::Resource(resource) = &mut retrieved_node.node.content { - let ord_resource = resource.as_ordered_vector_resource_mut()?; - - if let Some(last_node_id) = ord_resource.last_node_id() { - let node_path = parent_path.push_cloned(last_node_id); - self.remove_node_at_path(node_path.clone(), update_merkle_hashes) - } else { - Err(VRError::InvalidNodeId("Last node id not found".to_string())) - } - } else { - Err(VRError::InvalidVRPath(parent_path.clone())) - } - } - } - - /// Internal method. Given a path, pops out each node along the path in order - /// and returned as a list, including its original key and embedding. - fn _deconstruct_nodes_along_path( - &mut self, - path: VRPath, - update_merkle_hashes: bool, - ) -> Result, VRError> { - if path.path_ids.is_empty() { - return Err(VRError::InvalidVRPath(path.clone())); - } - - let first_node = self.get_root_node(path.path_ids[0].clone())?; - let first_embedding = self.get_root_embedding(path.path_ids[0].clone())?; - let mut deconstructed_nodes = vec![(path.path_ids[0].clone(), first_node, first_embedding)]; - - for id in path.path_ids.iter().skip(1) { - let last_mut = deconstructed_nodes - .last_mut() - .ok_or(VRError::InvalidVRPath(path.clone()))?; - let (_node_key, ref mut node, ref mut _embedding) = last_mut; - match &mut node.content { - NodeContent::Resource(resource) => { - let (removed_node, removed_embedding) = resource.as_trait_object_mut().remove_node_dt_specified( - id.to_string(), - None, - update_merkle_hashes, - )?; - deconstructed_nodes.push((id.clone(), removed_node, removed_embedding)); - } - _ => { - if id != path.path_ids.last().ok_or(VRError::InvalidVRPath(path.clone()))? { - return Err(VRError::InvalidVRPath(path.clone())); - } - } - } - } - - Ok(deconstructed_nodes) - } - - /// Internal method. Given a list of deconstructed_nodes, iterate backwards and rebuild them - /// into a single top-level node. - fn _rebuild_deconstructed_nodes( - &mut self, - mut deconstructed_nodes: Vec<(String, Node, Embedding)>, - update_merkle_hashes: bool, - ) -> Result<(String, Node, Embedding), VRError> { - let mut current_node = deconstructed_nodes.pop().ok_or(VRError::InvalidVRPath(VRPath::new()))?; - for (id, mut node, embedding) in deconstructed_nodes.into_iter().rev() { - if let NodeContent::Resource(resource) = &mut node.content { - // Preserve the last written datetime on the node assigned by prior functions - let current_node_last_written = current_node.1.last_written_datetime; - resource.as_trait_object_mut().insert_node_dt_specified( - current_node.0, - current_node.1, - current_node.2, - Some(current_node_last_written), - update_merkle_hashes, - )?; - current_node = (id, node, embedding); - } - } - Ok(current_node) - } - - /// Note: Intended for internal use only (used by VectorFS). - /// Sets the Merkle hash of a Resource node at the specified path. - /// Does not update any other merkle hashes, thus for internal use. - fn _set_resource_merkle_hash_at_path(&mut self, path: VRPath, merkle_hash: String) -> Result<(), VRError> { - self.mutate_node_at_path( - path, - &mut |node: &mut Node, _embedding: &mut Embedding| { - if let NodeContent::Resource(resource) = &mut node.content { - resource.as_trait_object_mut().set_merkle_root(merkle_hash.clone())?; - Ok(()) - } else { - Err(VRError::InvalidNodeType("Expected a folder node".to_string())) - } - }, - false, - ) - } - - /// Note: Intended for internal use only (used by VectorFS). - /// Updates the Merkle root of a Resource node at the specified path. - fn _update_resource_merkle_hash_at_path( - &mut self, - path: VRPath, - update_ancestor_merkle_hashes: bool, - ) -> Result<(), VRError> { - self.mutate_node_at_path( - path, - &mut |node: &mut Node, _embedding: &mut Embedding| { - if let NodeContent::Resource(resource) = &mut node.content { - resource.as_trait_object_mut().update_merkle_root()?; - Ok(()) - } else { - Err(VRError::InvalidNodeType( - "Cannot update merkle root of a non-Resource node".to_string(), - )) - } - }, - update_ancestor_merkle_hashes, - ) - } - - /// Attempts to return the DistributionInfo datetime, if not available, returns - /// the resource_last_written_datetime. - fn get_resource_datetime_default(&self) -> DateTime { - if let Some(datetime) = &self.distribution_info().datetime { - datetime.clone() - } else { - self.last_written_datetime() - } - } - - /// Attempts to return the DistributionInfo datetime, if not available, returns - /// the resource_created_datetime. - fn get_resource_datetime_default_created(&self) -> DateTime { - if let Some(datetime) = &self.distribution_info().datetime { - datetime.clone() - } else { - self.created_datetime() - } - } - - /// Retrieve all nodes in the Vector Resource with all hierarchy flattened. - /// If the resource is an OrderedVectorResource, the ordering is preserved. - fn get_all_nodes_flattened(&self) -> Vec { - self.get_all_nodes_embeddings_flattened() - .iter() - .map(|(node, _)| node.clone()) - .collect() - } - - /// Retrieve all embeddings in the Vector Resource with all hierarchy flattened. - /// If the resource is an OrderedVectorResource, the ordering is preserved. - fn get_all_embeddings_flattened(&self) -> Vec { - self.get_all_nodes_embeddings_flattened() - .iter() - .map(|(_, embedding)| embedding.clone()) - .collect() - } - - /// Retrieve all nodes and embeddings in the Vector Resource with all hierarchy flattened. - /// If the resource is an OrderedVectorResource, the ordering is preserved. - fn get_all_nodes_embeddings_flattened(&self) -> Vec<(Node, Embedding)> { - let mut result_nodes = vec![]; - - let mut root_nodes = self.get_root_nodes(); - for node in &mut root_nodes { - if let Ok(resource) = node.get_vector_resource_content_mut() { - // First remove the children nodes, and push the emptied resource node to results w/its embedding - let child_nodes_res = resource.as_trait_object_mut().remove_root_nodes(); - let embedding_res = self.get_root_embedding(node.id.clone()); - if let Ok(embedding) = embedding_res { - result_nodes.push((node.clone(), embedding)); - } - - // Then we iterate through the children and retrieve their nodes/embeddings - if let Ok(child_nodes) = child_nodes_res { - for (child_node, child_embedding) in child_nodes { - if let Ok(resource) = child_node.get_vector_resource_content() { - let child_ret_nodes = resource.as_trait_object().get_all_nodes_embeddings_flattened(); - result_nodes.extend(child_ret_nodes); - } else { - result_nodes.push((child_node.clone(), child_embedding.clone())); - } - } - } - } - // If its not a VR node - else { - let embedding_res = self.get_root_embedding(node.id.clone()); - if let Ok(embedding) = embedding_res { - result_nodes.push((node.clone(), embedding)); - } - } - } - - result_nodes - } - - /// Generates 2 RetrievedNodes which contain either the description + 2nd node, or the first two nodes if no description is available. - /// Sets their score to `1.0` with empty retrieval path & id. This is intended for job vector searches to prepend the intro text about relevant VRs. - /// Only works on OrderedVectorResources, errors otherwise. - fn generate_intro_ret_nodes(&self) -> Result, VRError> { - let self_header = self.generate_resource_header(); - let mut description_node = None; - - // Create the description RetrievedNode if description exists - if let Some(desc) = self.description() { - let node = Node::new_text("".to_string(), desc.to_string(), None, &vec![]); - description_node = Some(flatten_and_convert_into_intro_retrieved_node(node, &self_header)); - } - - if let Ok(ord_resource) = self.as_ordered_vector_resource() { - if let Some(second_node) = ord_resource.get_second_node() { - let second_node_ret = flatten_and_convert_into_intro_retrieved_node(second_node, &self_header); - if let Some(desc) = description_node.clone() { - return Ok(vec![desc, second_node_ret]); - } else { - if let Some(first_node) = ord_resource.get_first_node() { - let first_node_ret = flatten_and_convert_into_intro_retrieved_node(first_node, &self_header); - return Ok(vec![first_node_ret, second_node_ret]); - } - } - } - } else if let Some(node) = description_node { - return Ok(vec![node]); - } - return Err(VRError::InvalidNodeType( - "Expected an OrderedVectorResource or a description".to_string(), - )); - } -} - -/// Takes an intro node, flattens it if it holds a VR , and converts it into a RetrievedNode. -fn flatten_and_convert_into_intro_retrieved_node(intro_node: Node, header: &VRHeader) -> RetrievedNode { - let node_id = intro_node.id.clone(); - - if let NodeContent::Resource(resource) = &intro_node.content { - let mut flattened_node_text = resource.as_trait_object().name().to_string(); - for node in resource.as_trait_object().get_root_nodes() { - if flattened_node_text.len() > 500 { - break; - } - if let Ok(text) = node.get_text_content() { - flattened_node_text += " "; - flattened_node_text += text; - } - if let Ok(_) = node.get_vector_resource_content() { - flatten_and_convert_into_intro_retrieved_node(node, header); - } - } - - // Now create a new node with the flattened text - let mut new_node = intro_node.clone(); - new_node.content = NodeContent::Text(flattened_node_text); - - RetrievedNode::new(new_node, 1.0, header.clone(), VRPath::new().push_cloned(node_id)) - } else { - RetrievedNode::new(intro_node, 1.0, header.clone(), VRPath::new().push_cloned(node_id)) - } -} diff --git a/shinkai-libs/shinkai-vector-resources/src/vector_resource/vector_resource_extensions.rs b/shinkai-libs/shinkai-vector-resources/src/vector_resource/vector_resource_extensions.rs deleted file mode 100644 index 7b03e5d44..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/vector_resource/vector_resource_extensions.rs +++ /dev/null @@ -1,32 +0,0 @@ -use super::{Node, VectorResource}; -use crate::{embeddings::Embedding, resource_errors::VRError}; - -/// Trait extension which specific Vector Resource types implement that have a guaranteed internal ordering -/// of their nodes, such as DocumentVectorResources. This trait extension enables new -/// capabilities to be implemented, such as append/pop node interfaces, proximity searches, and more. -pub trait OrderedVectorResource: VectorResource { - /// Id of the first node held internally - fn first_node_id(&self) -> Option; - /// Id of the last node held internally - fn last_node_id(&self) -> Option; - /// Retrieve the first node held internally - fn get_first_node(&self) -> Option; - /// Retrieve the second node held internally - fn get_second_node(&self) -> Option; - /// Retrieve the third node held internally - fn get_third_node(&self) -> Option; - /// Retrieve the last node held internally - fn get_last_node(&self) -> Option; - /// Id to be used when pushing a new node - fn new_push_node_id(&self) -> String; - /// Takes the first N nodes held internally and returns them as references - fn take(&self, n: usize) -> Vec<&Node>; - /// Takes the first N nodes held internally and returns cloned copies of them - fn take_cloned(&self, n: usize) -> Vec; - /// Attempts to fetch a node (using the provided id) and proximity_window before/after, at root depth - fn get_node_and_embedding_proximity( - &self, - id: String, - proximity_window: u64, - ) -> Result, VRError>; -} diff --git a/shinkai-libs/shinkai-vector-resources/src/vector_resource/vector_resource_search.rs b/shinkai-libs/shinkai-vector-resources/src/vector_resource/vector_resource_search.rs deleted file mode 100644 index c8b355eec..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/vector_resource/vector_resource_search.rs +++ /dev/null @@ -1,986 +0,0 @@ -use super::VectorResourceCore; -#[cfg(feature = "desktop-only")] -use crate::embedding_generator::EmbeddingGenerator; -#[cfg(feature = "desktop-only")] -use crate::embedding_generator::RemoteEmbeddingGenerator; -use crate::embeddings::Embedding; -use crate::file_parser::file_parser::ShinkaiFileParser; -use crate::model_type::EmbeddingModelType; -use crate::resource_errors::VRError; -pub use crate::source::VRSourceReference; -pub use crate::vector_resource::vector_resource_types::*; -pub use crate::vector_resource::vector_search_traversal::*; -use async_trait::async_trait; -use rand::rngs::StdRng; -use rand::seq::IteratorRandom; -use rand::SeedableRng; -use std::collections::HashMap; -use std::vec; - -#[async_trait] -pub trait VectorResourceSearch: VectorResourceCore { - #[cfg(feature = "desktop-only")] - /// Fetches percent_to_verify (between 0.0 - 1.0) of random nodes from within the VectorResource - /// and validates that said node's included embeddings in the VectorResource are correct. - async fn verify_internal_embeddings_coherence( - &self, - generator: &dyn EmbeddingGenerator, - percent_to_verify: f32, - ) -> Result { - let all_nodes = self.retrieve_nodes_exhaustive_unordered(None); - let percent_to_verify = percent_to_verify.max(0.0).min(1.0); - let num_to_verify = (all_nodes.len() as f32 * percent_to_verify).ceil() as usize; - // Ensure at least one node is verified always - let num_to_verify = num_to_verify.max(1); - - // Filter out any non-text nodes, and randomly select from these nodes for the list of nodes to be verified - // TODO: Later on also allow VectorResource nodes, and re-generate the resource embedding + verify it. - let mut rng = StdRng::from_entropy(); - let nodes_to_verify: Vec<_> = all_nodes - .into_iter() - .filter(|node| matches!(node.node.content, NodeContent::Text(_))) - .choose_multiple(&mut rng, num_to_verify); - - for ret_node in nodes_to_verify { - let embedding = self.retrieve_embedding_at_path(ret_node.retrieval_path)?; - match ret_node.node.content { - NodeContent::Text(text) => { - let regenerated_embedding = generator.generate_embedding_default(&text).await?; - // We check if the score of the regenerated embedding is ever below 0.99 (some leeway in case some models are not 100% deterministic) - let score = embedding.cosine_similarity(®enerated_embedding) < 0.99; - if score { - return Ok(false); - } - } - _ => return Err(VRError::InvalidNodeType("Node must hold Text content".to_string())), - } - } - - Ok(true) - } - - /// Returns every single node at any depth in the whole Vector Resource, including the Vector Resources nodes themselves, - /// and the Nodes they hold additionally. If a starting_path is provided then fetches all nodes from there, - /// else starts at root. If resources_only is true, only Vector Resources are returned. - /// Of note: This method does not guarantee ordering of the nodes, no matter what kind of VR this is used on. - fn retrieve_nodes_exhaustive_unordered(&self, starting_path: Option) -> Vec { - let empty_embedding = Embedding::new_empty(); - self.vector_search_customized( - empty_embedding, - 0, - TraversalMethod::UnscoredAllNodes, - &vec![], - starting_path, - vec![], - ) - } - - /// Retrieves any resource nodes from the Vector Resource at any level of depth under starting path. - fn retrieve_resource_nodes_exhaustive(&self, starting_path: Option) -> Vec { - let mut nodes = self.retrieve_nodes_exhaustive_unordered(starting_path); - nodes.retain(|node| matches!(node.node.content, NodeContent::Resource(_))); - nodes - } - - /// Retrieves any text nodes from the Vector Resource at any level of depth under starting path. - fn retrieve_text_nodes_exhaustive(&self, starting_path: Option) -> Vec { - let mut nodes = self.retrieve_nodes_exhaustive_unordered(starting_path); - nodes.retain(|node| matches!(node.node.content, NodeContent::Text(_))); - nodes - } - - /// Retrieves any external content nodes from the Vector Resource at any level of depth under starting path. - fn retrieve_external_content_nodes_exhaustive(&self, starting_path: Option) -> Vec { - let mut nodes = self.retrieve_nodes_exhaustive_unordered(starting_path); - nodes.retain(|node| matches!(node.node.content, NodeContent::ExternalContent(_))); - nodes - } - - /// Retrieves any VRHeader nodes from the Vector Resource at any level of depth under starting path. - fn retrieve_vrheader_nodes_exhaustive(&self, starting_path: Option) -> Vec { - let mut nodes = self.retrieve_nodes_exhaustive_unordered(starting_path); - nodes.retain(|node| matches!(node.node.content, NodeContent::VRHeader(_))); - nodes - } - - /// Retrieves all nodes and their paths to easily/quickly examine a Vector Resource. - /// This is exhaustive and can begin from any starting_path. - /// `shorten_data` - Cuts the string content short to improve readability. - /// `resources_only` - Only prints Vector Resources - /// `add_merkle_hash` - Adds the merkle hash to each node - fn retrieve_all_nodes_contents_by_hierarchy( - &self, - starting_path: Option, - shorten_data: bool, - resources_only: bool, - add_merkle_hash: bool, - ) -> Vec { - let nodes = if resources_only { - self.retrieve_resource_nodes_exhaustive(starting_path) - } else { - self.retrieve_nodes_exhaustive_unordered(starting_path) - }; - - let mut result = Vec::new(); - - for node in nodes { - let ret_path = node.retrieval_path; - let _path = ret_path.format_to_string(); - let path_depth = ret_path.path_ids.len(); - let node_id = node.node.id.clone(); - let data = match &node.node.content { - NodeContent::Text(s) => { - if shorten_data && s.chars().count() > 25 { - format!("{} - {}", node_id, s.chars().take(25).collect::() + "...") - } else { - format!("{} - {}", node_id, s) - } - } - NodeContent::Resource(resource) => { - if path_depth == 1 { - eprintln!(" "); - } - // Decide what to print for start - format!( - "{} - {} - {} Nodes Held Inside", - node_id, - resource.as_trait_object().name(), - resource.as_trait_object().get_root_embeddings().len() - ) - } - NodeContent::ExternalContent(external_content) => { - format!("{} - {} ", node_id, external_content) - } - - NodeContent::VRHeader(header) => { - format!("{} - {} ", node_id, header.reference_string()) - } - }; - // Adding merkle hash if it exists to output string - let mut merkle_hash = String::new(); - if add_merkle_hash { - if let Ok(hash) = node.node.get_merkle_hash() { - if hash.chars().count() > 15 { - merkle_hash = hash.chars().take(15).collect::() + "..." - } else { - merkle_hash = hash.to_string() - } - } - } - - // Create indent string and do the final print - let indent_string = " ".repeat(path_depth * 2) + &">".repeat(path_depth); - if merkle_hash.is_empty() { - result.push(format!("{}{}", indent_string, data)); - } else { - result.push(format!("{}{} | Merkle Hash: {}", indent_string, data, merkle_hash)); - } - } - - result - } - - /// Prints all nodes and their paths to easily/quickly examine a Vector Resource. - /// This is exhaustive and can begin from any starting_path. - /// `shorten_data` - Cuts the string content short to improve readability. - /// `resources_only` - Only prints Vector Resources - fn print_all_nodes_exhaustive(&self, starting_path: Option, shorten_data: bool, resources_only: bool) { - let contents = self.retrieve_all_nodes_contents_by_hierarchy(starting_path, shorten_data, resources_only, true); - - for content in contents { - eprintln!("{}", content); - } - } - - #[cfg(feature = "desktop-only")] - /// Performs a dynamic vector search that returns the most similar nodes based on the input query String. - /// Dynamic Vector Searches support internal VectorResources with different Embedding models by automatically generating - /// the query Embedding from the input_query for each model. Dynamic Vector Searches are always Exhaustive. - async fn dynamic_vector_search( - &self, - input_query: String, - num_of_results: u64, - embedding_generator: RemoteEmbeddingGenerator, - vector_search_mode: Vec, - ) -> Result, VRError> { - self.dynamic_vector_search_customized( - input_query, - num_of_results, - &vec![TraversalOption::SetScoringMode(ScoringMode::HierarchicalAverageScoring)], - None, - embedding_generator, - vector_search_mode, - ) - .await - } - - #[cfg(feature = "desktop-only")] - /// Performs a dynamic vector search that returns the most similar nodes based on the input query String. - /// Dynamic Vector Searches support internal VectorResources with different Embedding models by automatically generating - /// the query Embedding from the input_query for each model. Dynamic Vector Searches are always Exhaustive. - /// NOTE: Not all traversal_options (ex. UntilDepth) will work with Dynamic Vector Searches. - async fn dynamic_vector_search_customized( - &self, - input_query: String, - num_of_results: u64, - traversal_options: &Vec, - starting_path: Option, - embedding_generator: RemoteEmbeddingGenerator, - vector_search_mode: Vec, - ) -> Result, VRError> { - // Setup the root VRHeader that will be attached to all RetrievedNodes - let root_vr_header = self.generate_resource_header(); - // We only traverse 1 level of depth at a time to be able to re-process the input_query as needed - let mut traversal_options = traversal_options.clone(); - traversal_options.retain(|option| !matches!(option, TraversalOption::UntilDepth(_))); - traversal_options.push(TraversalOption::UntilDepth(0)); - // Create a hash_map to save the embedding queries generated based on model type - let mut input_query_embeddings: HashMap = HashMap::new(); - - // If the embedding model is different then initialize a new generator & generate the embedding - let mut query_embedding = if self.embedding_model_used() != embedding_generator.model_type() { - let new_generator = self.initialize_compatible_embeddings_generator( - &embedding_generator.api_url, - embedding_generator.api_key.clone(), - ); - let query_embedding = new_generator.generate_embedding_default(&input_query).await?; - input_query_embeddings.insert(new_generator.model_type(), query_embedding.clone()); - query_embedding - } else { - let query_embedding = embedding_generator.generate_embedding_default(&input_query).await?; - input_query_embeddings.insert(embedding_generator.model_type(), query_embedding.clone()); - query_embedding - }; - - // Search the self Vector Resource - let mut latest_returned_results = self.vector_search_customized( - query_embedding, - num_of_results, - TraversalMethod::Exhaustive, - &traversal_options, - starting_path.clone(), - vector_search_mode.clone(), - ); - - // Keep looping until we go through all nodes in the Vector Resource while carrying forward the score weighting - // through the deeper levels of the Vector Resource - let mut node_results = vec![]; - while let Some(ret_node) = latest_returned_results.pop() { - match ret_node.node.content { - NodeContent::Resource(ref resource) => { - // Reuse a previously generated query embedding if matching is available - if let Some(embedding) = - input_query_embeddings.get(&resource.as_trait_object().embedding_model_used()) - { - query_embedding = embedding.clone(); - } - // If a new embedding model is found for this resource, then initialize a new generator & generate the embedding - else { - let new_generator = resource.as_trait_object().initialize_compatible_embeddings_generator( - &embedding_generator.api_url, - embedding_generator.api_key.clone(), - ); - query_embedding = new_generator.generate_embedding_default(&input_query).await?; - input_query_embeddings.insert(new_generator.model_type(), query_embedding.clone()); - } - - // Call vector_search() on the resource to get all the next depth Nodes from it - let new_results = resource.as_trait_object()._vector_search_customized_with_root_header( - query_embedding, - num_of_results, - TraversalMethod::Exhaustive, - &traversal_options, - starting_path.clone(), - Some(root_vr_header.clone()), - vector_search_mode.clone(), - ); - // Take into account current resource score, then push the new results to latest_returned_results to be further processed - if let Some(ScoringMode::HierarchicalAverageScoring) = - traversal_options.get_set_scoring_mode_option() - { - // Average resource's score into the retrieved results scores, then push them to latest_returned_results - for result in new_results { - let mut updated_result = result.clone(); - updated_result.score = - vec![updated_result.score, ret_node.score].iter().sum::() / 2 as f32; - latest_returned_results.push(updated_result) - } - } - } - _ => { - // For any non-Vector Resource nodes, simply push them into the results - node_results.push(ret_node); - } - } - } - - // Now that we have all of the node results, sort them efficiently and return the expected number of results - let final_results = RetrievedNode::sort_by_score(&node_results, num_of_results); - - Ok(final_results) - } - - /// Performs a vector search that returns the most similar nodes based on the query with - /// default traversal method/options. - fn vector_search(&self, query: Embedding, num_of_results: u64) -> Vec { - self.vector_search_customized( - query, - num_of_results, - TraversalMethod::Exhaustive, - &vec![TraversalOption::SetScoringMode(ScoringMode::HierarchicalAverageScoring)], - None, - vec![], - ) - } - - /// Performs a vector search that returns the most similar nodes based on the query. - /// The input traversal_method/options allows the developer to choose how the search moves through the levels. - /// The optional starting_path allows the developer to choose to start searching from a Vector Resource - /// held internally at a specific path. - fn vector_search_customized( - &self, - query: Embedding, - num_of_results: u64, - traversal_method: TraversalMethod, - traversal_options: &Vec, - starting_path: Option, - vector_search_mode: Vec, - ) -> Vec { - // Call the new method, passing None for the root_header parameter - let retrieved_nodes = self._vector_search_customized_with_root_header( - query, - num_of_results, - traversal_method, - traversal_options, - starting_path, - None, - vector_search_mode.clone(), - ); - - if let VRSourceReference::Standard(SourceReference::FileRef(file_ref)) = self.source() { - if let SourceFileType::Document(file_type) = file_ref.file_type { - if file_type == DocumentFileType::Csv - || file_type == DocumentFileType::Xlsx - || file_type == DocumentFileType::Xls - { - return self._merge_retrieved_nodes(retrieved_nodes); - } - - if file_type == DocumentFileType::Pdf && vector_search_mode.contains(&VectorSearchMode::MergeSiblings) { - return self - ._add_and_merge_node_siblings(&retrieved_nodes) - .unwrap_or(retrieved_nodes); - } - } - } - - retrieved_nodes - } - - /// Merges content of nodes to a single node. Used for data tables and merging sibling nodes vector search mode. - fn _merge_retrieved_nodes(&self, mut retrieved_nodes: Vec) -> Vec { - if retrieved_nodes.len() < 2 { - return retrieved_nodes; - } - - retrieved_nodes.sort_by(|a, b| { - a.node - .id - .parse::() - .unwrap_or_default() - .cmp(&b.node.id.parse::().unwrap_or_default()) - }); - - let first_node = retrieved_nodes.first().unwrap(); - let nodes = retrieved_nodes.iter().map(|node| &node.node).collect::>(); - - let node_id = nodes.first().and_then(|n| Some(n.id.clone())).unwrap_or_default(); - let mut merged_text = String::new(); - let mut merged_data_tags = Vec::new(); - let mut merged_metadata: Option> = None; - for node in nodes { - if let Ok(text) = node.get_text_content() { - merged_text += text; - merged_text += "\n"; - merged_data_tags.extend(node.data_tag_names.clone()); - - if let Some(metadata) = &node.metadata { - if merged_metadata.is_none() { - merged_metadata = Some(metadata.clone()); - } else { - let mut merged_metadata_unwrapped = merged_metadata.unwrap(); - for (key, value) in metadata { - merged_metadata_unwrapped - .entry(key.to_string()) - .or_insert(value.to_string()); - } - merged_metadata = Some(merged_metadata_unwrapped); - } - } - } - } - - if merged_text.is_empty() { - return retrieved_nodes; - } - - let merged_node = Node::from_node_content( - node_id, - NodeContent::Text(merged_text), - merged_metadata, - merged_data_tags, - ); - - vec![RetrievedNode { - node: merged_node, - score: retrieved_nodes - .iter() - .reduce(|a, b| if a.score > b.score { a } else { b }) - .unwrap() - .score, - resource_header: first_node.resource_header.clone(), - retrieval_path: first_node.retrieval_path.clone(), - }] - } - - /// Adds previous 3 and next 3 nodes to each found node and merges them together. - fn _add_and_merge_node_siblings( - &self, - retrieved_nodes: &Vec, - ) -> Result, VRError> { - let mut merged_nodes = Vec::new(); - let mut processed_ids = Vec::new(); - - let num_nodes = self.get_root_nodes_ref().len(); - - for node in retrieved_nodes.iter() { - let node_id = node - .node - .id - .parse::() - .map_err(|err| VRError::InvalidNodeId(err.to_string()))?; - let first_previous_id = node_id.checked_sub(4).unwrap_or(0) + 1; - let last_next_id = (node_id + 3).min(num_nodes as u64); - - if processed_ids.contains(&node_id) { - continue; - } - - let mut current_id = first_previous_id; - let mut node_siblings = Vec::new(); - - while current_id <= last_next_id { - let current_retrieved_node = if current_id == node_id { - node.clone() - } else { - let current_node = self.get_root_node(current_id.to_string())?; - - RetrievedNode { - node: current_node, - score: node.score, - resource_header: node.resource_header.clone(), - retrieval_path: node.retrieval_path.clone(), - } - }; - - if !processed_ids.contains(¤t_id) { - node_siblings.push(current_retrieved_node); - processed_ids.push(current_id); - } - - current_id += 1; - } - - let merged_node = self._merge_retrieved_nodes(node_siblings); - merged_nodes.extend(merged_node); - } - - Ok(merged_nodes) - } - - /// Vector search customized core logic, with ability to specify root_header - fn _vector_search_customized_with_root_header( - &self, - query: Embedding, - num_of_results: u64, - traversal_method: TraversalMethod, - traversal_options: &Vec, - starting_path: Option, - root_header: Option, - vector_search_mode: Vec, - ) -> Vec { - // Setup the root VRHeader that will be attached to all RetrievedNodes - let root_vr_header = root_header.unwrap_or_else(|| self.generate_resource_header()); - - // Only retrieve inner path if it exists and is not root - if let Some(path) = starting_path { - if path != VRPath::root() { - match self.retrieve_node_at_path(path.clone(), None) { - Ok(ret_node) => { - if let NodeContent::Resource(resource) = ret_node.node.content.clone() { - return resource.as_trait_object()._vector_search_customized_core( - query, - num_of_results, - traversal_method, - traversal_options, - vec![], - path, - root_vr_header.clone(), - vector_search_mode, - ); - } - } - Err(_) => {} - } - } - } - // Perform the vector search and continue forward - let mut results = self._vector_search_customized_core( - query.clone(), - num_of_results, - traversal_method.clone(), - traversal_options, - vec![], - VRPath::new(), - root_vr_header.clone(), - vector_search_mode, - ); - - // After getting all results from the vector search, perform final filtering - // Check if we need to cut results according to tolerance range - let tolerance_range_option = traversal_options.iter().find_map(|option| { - if let TraversalOption::ToleranceRangeResults(range) = option { - Some(*range) - } else { - None - } - }); - if let Some(tolerance_range) = tolerance_range_option { - results = self._tolerance_range_results(tolerance_range, &results); - } - - // Check if we need to cut results according to the minimum score - let min_score_option = traversal_options.iter().find_map(|option| { - if let TraversalOption::MinimumScore(score) = option { - Some(*score) - } else { - None - } - }); - if let Some(min_score) = min_score_option { - results = results - .into_iter() - .filter(|ret_node| ret_node.score >= min_score) - .collect(); - } - - // Check if we need to adjust based on the ResultsMode - if let Some(result_mode) = traversal_options.get_set_results_mode_option() { - let ResultsMode::ProximitySearch(proximity_window, num_of_top_results) = result_mode; - let mut paths_checked = HashMap::new(); - let mut new_results = Vec::new(); - let mut new_top_results_added = 0; - let mut iter = results.iter().cloned(); - - while new_top_results_added < num_of_top_results as usize { - if let Some(top_result) = iter.next() { - // Check if the node has already been included, then skip - if paths_checked.contains_key(&top_result.retrieval_path.clone()) { - continue; - } - - match self.proximity_retrieve_nodes_at_path( - top_result.retrieval_path.clone(), - proximity_window, - Some(query.clone()), - ) { - Ok(mut proximity_results) => { - let mut non_duplicates = vec![]; - let top_result_path = top_result.retrieval_path.clone(); - for proximity_result in &mut proximity_results { - // Replace the retrieved node with the actual top result node (to preserve results from other scoring logic, ie. hierarchical) - let mut proximity_result = if top_result_path == proximity_result.retrieval_path { - top_result.clone() - } else { - proximity_result.clone() - }; - - // Update the proximity result and push it into the list of non duplicate results - if !paths_checked.contains_key(&proximity_result.retrieval_path) { - proximity_result.resource_header = root_vr_header.clone(); - proximity_result.set_proximity_group_id(new_top_results_added.to_string()); - paths_checked.insert(proximity_result.retrieval_path.clone(), true); - non_duplicates.push(proximity_result.clone()); - } - } - - new_results.append(&mut non_duplicates); - new_top_results_added += 1; - } - Err(_) => new_results.push(top_result), // Keep the original result if proximity retrieval fails - } - } else { - // Break the loop if there are no more top results to process - break; - } - } - results = new_results; - } - - // Check if we are using traversal method unscored all nodes - if traversal_method != TraversalMethod::UnscoredAllNodes { - results.truncate(num_of_results as usize); - } - - results - } - - /// Internal method which is used to keep track of traversal info - #[allow(clippy::too_many_arguments)] - fn _vector_search_customized_core( - &self, - query: Embedding, - num_of_results: u64, - traversal_method: TraversalMethod, - traversal_options: &Vec, - hierarchical_scores: Vec, - traversal_path: VRPath, - root_vr_header: VRHeader, - vector_search_mode: Vec, - ) -> Vec { - // First we fetch the embeddings we want to score - let mut embeddings_to_score = vec![]; - // Check for syntactic search prefilter mode - let syntactic_search_option = traversal_options.iter().find_map(|option| match option { - TraversalOption::SetPrefilterMode(PrefilterMode::SyntacticVectorSearch(data_tags)) => { - Some(data_tags.clone()) - } - _ => None, - }); - if let Some(data_tag_names) = syntactic_search_option { - // If SyntacticVectorSearch is in traversal_options, fetch nodes with matching data tags - let ids = self._syntactic_search_id_fetch(&data_tag_names); - for id in ids { - if let Ok(embedding) = self.get_root_embedding(id) { - embeddings_to_score.push(embedding); - } - } - } else { - // If SyntacticVectorSearch is not in traversal_options, get all embeddings - embeddings_to_score = self.get_root_embeddings(); - } - - // Score embeddings based on traversal method - let mut score_num_of_results = num_of_results; - let scores = match traversal_method { - // Score all if exhaustive - TraversalMethod::Exhaustive => { - score_num_of_results = embeddings_to_score.len() as u64; - query.score_similarities(&embeddings_to_score, score_num_of_results) - } - // Fake score all as 0 if unscored exhaustive - TraversalMethod::UnscoredAllNodes => embeddings_to_score - .iter() - .map(|embedding| (0.0, embedding.id.clone())) - .collect(), - // Else score as normal - _ => query.score_similarities(&embeddings_to_score, score_num_of_results), - }; - - self._order_vector_search_results( - scores, - query, - num_of_results, - traversal_method, - traversal_options, - hierarchical_scores, - traversal_path, - root_vr_header, - vector_search_mode, - ) - } - - /// Internal method that orders all scores, and importantly traverses into any nodes holding further BaseVectorResources. - #[allow(clippy::too_many_arguments)] - fn _order_vector_search_results( - &self, - scores: Vec<(f32, String)>, - query: Embedding, - num_of_results: u64, - traversal_method: TraversalMethod, - traversal_options: &Vec, - hierarchical_scores: Vec, - traversal_path: VRPath, - root_vr_header: VRHeader, - vector_search_mode: Vec, - ) -> Vec { - let mut current_level_results: Vec = vec![]; - let mut vector_resource_count = 0; - let query = query.clone(); - - for (score, id) in scores { - let mut skip_traversing_deeper = false; - if let Ok(node) = self.get_root_node(id.clone()) { - // Perform validations based on Filter Mode - let filter_mode = traversal_options.get_set_filter_mode_option(); - if let Some(FilterMode::ContainsAnyMetadataKeyValues(kv_pairs)) = filter_mode.clone() { - if !FilterMode::node_metadata_any_check(&node, &kv_pairs) { - continue; - } - } - if let Some(FilterMode::ContainsAllMetadataKeyValues(kv_pairs)) = filter_mode { - if !FilterMode::node_metadata_all_check(&node, &kv_pairs) { - continue; - } - } - // Perform validations related to node content type - if let NodeContent::Resource(node_resource) = node.content.clone() { - // Keep track for later sorting efficiency - vector_resource_count += 1; - - // If traversal option includes UntilDepth and we've reached the right level - // Don't recurse any deeper, just return current Node with BaseVectorResource - if let Some(d) = traversal_options.get_until_depth_option() { - if d == traversal_path.depth_inclusive() { - let ret_node = RetrievedNode { - node: node.clone(), - score, - resource_header: root_vr_header.clone(), - retrieval_path: traversal_path.clone(), - }; - current_level_results.push(ret_node); - skip_traversing_deeper = true; - } - } - - // If node Resource does not have same base type as LimitTraversalToType then - // then skip going deeper into it - if let Some(base_type) = traversal_options.get_limit_traversal_to_type_option() { - if &node_resource.resource_base_type() != base_type { - skip_traversing_deeper = true; - } - } - - // If node does not pass the validation check then skip going deeper into it - if let Some((validation_func, hash_map)) = - traversal_options.get_limit_traversal_by_validation_with_map_option() - { - let node_path = traversal_path.push_cloned(id.clone()); - if !validation_func(&node, &node_path, hash_map) { - skip_traversing_deeper = true; - } - } - } - if skip_traversing_deeper { - continue; - } - - let results = self._recursive_data_extraction( - node.clone(), - score, - query.clone(), - num_of_results, - traversal_method.clone(), - traversal_options, - hierarchical_scores.clone(), - traversal_path.clone(), - root_vr_header.clone(), - vector_search_mode.clone(), - ); - current_level_results.extend(results); - } - } - - if vector_search_mode.contains(&VectorSearchMode::FillUpTo25k) { - self._prioritize_document_first_page(&mut current_level_results); - } - - // If at least one vector resource exists in the Nodes then re-sort - // after fetching deeper level results to ensure ordering is correct - if vector_resource_count >= 1 && traversal_method != TraversalMethod::UnscoredAllNodes { - return RetrievedNode::sort_by_score(¤t_level_results, num_of_results); - } - // Otherwise just return 1st level results - current_level_results - } - - /// Internal method for recursing into deeper levels of Vector Resources - #[allow(clippy::too_many_arguments)] - fn _recursive_data_extraction( - &self, - node: Node, - score: f32, - query: Embedding, - num_of_results: u64, - traversal_method: TraversalMethod, - traversal_options: &Vec, - hierarchical_scores: Vec, - traversal_path: VRPath, - root_vr_header: VRHeader, - vector_search_mode: Vec, - ) -> Vec { - let mut current_level_results: Vec = vec![]; - // Concat the current score into a new hierarchical scores Vec before moving forward - let mut new_hierarchical_scores = [&hierarchical_scores[..], &[score]].concat(); - // Create a new traversal path with the node id - let new_traversal_path = traversal_path.push_cloned(node.id.clone()); - - match &node.content { - NodeContent::Resource(resource) => { - // If no data tag names provided, it means we are doing a normal vector search - let sub_results = resource.as_trait_object()._vector_search_customized_core( - query.clone(), - num_of_results, - traversal_method.clone(), - traversal_options, - new_hierarchical_scores, - new_traversal_path.clone(), - root_vr_header.clone(), - vector_search_mode.clone(), - ); - - // If traversing with UnscoredAllNodes, include the Vector Resource - // nodes as well in the results, prepended before their nodes - // held inside - if traversal_method == TraversalMethod::UnscoredAllNodes { - current_level_results.push(RetrievedNode { - node: node.clone(), - score, - resource_header: root_vr_header.clone(), - retrieval_path: new_traversal_path, - }); - } - - current_level_results.extend(sub_results); - } - // If it's not a resource, it's a node which we need to return - _ => { - let mut score = score; - for option in traversal_options { - if let TraversalOption::SetScoringMode(ScoringMode::HierarchicalAverageScoring) = option { - // Perform score "averaging" here. We go with a simple additional approach rather than actual average, so that low/many hierarchy scores does not kill an actually valuable node - if let Some(current_score) = new_hierarchical_scores.pop() { - let hierarchical_count = new_hierarchical_scores.len(); - let hierarchical_sum = new_hierarchical_scores.iter().sum::(); - if hierarchical_count > 0 && hierarchical_sum > 0.0 { - let hierarchical_weight = 0.2; - let current_score_weight = 1.0 - hierarchical_weight; - let hierarchical_score = - (hierarchical_sum / hierarchical_count as f32) * hierarchical_weight; - score = (current_score * current_score_weight) + hierarchical_score; - } - } - break; - } - } - current_level_results.push(RetrievedNode { - node: node.clone(), - score, - resource_header: root_vr_header.clone(), - retrieval_path: new_traversal_path, - }); - } - } - current_level_results - } - - /// Ease-of-use function for performing a syntactic vector search. Uses exhaustive traversal and hierarchical average scoring. - /// A syntactic vector search efficiently pre-filters all Nodes held internally to a subset that matches the provided list of data tag names. - fn syntactic_vector_search( - &self, - query: Embedding, - num_of_results: u64, - data_tag_names: &[String], - ) -> Vec { - self.vector_search_customized( - query, - num_of_results, - TraversalMethod::Exhaustive, - &vec![ - TraversalOption::SetScoringMode(ScoringMode::HierarchicalAverageScoring), - TraversalOption::SetPrefilterMode(PrefilterMode::SyntacticVectorSearch(data_tag_names.to_owned())), - ], - None, - vec![], - ) - } - - /// Returns the most similar nodes within a specific range of the provided top similarity score. - fn _tolerance_range_results(&self, tolerance_range: f32, results: &Vec) -> Vec { - // Calculate the top similarity score - let top_similarity_score = results.first().map_or(0.0, |ret_node| ret_node.score); - - // Clamp the tolerance_range to be between 0 and 1 - let tolerance_range = tolerance_range.max(0.0).min(1.0); - - // Calculate the range of acceptable similarity scores - let lower_bound = top_similarity_score * (1.0 - tolerance_range); - - // Filter the results to only include those within the range of the top similarity score - let mut filtered_results = Vec::new(); - for ret_node in results { - if ret_node.score >= lower_bound && ret_node.score <= top_similarity_score { - filtered_results.push(ret_node.clone()); - } - } - - filtered_results - } - - /// Internal method to fetch all node ids for syntactic searches - fn _syntactic_search_id_fetch(&self, data_tag_names: &Vec) -> Vec { - let mut ids = vec![]; - for name in data_tag_names { - if let Some(node_ids) = self.data_tag_index().get_node_ids(&name) { - ids.extend(node_ids.iter().map(|id| id.to_string())); - } - } - ids - } - - /// Prioritize the first page of a PDF document and fill up the rest of the results with the remaining nodes. - fn _prioritize_document_first_page(&self, nodes: &mut Vec) { - for node in nodes { - if let VRSourceReference::Standard(SourceReference::FileRef(file_ref)) = - &node.resource_header.resource_source - { - if let SourceFileType::Document(file_type) = &file_ref.file_type { - if *file_type == DocumentFileType::Pdf { - if let Some(metadata) = &node.node.metadata { - if let Some(pg_nums) = metadata.get(&ShinkaiFileParser::page_numbers_metadata_key()) { - let pg_nums = pg_nums - .trim_matches(|c| c == '[' || c == ']') - .split(",") - .collect::>(); - let has_first_page = pg_nums.contains(&"1"); - - if has_first_page { - node.score = 1.0; - } - } - } - } - } - } - } - } -} - -/// Function used by deep searches to "average" out the scores of the retrieved nodes -/// with the top level search score from the VRs themselves. -/// Uses the input strings for more advanced detection for how much to weigh the VR score vs the node score. -pub fn deep_search_scores_average_out( - _query_text: Option, - vr_score: f32, - _vr_description: String, - node_score: f32, - _node_content: String, -) -> f32 { - // TODO: Later on do keyword extraction on query_text, and if the description or node content has any of the top 3, increase weighting accordingly - // This might be too intensive to run rake on all results, so re-think this over later/test it. - - // Go with a simple additional approach rather than actual average, so that low vr_scores never decrease actual node scores - let vr_weight = 0.2; - let adjusted_vr_score = (vr_score * vr_weight).min(0.2); - node_score + adjusted_vr_score // final score -} diff --git a/shinkai-libs/shinkai-vector-resources/src/vector_resource/vector_resource_types.rs b/shinkai-libs/shinkai-vector-resources/src/vector_resource/vector_resource_types.rs deleted file mode 100644 index 7c0ca4610..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/vector_resource/vector_resource_types.rs +++ /dev/null @@ -1,1198 +0,0 @@ -use crate::embedding_generator::EmbeddingGenerator; -use crate::embeddings::Embedding; -use crate::file_parser::file_parser::ShinkaiFileParser; -use crate::model_type::EmbeddingModelType; -use crate::resource_errors::VRError; -use crate::shinkai_time::ShinkaiTime; -use crate::source::DistributionInfo; -pub use crate::source::{ - DocumentFileType, ImageFileType, SourceFileReference, SourceFileType, SourceReference, VRSourceReference, -}; -use crate::utils::count_tokens_from_message_llama3; -use crate::vector_resource::base_vector_resources::{BaseVectorResource, VRBaseType}; -use blake3::hash; -use chrono::{DateTime, Utc}; -use ordered_float::NotNan; -use rand::rngs::StdRng; -use rand::seq::SliceRandom; -use rand::SeedableRng; -use serde::{Deserialize, Deserializer}; -use serde::{Serialize, Serializer}; -use std::collections::HashMap; -use std::fmt; -use std::hash::{Hash, Hasher}; -use utoipa::ToSchema; - -/// A node that was retrieved from inside of a Vector Resource. Includes extra data like the retrieval path -/// and the similarity score from the vector search. The resource_header is the VRHeader from the root -/// Vector Resource the RetrievedNode is from. -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] -pub struct RetrievedNode { - pub node: Node, - pub score: f32, - pub resource_header: VRHeader, - pub retrieval_path: VRPath, -} - -impl RetrievedNode { - /// Create a new RetrievedNode - pub fn new(node: Node, score: f32, resource_header: VRHeader, retrieval_path: VRPath) -> Self { - Self { - node, - score, - resource_header, - retrieval_path, - } - } - - /// Sorts the list of RetrievedNodes based on their scores. - /// Uses a binary heap for efficiency, returns num_results of highest scored. - pub fn sort_by_score(retrieved_data: &Vec, num_results: u64) -> Vec { - // Create a HashMap to store the RetrievedNode instances for post-scoring retrieval - let mut nodes: HashMap = HashMap::new(); - - // Map the retrieved_data to a vector of tuples (NotNan, id_ref_key) - // We create id_ref_key to support sorting RetrievedNodes from - // different Resources together and avoid node id collision problems. - let scores: Vec<(NotNan, String)> = retrieved_data - .into_iter() - .map(|node| { - let _hash = node.node.get_merkle_hash().unwrap_or_default(); - let id_ref_key = node.generate_globally_unique_node_id(); - nodes.insert(id_ref_key.clone(), node.clone()); - (NotNan::new(nodes[&id_ref_key].score).unwrap(), id_ref_key) - }) - .collect(); - - // Use the bin_heap_order_scores function to sort the scores - let sorted_scores = Embedding::bin_heap_order_scores(scores, num_results as usize); - - // Map the sorted_scores back to a vector of RetrievedNode - let sorted_data: Vec = sorted_scores - .into_iter() - .map(|(_, id_ref_key)| nodes[&id_ref_key].clone()) - .collect(); - - sorted_data - } - - /// Sorts groups of RetrievedNodes based on the highest score within each group. - /// Returns the groups sorted by the highest score in each group. - pub fn sort_by_score_groups( - retrieved_node_groups: &Vec>, - num_results: u64, - ) -> Vec> { - let mut highest_score_nodes: Vec = Vec::new(); - let mut group_map: HashMap> = HashMap::new(); - - // Iterate over each group, find the node with the highest score, and store it along with the group - for group in retrieved_node_groups { - if let Some(highest_node) = group - .iter() - .max_by(|a, b| a.score.partial_cmp(&b.score).unwrap_or(std::cmp::Ordering::Equal)) - { - let highest_node_clone = highest_node.clone(); - let id_ref_key = highest_node.generate_globally_unique_node_id(); - highest_score_nodes.push(highest_node_clone); - group_map.insert(id_ref_key, group.clone()); - } - } - - // Sort the highest scoring nodes from each group - let sorted_highest_nodes = Self::sort_by_score(&highest_score_nodes, num_results); - - // Fetch each group in the order determined by the sorted highest scoring nodes - let sorted_groups: Vec> = sorted_highest_nodes - .into_iter() - .filter_map(|node| { - let id_ref_key = node.generate_globally_unique_node_id(); - group_map.remove(&id_ref_key) - }) - .collect(); - - sorted_groups - } - - /// Generates a unique identifier (across VRs) for the RetrievedNode based on its content and metadata. - /// This id includes merkle hash, retrieval path, last written datetime, score, and resource id. - pub fn generate_globally_unique_node_id(&self) -> String { - let hash = self.node.get_merkle_hash().unwrap_or_default(); - format!( - "{}-{}-{}-{}-{}", - hash, - self.retrieval_path, - self.node.last_written_datetime.to_rfc3339(), - self.score, - self.resource_header.resource_id, - ) - } - - /// Formats the retrieval path to a string, adding a trailing `/` - /// if the node at the path is a Vector Resource - pub fn format_path_to_string(&self) -> String { - let mut path_string = self.retrieval_path.format_to_string(); - if let NodeContent::Resource(_) = self.node.content { - path_string.push('/'); - } - path_string - } - - /// Formats the data, source, and metadata of all provided `RetrievedNode`s into a bullet-point - /// list as a single string. This is to be included inside of a prompt to an LLM. - /// Includes `max_characters` to allow specifying a hard-cap maximum that will be respected. - pub fn format_ret_nodes_for_prompt_single_string(ret_nodes: Vec, max_characters: usize) -> String { - if ret_nodes.is_empty() { - return String::new(); - } - - let mut result = String::new(); - let mut remaining_chars = max_characters; - - for ret_node in ret_nodes { - if let Some(formatted_node) = ret_node.format_for_prompt(remaining_chars) { - if formatted_node.len() > remaining_chars { - break; - } - result.push_str(&formatted_node); - result.push_str("\n\n "); - remaining_chars -= formatted_node.len(); - } - } - - result - } - - /// Fetches the node's datetime by first checking node metadata, then if none available, returns None. - pub fn get_datetime_default(&self) -> Option> { - self.node.get_metadata_datetime() - } - - /// Fetches the node's datetime by first checking node metadata, then if none available, returns None. - /// Returns a string in RFC3339 format without the fractional seconds if datetime is available. - pub fn get_datetime_default_string(&self) -> Option { - self.get_datetime_default() - .map(|dt| dt.to_rfc3339().split('.').next().unwrap_or("").to_string()) - } - - /// Formats the data, source, and metadata together into a single string that is ready - /// to be included as part of a prompt to an LLM. - /// Includes `max_characters` to allow specifying a hard-cap maximum that will be respected. - pub fn format_for_prompt(&self, max_characters: usize) -> Option { - let source_string = self.resource_header.resource_source.format_source_string(); - let position_string = self.format_position_string(); - let datetime_string = self.get_datetime_default_string(); - - // If the text is too long, cut it - let mut data_string = self.node.get_text_content().ok()?.to_string(); - if data_string.len() > max_characters { - let amount_over = data_string.len() - max_characters; - let amount_to_add = source_string.len() - + position_string.len() - + datetime_string.as_ref().map_or(0, |s| s.len()) - + amount_over; - let amount_to_cut = amount_over + amount_to_add + 25; - data_string = data_string.chars().take(amount_to_cut).collect::(); - } - - let formatted_string = if position_string.len() > 0 { - if let Some(datetime_string) = datetime_string { - format!( - "- {} (Source: {}, {}) {}", - data_string, source_string, position_string, datetime_string - ) - } else { - format!("- {} (Source: {}, {})", data_string, source_string, position_string) - } - } else { - if let Some(datetime_string) = datetime_string { - format!("- {} (Source: {}) {}", data_string, source_string, datetime_string) - } else { - format!("- {} (Source: {})", data_string, source_string) - } - }; - - Some(formatted_string) - } - - /// Parses node position in the content using metadata/retrieved node data. - pub fn format_position_string(&self) -> String { - if let Some(metadata) = &self.node.metadata { - if let Some(page_numbers) = metadata.get(&ShinkaiFileParser::page_numbers_metadata_key()) { - if !page_numbers.is_empty() { - let page_label = if page_numbers.contains(',') { "Pages" } else { "Page" }; - return format!("{}: {}", page_label, page_numbers); - } - } - } - - // Cut up the retrieval path into shortened strings - let section_strings = self - .retrieval_path - .path_ids - .iter() - .map(|id| { - let mut shortened_id = id.to_string(); - if shortened_id.len() > 20 { - let mut char_iter = shortened_id.chars(); - shortened_id = char_iter.by_ref().take(20).collect::(); - // shortened_id.push_str("..."); - } - shortened_id - }) - .collect::>(); - - // Create a relative position based on parents node ids - let final_section_string = if section_strings.len() > 3 { - format!( - ".../{}", - section_strings - .iter() - .skip(section_strings.len() - 3) - .map(|s| s.as_str()) - .collect::>() - .join("/") - ) - } else { - section_strings.join("/") - }; - - format!("Section: {}", final_section_string) - } - - /// Sets the proximity_group_id in the node's metadata. - pub fn set_proximity_group_id(&mut self, proximity_group_id: String) { - let metadata = self.node.metadata.get_or_insert_with(HashMap::new); - metadata.insert("proximity_group_id".to_string(), proximity_group_id); - } - - /// Gets the proximity_group_id from the node's metadata if it exists. - pub fn get_proximity_group_id(&self) -> Option<&String> { - self.node.metadata.as_ref()?.get("proximity_group_id") - } - - /// Removes the proximity_group_id from the node's metadata if it exists. - pub fn remove_proximity_group_id(&mut self) { - if let Some(metadata) = &mut self.node.metadata { - metadata.remove("proximity_group_id"); - if metadata.is_empty() { - self.node.metadata = None; - } - } - } - - /// Groups the given RetrievedNodes by their proximity_group_id. - /// Can only be used with nodes returned using `ResultsMode::ProximitySearch`, else errors. - pub fn group_proximity_results(nodes: &Vec) -> Result>, VRError> { - let mut grouped_results: Vec> = Vec::new(); - let mut current_group: Vec = Vec::new(); - let mut current_group_id: Option = None; - - for node in nodes { - match node.get_proximity_group_id() { - Some(group_id) => { - if current_group_id.as_ref() == Some(group_id) { - // Current node belongs to the current group - current_group.push(node.clone()); - } else { - // Current node starts a new group - if !current_group.is_empty() { - grouped_results.push(current_group); - current_group = Vec::new(); - } - current_group.push(node.clone()); - current_group_id = Some(group_id.clone()); - } - } - None => { - // If the node does not have a proximity_group_id, return an error - return Err(VRError::ResourceDoesNotSupportOrderedOperations( - node.resource_header.reference_string(), - )); - } - } - } - - // Add the last group if it's not empty - if !current_group.is_empty() { - grouped_results.push(current_group); - } - - Ok(grouped_results) - } - - // Normalizes the scores of the retrieved nodes based on the embedding normalization factor. - // Used during vector search to support different embedding models. - pub fn normalize_scores(nodes: &mut Vec) { - // Skip normalization if every model is the same - let first_node = nodes.first(); - if let Some(first_node) = first_node { - let model = &first_node.resource_header.resource_embedding_model_used; - - if nodes - .iter() - .all(|node| node.resource_header.resource_embedding_model_used == *model) - { - return; - } - } - - for node in nodes { - let factor = node - .resource_header - .resource_embedding_model_used - .embedding_normalization_factor(); - - node.score = node.score * factor; - } - } -} - -/// Represents a Vector Resource Node which holds a unique id, one of the types of NodeContent, -/// metadata, and other internal relevant data. -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, ToSchema)] -pub struct Node { - pub id: String, - pub content: NodeContent, - pub metadata: Option>, - pub data_tag_names: Vec, - #[schema(value_type = String, format = Date)] - pub last_written_datetime: DateTime, - pub merkle_hash: Option, -} - -impl Node { - /// Create a new text-holding Node with a provided String id - pub fn new_text( - id: String, - text: String, - metadata: Option>, - data_tag_names: &Vec, - ) -> Self { - let current_time = ShinkaiTime::generate_time_now(); - - let node = Self { - id, - content: NodeContent::Text(text.to_string()), - metadata, - data_tag_names: data_tag_names.clone(), - last_written_datetime: current_time, - merkle_hash: None, - }; - let _ = node._generate_merkle_hash(); - node - } - - /// Create a new text-holding Node with a provided u64 id, which gets converted to string internally - pub fn new_text_with_integer_id( - id: u64, - text: String, - metadata: Option>, - data_tag_names: &Vec, - ) -> Self { - Self::new_text(id.to_string(), text, metadata, data_tag_names) - } - - /// Create a new BaseVectorResource-holding Node with a provided String id - pub fn new_vector_resource( - id: String, - vector_resource: &BaseVectorResource, - metadata: Option>, - ) -> Self { - let current_time = ShinkaiTime::generate_time_now(); - let node = Node { - id: id, - content: NodeContent::Resource(vector_resource.clone()), - metadata: metadata, - data_tag_names: vector_resource.as_trait_object().data_tag_index().data_tag_names(), - last_written_datetime: current_time, - merkle_hash: None, - }; - - let _ = node._generate_merkle_hash(); - node - } - - /// Create a new BaseVectorResource-holding Node with a provided u64 id, which gets converted to string internally - pub fn new_vector_resource_with_integer_id( - id: u64, - vector_resource: &BaseVectorResource, - metadata: Option>, - ) -> Self { - Self::new_vector_resource(id.to_string(), vector_resource, metadata) - } - - /// Create a new ExternalContent-holding Node with a provided String id - pub fn new_external_content( - id: String, - external_content: &SourceReference, - metadata: Option>, - ) -> Self { - let current_time = ShinkaiTime::generate_time_now(); - let node = Node { - id, - content: NodeContent::ExternalContent(external_content.clone()), - metadata, - data_tag_names: vec![], - last_written_datetime: current_time, - merkle_hash: None, - }; - - let _ = node._generate_merkle_hash(); - node - } - - /// Create a new ExternalContent-holding Node with a provided u64 id, which gets converted to string internally - pub fn new_external_content_with_integer_id( - id: u64, - external_content: &SourceReference, - metadata: Option>, - ) -> Self { - Self::new_external_content(id.to_string(), external_content, metadata) - } - - /// Create a new VRHeader-holding Node with a provided String id - pub fn new_vr_header( - id: String, - vr_header: &VRHeader, - metadata: Option>, - data_tag_names: &Vec, - ) -> Self { - let current_time = ShinkaiTime::generate_time_now(); - - let node = Self { - id, - content: NodeContent::VRHeader(vr_header.clone()), - metadata, - data_tag_names: data_tag_names.clone(), - last_written_datetime: current_time, - merkle_hash: None, - }; - - let _ = node._generate_merkle_hash(); - node - } - - /// Create a new VRHeader-holding Node with a provided u64 id, which gets converted to string internally - pub fn new_vr_header_with_integer_id( - id: u64, - vr_header: &VRHeader, - metadata: Option>, - data_tag_names: &Vec, - ) -> Self { - Self::new_vr_header(id.to_string(), vr_header, metadata, data_tag_names) - } - - /// Creates a new Node using provided content with a String id. - pub fn from_node_content( - id: String, - content: NodeContent, - metadata: Option>, - data_tag_names: Vec, - ) -> Self { - let current_time = ShinkaiTime::generate_time_now(); - let node = Self { - id, - content, - metadata, - data_tag_names, - last_written_datetime: current_time, - merkle_hash: None, - }; - - let _ = node._generate_merkle_hash(); - node - } - - /// Creates a new Node using provided content with a u64 id - pub fn from_node_content_with_integer_id( - id: u64, - content: NodeContent, - metadata: Option>, - data_tag_names: Vec, - ) -> Self { - Self::from_node_content(id.to_string(), content, metadata, data_tag_names) - } - - /// Updates the last_written_datetime to the provided datetime - pub fn set_last_written(&mut self, datetime: DateTime) { - self.last_written_datetime = datetime; - } - - /// Updates the last_written_datetime to the current time - pub fn update_last_written_to_now(&mut self) { - let current_time = ShinkaiTime::generate_time_now(); - self.set_last_written(current_time); - } - - /// Attempts to return a reference to the text content from the Node. Errors if is different type - pub fn get_text_content(&self) -> Result<&str, VRError> { - match &self.content { - NodeContent::Text(s) => Ok(s), - _ => Err(VRError::ContentIsNonMatchingType), - } - } - - /// Attempts to return a reference to the BaseVectorResource from the Node. Errors if is different type - pub fn get_vector_resource_content(&self) -> Result<&BaseVectorResource, VRError> { - match &self.content { - NodeContent::Resource(resource) => Ok(resource), - _ => Err(VRError::ContentIsNonMatchingType), - } - } - - /// Attempts to return a reference to the ExternalContent from the Node. Errors if content is not ExternalContent - pub fn get_external_content(&self) -> Result<&SourceReference, VRError> { - match &self.content { - NodeContent::ExternalContent(external_content) => Ok(external_content), - _ => Err(VRError::ContentIsNonMatchingType), - } - } - - /// Attempts to return a reference to the VRHeader from the Node. Errors if content is not VRHeader - pub fn get_vr_header_content(&self) -> Result<&VRHeader, VRError> { - match &self.content { - NodeContent::VRHeader(vr_header) => Ok(vr_header), - _ => Err(VRError::ContentIsNonMatchingType), - } - } - - /// Attempts to return a mutable reference to the text content from the Node. Errors if is different type - pub fn get_text_content_mut(&mut self) -> Result<&mut String, VRError> { - match &mut self.content { - NodeContent::Text(s) => Ok(s), - _ => Err(VRError::ContentIsNonMatchingType), - } - } - - /// Attempts to return a mutable reference to the BaseVectorResource from the Node. Errors if is different type - pub fn get_vector_resource_content_mut(&mut self) -> Result<&mut BaseVectorResource, VRError> { - match &mut self.content { - NodeContent::Resource(resource) => Ok(resource), - _ => Err(VRError::ContentIsNonMatchingType), - } - } - - /// Attempts to return a mutable reference to the ExternalContent from the Node. Errors if content is not ExternalContent - pub fn get_external_content_mut(&mut self) -> Result<&mut SourceReference, VRError> { - match &mut self.content { - NodeContent::ExternalContent(external_content) => Ok(external_content), - _ => Err(VRError::ContentIsNonMatchingType), - } - } - - /// Attempts to return a mutable reference to the VRHeader from the Node. Errors if content is not VRHeader - pub fn get_vr_header_content_mut(&mut self) -> Result<&mut VRHeader, VRError> { - match &mut self.content { - NodeContent::VRHeader(vr_header) => Ok(vr_header), - _ => Err(VRError::ContentIsNonMatchingType), - } - } - - /// Returns the keys of all kv pairs in the Node's metadata field, - /// and all metadata keys of internal nodes for Vector Resources and VRHeaders. - /// None if no keys exist. - pub fn metadata_keys(&self) -> Option> { - let mut keys = self - .metadata - .as_ref() - .map(|metadata| metadata.keys().cloned().collect::>()) - .unwrap_or_else(Vec::new); - - if let NodeContent::Resource(resource) = &self.content { - let internal_keys = resource.as_trait_object().metadata_index().get_all_metadata_keys(); - keys.extend(internal_keys); - } else if let NodeContent::VRHeader(header) = &self.content { - keys.extend(header.metadata_index_keys.clone()); - } - - if keys.is_empty() { - None - } else { - Some(keys) - } - } - - /// Gets the Merkle hash of the Node. - /// For VRHeader/Vector Resource nodes, uses the resource merkle_root. - pub fn get_merkle_hash(&self) -> Result { - match &self.content { - NodeContent::VRHeader(header) => header - .resource_merkle_root - .clone() - .ok_or(VRError::MerkleRootNotFound(header.reference_string())), - NodeContent::Resource(resource) => resource.as_trait_object().get_merkle_root(), - _ => self - .merkle_hash - .clone() - .ok_or(VRError::MerkleHashNotFoundInNode(self.id.clone())), - } - } - - /// Updates the Merkle hash of the Node using its current content. - /// This should be called whenever content in the Node is updated internally. - pub fn update_merkle_hash(&mut self) -> Result<(), VRError> { - match &mut self.content { - NodeContent::Resource(resource) => resource.as_trait_object_mut().update_merkle_root(), - _ => { - let new_hash = self._generate_merkle_hash()?; - self.set_merkle_hash(new_hash) - } - } - } - - /// Generates a Merkle hash based on the node content. - /// For VRHeader and BaseVectorResource nodes, returns the resource merkle_root if it is available, - /// however if root == None, then generates a new hash from the content. - pub fn _generate_merkle_hash(&self) -> Result { - match &self.content { - NodeContent::VRHeader(header) => match header.resource_merkle_root.clone() { - Some(hash) => Ok(hash), - None => Self::hash_node_content(&self.content), - }, - NodeContent::Resource(resource) => match resource.as_trait_object().get_merkle_root() { - Ok(hash) => Ok(hash), - Err(_) => Self::hash_node_content(&self.content), - }, - _ => Self::hash_node_content(&self.content), - } - } - - /// Creates a Blake3 hash of the NodeContent. - fn hash_node_content(content: &NodeContent) -> Result { - let json = content.to_json()?; - let content = json.as_bytes(); - let hash = hash(content); - Ok(hash.to_hex().to_string()) - } - - /// Sets the Merkle hash of the Node. - /// For Vector Resource & VRHeader nodes, sets the resource merkle_root. - fn set_merkle_hash(&mut self, merkle_hash: String) -> Result<(), VRError> { - match &mut self.content { - NodeContent::VRHeader(header) => { - header.resource_merkle_root = Some(merkle_hash); - Ok(()) - } - NodeContent::Resource(resource) => { - resource.as_trait_object_mut().set_merkle_root(merkle_hash); - Ok(()) - } - _ => { - self.merkle_hash = Some(merkle_hash); - Ok(()) - } - } - } - - /// Returns the key used for storing the Merkle hash in the metadata. - fn merkle_hash_metadata_key() -> &'static str { - "merkle_hash" - } - - /// Tries to fetch the node's datetime by reading it from the default datetime metadata key - pub fn get_metadata_datetime(&self) -> Option> { - if let Some(metadata) = &self.metadata { - if let Some(datetime) = metadata.get(&ShinkaiFileParser::datetime_metadata_key()) { - let datetime_option = DateTime::parse_from_rfc3339(datetime).ok(); - if let Some(dt) = datetime_option { - return Some(dt.into()); - } - } - } - None - } - - pub fn count_total_tokens(&self) -> u64 { - match &self.content { - NodeContent::Text(text) => count_tokens_from_message_llama3(text), - NodeContent::Resource(resource) => resource.as_trait_object().count_total_tokens(), - _ => 0, - } - } -} - -/// Contents of a Node -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, ToSchema)] -pub enum NodeContent { - Text(String), - Resource(BaseVectorResource), - ExternalContent(SourceReference), - VRHeader(VRHeader), -} - -impl NodeContent { - /// Converts the NodeContent to a JSON string - pub fn to_json(&self) -> Result { - serde_json::to_string(self) - } - - /// Creates a NodeContent from a JSON string - pub fn from_json(json: &str) -> Result { - serde_json::from_str(json) - } -} - -/// Struct which holds descriptive information about a given Vector Resource. -#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, ToSchema)] -pub struct VRHeader { - pub resource_name: String, - pub resource_id: String, - pub resource_base_type: VRBaseType, - pub resource_source: VRSourceReference, - pub resource_embedding: Option, - /// ISO RFC3339 when then Vector Resource was created - #[schema(value_type = String, format = Date)] - pub resource_created_datetime: DateTime, - /// ISO RFC3339 when then Vector Resource was last written into (a node was modified) - #[schema(value_type = String, format = Date)] - pub resource_last_written_datetime: DateTime, - #[schema(value_type = String)] - pub resource_embedding_model_used: EmbeddingModelType, - pub resource_merkle_root: Option, - pub resource_keywords: VRKeywords, - pub resource_distribution_info: DistributionInfo, - /// List of data tag names matching in internal nodes - pub data_tag_names: Vec, - /// List of metadata keys held in internal nodes - pub metadata_index_keys: Vec, -} - -impl VRHeader { - /// Create a new VRHeader - #[allow(clippy::too_many_arguments)] - pub fn new( - resource_name: &str, - resource_id: &str, - resource_base_type: VRBaseType, - resource_embedding: Option, - data_tag_names: Vec, - resource_source: VRSourceReference, - resource_created_datetime: DateTime, - resource_last_written_datetime: DateTime, - metadata_index_keys: Vec, - resource_embedding_model_used: EmbeddingModelType, - resource_merkle_root: Option, - resource_keywords: VRKeywords, - resource_distribution_info: DistributionInfo, - ) -> Self { - Self { - resource_name: resource_name.to_string(), - resource_id: resource_id.to_string(), - resource_base_type, - resource_embedding: resource_embedding.clone(), - data_tag_names: data_tag_names, - resource_source, - resource_created_datetime, - resource_last_written_datetime, - metadata_index_keys, - resource_embedding_model_used, - resource_merkle_root, - resource_keywords, - resource_distribution_info, - } - } - - /// Create a new VRHeader using a reference_string instead of the name/id directly - pub fn new_with_reference_string( - reference_string: String, - resource_base_type: VRBaseType, - resource_embedding: Option, - data_tag_names: Vec, - resource_source: VRSourceReference, - resource_created_datetime: DateTime, - resource_last_written_datetime: DateTime, - metadata_index_keys: Vec, - resource_embedding_model_used: EmbeddingModelType, - resource_merkle_root: Option, - resource_keywords: VRKeywords, - resource_distribution_info: DistributionInfo, - ) -> Result { - let parts: Vec<&str> = reference_string.split(":::").collect(); - if parts.len() != 2 { - return Err(VRError::InvalidReferenceString(reference_string.clone())); - } - let resource_name = parts[0].to_string(); - let resource_id = parts[1].to_string(); - - Ok(Self { - resource_name, - resource_id, - resource_base_type, - resource_embedding: resource_embedding.clone(), - data_tag_names: data_tag_names, - resource_source, - resource_created_datetime, - resource_last_written_datetime, - metadata_index_keys, - resource_embedding_model_used, - resource_merkle_root, - resource_keywords, - resource_distribution_info, - }) - } - - /// Returns a "reference string" that uniquely identifies the VectorResource (formatted as: `{name}:::{resource_id}`). - /// This is also used in the Shinkai Node as the key where the VectorResource is stored in the DB. - pub fn reference_string(&self) -> String { - Self::generate_resource_reference_string(self.resource_name.clone(), self.resource_id.clone()) - } - - /// Returns a "reference string" that uniquely identifies the VectorResource (formatted as: `{name}:::{resource_id}`). - /// This is also used in the Shinkai Node as the key where the VectorResource is stored in the DB. - pub fn generate_resource_reference_string(name: String, resource_id: String) -> String { - let name = VRPath::clean_string(&name); - let resource_id = VRPath::clean_string(&resource_id); - format!("{}:::{}", name, resource_id) - } - - /// Attempts to return the DistributionInfo datetime, if not available, returns - /// the resource_last_written_datetime. - pub fn get_resource_datetime_default(&self) -> DateTime { - if let Some(datetime) = &self.resource_distribution_info.datetime { - datetime.clone() - } else { - self.resource_last_written_datetime - } - } - - /// Attempts to return the DistributionInfo datetime, if not available, returns - /// the resource_created_datetime. - pub fn get_resource_datetime_default_created(&self) -> DateTime { - if let Some(datetime) = &self.resource_distribution_info.datetime { - datetime.clone() - } else { - self.resource_created_datetime - } - } -} - -/// A struct which holds a Vector Resource's keywords/optional -/// keywords embedding -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, ToSchema)] -pub struct VRKeywords { - pub keyword_list: Vec, - pub keywords_embedding: Option, -} - -impl VRKeywords { - /// Creates a new instance of VRKeywords. - pub fn new() -> Self { - VRKeywords { - keyword_list: Vec::new(), - keywords_embedding: None, - } - } - - /// Adds a keyword to the list. - pub fn add_keyword(&mut self, keyword: String) { - self.keyword_list.push(keyword); - } - - /// Removes the last keyword from the list and returns it. - pub fn pop_keyword(&mut self) -> Option { - self.keyword_list.pop() - } - - /// Sets the entire list of keywords. - pub fn set_keywords(&mut self, keywords: Vec) { - self.keyword_list = keywords; - } - - /// Sets the keyword embedding, overwriting the previous value. - pub fn set_embedding(&mut self, embedding: Embedding, model_type: EmbeddingModelType) { - let keyword_embedding = KeywordEmbedding::new(embedding, model_type); - self.keywords_embedding = Some(keyword_embedding); - } - - /// Removes the keyword embedding and returns it. - pub fn remove_embedding(&mut self) -> Option { - self.keywords_embedding.take() - } - - #[cfg(feature = "desktop-only")] - /// Asynchronously regenerates and updates the keywords' embedding using the provided keywords. - pub async fn update_keywords_embedding(&mut self, generator: &dyn EmbeddingGenerator) -> Result<(), VRError> { - let formatted_keywords = format!("Keywords: [{}]", self.keyword_list.join(",")); - let new_embedding = generator.generate_embedding(&formatted_keywords, "KE").await?; - self.set_embedding(new_embedding, generator.model_type()); - Ok(()) - } - - #[cfg(feature = "desktop-only")] - /// Synchronously regenerates and updates the keywords' embedding using the provided keywords. - pub fn update_keywords_embedding_blocking(&mut self, generator: &dyn EmbeddingGenerator) -> Result<(), VRError> { - let formatted_keywords = format!("Keywords: [{}]", self.keyword_list.join(",")); - let new_embedding = generator.generate_embedding_blocking(&formatted_keywords, "KE")?; - self.set_embedding(new_embedding, generator.model_type()); - Ok(()) - } - /// Randomly replaces a specified number of keywords in `keyword_list` with the first `actual_num_to_replace` keywords from the provided list. - pub fn random_replace_keywords(&mut self, num_to_replace: usize, replacement_keywords: Vec) { - // Calculate the actual number of keywords to replace - let actual_num_to_replace = std::cmp::min( - num_to_replace, - std::cmp::min(self.keyword_list.len(), replacement_keywords.len()), - ); - - // Take the first `actual_num_to_replace` keywords from the input list - let replacement_keywords = &replacement_keywords[..actual_num_to_replace]; - - // Randomly select indices in the current keyword list to replace - let mut rng = StdRng::from_entropy(); - let mut indices_to_replace: Vec = (0..self.keyword_list.len()).collect(); - indices_to_replace.shuffle(&mut rng); - let indices_to_replace = &indices_to_replace[..actual_num_to_replace]; - - // Perform the replacement - for (&index, replacement_keyword) in indices_to_replace.iter().zip(replacement_keywords.iter()) { - self.keyword_list[index] = replacement_keyword.clone(); - } - } -} - -/// Struct which holds the embedding for a Vector Resource's keywords -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, ToSchema)] -pub struct KeywordEmbedding { - pub embedding: Embedding, - #[schema(value_type = String)] - pub model_used: EmbeddingModelType, -} - -impl KeywordEmbedding { - /// Creates a new instance of KeywordEmbedding. - pub fn new(embedding: Embedding, model_used: EmbeddingModelType) -> Self { - KeywordEmbedding { embedding, model_used } - } - - /// Sets the embedding and model type. - pub fn set_embedding(&mut self, embedding: Embedding, model_type: EmbeddingModelType) { - self.embedding = embedding; - self.model_used = model_type; - } -} - -/// A path inside of a Vector Resource to a Node which exists somewhere in the hierarchy. -/// Internally the path is made up of an ordered list of Node ids (Int-holding strings for Docs, any string for Maps). -#[derive(Debug, Clone, PartialEq, Eq, ToSchema)] -pub struct VRPath { - pub path_ids: Vec, -} - -impl VRPath { - /// Create a new VRPath, defaulting to root `/`. - /// Equivalent to VRPath::root(). - pub fn new() -> Self { - Self { path_ids: vec![] } - } - - /// Create a new VRPath at root `/`. - /// Equivalent to VRPath::new(). - pub fn root() -> Self { - Self::new() - } - - /// Returns if the path is empty (aka pointing at root, `/`). Equivalent to `.is_root()` - pub fn is_empty(&self) -> bool { - self.path_ids.len() == 0 - } - - /// Returns if the path is pointing at root, `/`. Equivalent to `.is_empty()` - pub fn is_root(&self) -> bool { - self.is_empty() - } - - /// Get the depth of the VRPath. Of note, this will return 0 in both cases if - /// the path is empty, or if it is in the root path (because depth starts at 0 - /// for Vector Resources). This matches the TraversalMethod::UntilDepth interface. - pub fn depth(&self) -> u64 { - if self.path_ids.is_empty() { - 0 - } else { - (self.path_ids.len() - 1) as u64 - } - } - - /// Get the inclusive depth of the VRPath, meaning we include all parts of the path, including - /// the final id. (In practice, generally +1 compared to .depth()) - pub fn depth_inclusive(&self) -> u64 { - self.path_ids.len() as u64 - } - - /// Adds an id to the end of the VRPath's path_ids. Automatically cleans the id String - /// to remove unsupported characters that would break the path. - pub fn push(&mut self, id: String) { - self.path_ids.push(VRPath::clean_string(&id)); - } - - /// Removes an element from the end of the path_ids - pub fn pop(&mut self) -> Option { - self.path_ids.pop() - } - - /// Removes the first element from the path_ids and returns it as an Option. - pub fn front_pop(&mut self) -> Option { - if self.path_ids.is_empty() { - None - } else { - Some(self.path_ids.remove(0)) - } - } - - /// Returns a copy of the final id in the path, if it exists. - /// This is the id of the actual node that the path points to. - pub fn last_path_id(&self) -> Result { - self.path_ids - .last() - .cloned() - .ok_or(VRError::InvalidVRPath(self.clone())) - } - - /// Creates a cloned VRPath and adds an id to the end of the VRPath's path_ids. - /// Automatically cleans the id String to remove unsupported characters that would break the path. - pub fn push_cloned(&self, id: String) -> Self { - let mut new_path = self.clone(); - new_path.push(id); - new_path - } - - /// Returns a cloned VRPath with the last id removed from the end - pub fn pop_cloned(&self) -> Self { - let mut new_path = self.clone(); - new_path.pop(); - new_path - } - - /// Returns a cloned VRPath with the first id removed from the start. - pub fn front_pop_cloned(&self) -> Self { - let mut new_path = self.clone(); - new_path.front_pop(); - new_path - } - - /// Appends the path ids from `input_path` to the end of this VRPath. - pub fn append_path(&mut self, input_path: &VRPath) { - for path_id in &input_path.path_ids { - self.push(path_id.clone()); - } - } - - /// Returns a new VRPath which is a clone of self with the path ids from `input_path` appended to the end. - pub fn append_path_cloned(&self, input_path: &VRPath) -> Self { - let mut new_path = self.clone(); - new_path.append_path(input_path); - new_path - } - - /// Returns a VRPath which is the path prior to self (the "parent path"). - /// Ie. For path "/a/b/c", this will return "/a/b". - pub fn parent_path(&self) -> Self { - self.pop_cloned() - } - - /// Checks if the given path is the immediate parent of self. - pub fn is_parent_path(&self, path: &VRPath) -> bool { - self.parent_path() == *path - } - - /// Checks if the input path is a descendant of self. - /// A descendant path is one that starts with the same ids as self but is longer. - pub fn is_descendant_path(&self, path: &VRPath) -> bool { - if path.path_ids.len() <= self.path_ids.len() { - return false; - } - - self.path_ids - .iter() - .zip(&path.path_ids) - .all(|(self_id, path_id)| self_id == path_id) - } - - /// Checks if self is an ancestor of the input path. - /// An ancestor path is one that is a prefix of self but is shorter. - pub fn is_ancestor_path(&self, path: &VRPath) -> bool { - if self.path_ids.len() == 0 && path.path_ids.len() != 0 { - return true; - } - - if path.path_ids.len() >= self.path_ids.len() { - return false; - } - - path.path_ids - .iter() - .zip(&self.path_ids) - .all(|(path_id, self_id)| path_id == self_id) - } - - /// Create a VRPath from a path string - pub fn from_string(path_string: &str) -> Result { - if !path_string.starts_with('/') { - return Err(VRError::InvalidPathString(path_string.to_string())); - } - - let mut path = Self::new(); - if path_string != "/" { - let path_ids_string = path_string.trim_start_matches('/').trim_end_matches('/'); - let elements: Vec<&str> = path_ids_string.split('/').collect(); - for element in elements { - path.push(element.to_string()); - } - } - Ok(path) - } - - /// Formats the VRPath to a string - pub fn format_to_string(&self) -> String { - format!("/{}", self.path_ids.join("/")) - } - - /// Cleans an input string to ensure that it does not have any - /// characters which would break a VRPath, or cause issues generally for the VectorFS. - pub fn clean_string(s: &str) -> String { - s.replace("/", "-").replace(":", "_") - } -} - -impl Hash for VRPath { - fn hash(&self, state: &mut H) { - self.format_to_string().hash(state); - } -} - -impl fmt::Display for VRPath { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "{}", &self.format_to_string()) - } -} - -impl Serialize for VRPath { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - // Convert the VRPath into a string here - let s = self.format_to_string(); - serializer.serialize_str(&s) - } -} - -impl<'de> Deserialize<'de> for VRPath { - fn deserialize(deserializer: D) -> Result - where - D: Deserializer<'de>, - { - // Deserialize the VRPath from a string - let s = String::deserialize(deserializer)?; - VRPath::from_string(&s).map_err(serde::de::Error::custom) - } -} - -/// Alters default vector search behavior that modifies the result context. Each mode can be enabled separately or together. -/// Default: fill context window up to maximum tokens. -/// FillUpTo25k: fill context window up to 25k tokens. -/// MergeSiblings: add previous 3 and next 3 nodes to each found node and merge them together. -#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)] -pub enum VectorSearchMode { - FillUpTo25k, - MergeSiblings, -} diff --git a/shinkai-libs/shinkai-vector-resources/src/vector_resource/vector_search_traversal.rs b/shinkai-libs/shinkai-vector-resources/src/vector_resource/vector_search_traversal.rs deleted file mode 100644 index 664e00913..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/vector_resource/vector_search_traversal.rs +++ /dev/null @@ -1,260 +0,0 @@ -use std::collections::HashMap; - -use crate::vector_resource::base_vector_resources::VRBaseType; -pub use crate::vector_resource::vector_resource_types::*; - -/// An enum that represents the different traversal approaches -/// supported by Vector Searching. In other words these allow the developer to -/// choose how the searching algorithm -#[derive(Debug, Clone, PartialEq)] -pub enum TraversalMethod { - /// Efficiently only goes deeper into Vector Resources if they are the highest scored Nodes at their level. - /// Will go infinitely deep until hitting a level where no BaseVectorResources are part of the highest scored. - Efficient, - /// Traverses through all levels of depth and scores all content holding nodes. - Exhaustive, - /// Iterates exhaustively going through all levels while doing absolutely no scoring/similarity checking, - /// returning every single Node at any level. Also returns the Vector Resources in addition to their - /// Nodes they hold inside, thus providing all nodes that exist within the root Vector Resource. - /// Note: This is not for vector searching, but for retrieving all possible Nodes. - UnscoredAllNodes, -} - -#[derive(Debug, Clone, PartialEq)] -pub enum TraversalOption { - /// Limits returned result to be within a percentage range (0.0 - 1.0) of the highest scored result. - /// For example, you can set a tolerance range of 0.1 which means only nodes with a similarity score - /// within 10% of the top result will be returned. - ToleranceRangeResults(f32), - /// Limits returned results to be greater than a specific score (0.0 - 1.0) - MinimumScore(f32), - /// Efficiently traverses until (and including) the specified depth is hit (or until there are no more levels to go). - /// Will return BaseVectorResource Nodes if they are the highest scored at the specified depth. - /// Top/root level starts at 0, and so first level of depth into internal BaseVectorResources is thus 1. - UntilDepth(u64), - /// Set a traversal limiting mode, which stops the Vector Search from going deeper into a BaseVectorResource-holding - /// node based on some set condition(s). - SetTraversalLimiting(LimitTraversalMode), - /// By default Vector Search scoring only weighs a node based on it's single embedding alone. - /// Alternate scoring modes are available which allow weighing a node base on relative scores - /// above/below/beside, or otherwise to get potentially higher quality results. - SetScoringMode(ScoringMode), - /// Set a prefilter mode for a vector search. These modes use pre-processed indices in the Vector Resource - /// to efficiently filter out all unrelated nodes before performing any semantic search logic. - SetPrefilterMode(PrefilterMode), - /// Set a filter mode while performing a vector search. These modes allow filtering elements during a Vector Search - /// dynamically based on data within each found node. They do not use an indices, so are slower than prefilter modes. - SetFilterMode(FilterMode), - /// Set a results mode for a vector search. These modes allow changing which nodes are returned from a Vector Search. - SetResultsMode(ResultsMode), -} - -#[derive(Debug, Clone, PartialEq)] -pub enum LimitTraversalMode { - /// Limits traversal into deeper Vector Resources only if they match the provided VRBaseType - LimitTraversalToType(VRBaseType), - /// Limits traversal by a validation function with an input HashMap. If the validation function returns `true`, the Vector Search will - /// traverse deeper into the Vector Resource-holding Node. - LimitTraversalByValidationWithMap( - ( - fn(&Node, &VRPath, HashMap) -> bool, - HashMap, - ), - ), -} - -#[derive(Debug, Clone, PartialEq, Copy)] -pub enum ScoringMode { - /// While traversing, averages out the score all the way to each final node. In other words, the final score - /// of each node weighs-in the scores of the Vector Resources that it was inside all the way up to the root. - HierarchicalAverageScoring, -} - -#[derive(Debug, Clone, PartialEq)] -pub enum PrefilterMode { - /// Perform a Syntactic Vector Search. - /// A syntactic vector search efficiently pre-filters all Nodes held internally to a subset that - /// matches the provided list of data tag names (Strings). - SyntacticVectorSearch(Vec), -} - -pub type ProximityWindow = u64; -pub type NumberOfTopResults = u64; - -#[derive(Debug, Clone, PartialEq)] -pub enum ResultsMode { - /// Finds the highest `NumberOfTopResults` scored nodes + fetches a `ProximityWindow` number - /// of nodes before/after. This search only works if the VectorResource where the node is held in - /// implements OrderedVectorResource. - ProximitySearch(ProximityWindow, NumberOfTopResults), -} - -pub type Key = String; -pub type Value = String; -#[derive(Debug, Clone, PartialEq)] -pub enum FilterMode { - /// Filters out Nodes which do not match at least one of the (Key, Option) pairs in the list. - /// Note, if Value is `None`, then we only check that the Node has a matching key, with the value being ignored. - ContainsAnyMetadataKeyValues(Vec<(Key, Option)>), - /// Filters out Nodes which do not match all of the (Key, Option) pairs in the list. - /// Note, if Value is `None`, then we only check that the Node has a matching key, with the value being ignored. - ContainsAllMetadataKeyValues(Vec<(Key, Option)>), -} - -impl FilterMode { - /// Helper function to check if a node contains any matching key values - pub fn node_metadata_any_check(node: &Node, kv_pairs: &Vec<(Key, Option)>) -> bool { - if let Some(metadata) = &node.metadata { - for (key, value_option) in kv_pairs { - if let Some(value) = metadata.get(key) { - if value_option.is_none() { - return true; - } else if let Some(expected_value) = value_option { - if value == expected_value { - return true; - } - } - } - } - } - false - } - - /// Helper function to check if a node contains all matching key values - pub fn node_metadata_all_check(node: &Node, kv_pairs: &Vec<(Key, Option)>) -> bool { - if let Some(metadata) = &node.metadata { - for (key, value_option) in kv_pairs { - if let Some(value) = metadata.get(key) { - if let Some(expected_value) = value_option { - if value != expected_value { - return false; - } - } - } else { - return false; - } - } - true - } else { - false - } - } -} - -pub trait TraversalOptionVecExt { - fn get_limit_traversal_to_type_option(&self) -> Option<&VRBaseType>; - fn get_tolerance_range_results_option(&self) -> Option; - fn get_minimum_score_option(&self) -> Option; - fn get_until_depth_option(&self) -> Option; - fn get_set_scoring_mode_option(&self) -> Option; - fn get_set_prefilter_mode_option(&self) -> Option; - fn get_set_filter_mode_option(&self) -> Option; - fn get_set_results_mode_option(&self) -> Option; - fn get_limit_traversal_by_validation_with_map_option( - &self, - ) -> Option<( - fn(&Node, &VRPath, HashMap) -> bool, - HashMap, - )>; -} - -impl TraversalOptionVecExt for Vec { - fn get_limit_traversal_to_type_option(&self) -> Option<&VRBaseType> { - self.iter().find_map(|option| { - if let TraversalOption::SetTraversalLimiting(LimitTraversalMode::LimitTraversalToType(value)) = option { - Some(value) - } else { - None - } - }) - } - - fn get_limit_traversal_by_validation_with_map_option( - &self, - ) -> Option<( - fn(&Node, &VRPath, HashMap) -> bool, - HashMap, - )> { - self.iter().find_map(|option| { - if let TraversalOption::SetTraversalLimiting(LimitTraversalMode::LimitTraversalByValidationWithMap(( - validation_func, - hashmap, - ))) = option - { - Some((*validation_func, hashmap.clone())) - } else { - None - } - }) - } - - fn get_tolerance_range_results_option(&self) -> Option { - self.iter().find_map(|option| { - if let TraversalOption::ToleranceRangeResults(value) = option { - Some(*value) - } else { - None - } - }) - } - - fn get_minimum_score_option(&self) -> Option { - self.iter().find_map(|option| { - if let TraversalOption::MinimumScore(value) = option { - Some(*value) - } else { - None - } - }) - } - - fn get_until_depth_option(&self) -> Option { - self.iter().find_map(|option| { - if let TraversalOption::UntilDepth(value) = option { - Some(*value) - } else { - None - } - }) - } - - fn get_set_scoring_mode_option(&self) -> Option { - self.iter().find_map(|option| { - if let TraversalOption::SetScoringMode(value) = option { - Some(*value) - } else { - None - } - }) - } - - fn get_set_prefilter_mode_option(&self) -> Option { - self.iter().find_map(|option| { - if let TraversalOption::SetPrefilterMode(value) = option { - Some(value.clone()) - } else { - None - } - }) - } - - fn get_set_filter_mode_option(&self) -> Option { - self.iter().find_map(|option| { - if let TraversalOption::SetFilterMode(value) = option { - Some(value.clone()) - } else { - None - } - }) - } - - fn get_set_results_mode_option(&self) -> Option { - self.iter().find_map(|option| { - if let TraversalOption::SetResultsMode(value) = option { - Some(value.clone()) - } else { - None - } - }) - } -} diff --git a/shinkai-libs/shinkai-vector-resources/src/vector_resource/vrkai.rs b/shinkai-libs/shinkai-vector-resources/src/vector_resource/vrkai.rs deleted file mode 100644 index 45a7b5331..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/vector_resource/vrkai.rs +++ /dev/null @@ -1,190 +0,0 @@ -use super::{BaseVectorResource, RetrievedNode, TraversalMethod, TraversalOption, VRPath, VectorSearchMode}; -use crate::{embeddings::Embedding, resource_errors::VRError, source::SourceFileMap}; -use base64::{decode, encode}; -use lz4_flex::{compress_prepend_size, decompress_size_prepended}; -use serde::{Deserialize, Serialize}; -use utoipa::ToSchema; - -use std::collections::HashMap; - -// Versions of VRKai that are supported -#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, ToSchema)] -pub enum VRKaiVersion { - #[serde(rename = "V1")] - V1, -} - -impl VRKaiVersion { - pub fn to_string(&self) -> String { - serde_json::to_string(self).unwrap() - } -} - -#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)] -pub enum RAGStrategy { - Basic, -} - -impl Default for RAGStrategy { - fn default() -> Self { - RAGStrategy::Basic - } -} - -/// Represents a parsed VRKai file with a BaseVectorResource, and optional SourceFileMap. -/// To save as a file or transfer the VRKai, call one of the `prepare_as_` methods. To parse from a file/transfer, use the `from_` methods. -#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)] -pub struct VRKai { - pub resource: BaseVectorResource, - pub sfm: Option, - pub version: VRKaiVersion, - pub metadata: HashMap, - #[serde(default)] - pub rag_strategy: RAGStrategy, - #[serde(default)] - pub total_token_count: u64, -} - -impl VRKai { - /// The default VRKai version which is used when creating new VRKais - pub fn default_vrkai_version() -> VRKaiVersion { - VRKaiVersion::V1 - } - - /// Creates a new VRKai instance from a BaseVectorResource, with optional SourceFileMap. - pub fn new(resource: BaseVectorResource, sfm: Option) -> Self { - let total_token_count = resource.as_trait_object().count_total_tokens(); - VRKai { - resource, - sfm, - version: Self::default_vrkai_version(), - metadata: HashMap::new(), - rag_strategy: RAGStrategy::Basic, - total_token_count, - } - } - - /// Returns the name of the Vector Resource stored in the VRKai - pub fn name(&self) -> String { - self.resource.as_trait_object().name().to_string() - } - - /// Prepares the VRKai to be saved or transferred as compressed bytes. - /// Of note, this is the bytes of the UTF-8 base64 string. This allows for easy compatibility between the two. - pub fn encode_as_bytes(&self) -> Result, VRError> { - if let VRKaiVersion::V1 = self.version { - let base64_encoded = self.encode_as_base64()?; - return Ok(base64_encoded.into_bytes()); - } - Err(VRError::UnsupportedVRKaiVersion(self.version.to_string())) - } - - /// Prepares the VRKai to be saved or transferred across the network as a compressed base64 encoded string. - pub fn encode_as_base64(&self) -> Result { - if let VRKaiVersion::V1 = self.version { - let json_str = serde_json::to_string(self)?; - let compressed_bytes = compress_prepend_size(json_str.as_bytes()); - let base64_encoded = encode(compressed_bytes); - return Ok(base64_encoded); - } - Err(VRError::UnsupportedVRKaiVersion(self.version.to_string())) - } - - /// Parses a VRKai from an array of bytes, assuming the bytes are a Base64 encoded string. - pub fn from_bytes(base64_bytes: &[u8]) -> Result { - // If it is Version V1 - if let Ok(base64_str) = String::from_utf8(base64_bytes.to_vec()) - .map_err(|e| VRError::VRKaiParsingError(format!("UTF-8 conversion error: {}", e))) - { - return Self::from_base64(&base64_str); - } - - Err(VRError::UnsupportedVRKaiVersion("".to_string())) - } - - /// Parses a VRKai from a Base64 encoded string. - pub fn from_base64(base64_encoded: &str) -> Result { - // If it is Version V1 - if let Ok(vrkai) = Self::from_base64_v1(base64_encoded) { - return Ok(vrkai); - } - - Err(VRError::UnsupportedVRKaiVersion("".to_string())) - } - - /// Parses a VRKai from a Base64 encoded string using V1 logic. - fn from_base64_v1(base64_encoded: &str) -> Result { - let bytes = - decode(base64_encoded).map_err(|e| VRError::VRKaiParsingError(format!("Base64 decoding error: {}", e)))?; - let decompressed_bytes = decompress_size_prepended(&bytes) - .map_err(|e| VRError::VRKaiParsingError(format!("Decompression error: {}", e)))?; - let json_str = String::from_utf8(decompressed_bytes) - .map_err(|e| VRError::VRKaiParsingError(format!("UTF-8 conversion error: {}", e)))?; - let vrkai = serde_json::from_str(&json_str) - .map_err(|e| VRError::VRKaiParsingError(format!("JSON parsing error: {}", e)))?; - Ok(vrkai) - } - - /// Parses the VRKai into human-readable JSON (intended for readability in non-production use cases) - pub fn to_json(&self) -> Result { - serde_json::to_string(self) - } - - /// Parses the VRKai into human-readable JSON Value (intended for readability in non-production use cases) - pub fn to_json_value(&self) -> Result { - serde_json::to_value(self) - } - - /// Parses into a VRKai from human-readable JSON (intended for readability in non-production use cases) - pub fn from_json(json_str: &str) -> Result { - serde_json::from_str(json_str) - } - - /// Inserts a key-value pair into the VRPack's metadata. Replaces existing value if key already exists. - pub fn metadata_insert(&mut self, key: String, value: String) { - self.metadata.insert(key, value); - } - - /// Retrieves the value associated with a key from the VRPack's metadata. - pub fn metadata_get(&self, key: &str) -> Option<&String> { - self.metadata.get(key) - } - - /// Removes a key-value pair from the VRPack's metadata given the key. - pub fn metadata_remove(&mut self, key: &str) -> Option { - self.metadata.remove(key) - } - - /// Performs a vector search that returns the most similar nodes based on the query with - /// default traversal method/options. - pub fn vector_search(&self, query: Embedding, num_of_results: u64) -> Vec { - self.resource.as_trait_object().vector_search(query, num_of_results) - } - - /// Performs a vector search that returns the most similar nodes based on the query. - /// The input traversal_method/options allows the developer to choose how the search moves through the levels. - /// The optional starting_path allows the developer to choose to start searching from a Vector Resource - /// held internally at a specific path. - pub fn vector_search_customized( - &self, - query: Embedding, - num_of_results: u64, - traversal_method: TraversalMethod, - traversal_options: &Vec, - starting_path: Option, - vector_search_mode: Vec, - ) -> Vec { - self.resource.as_trait_object().vector_search_customized( - query, - num_of_results, - traversal_method, - traversal_options, - starting_path, - vector_search_mode, - ) - } - - pub fn count_total_tokens(&self) -> u64 { - self.resource.as_trait_object().count_total_tokens() - } -} diff --git a/shinkai-libs/shinkai-vector-resources/src/vector_resource/vrpack.rs b/shinkai-libs/shinkai-vector-resources/src/vector_resource/vrpack.rs deleted file mode 100644 index 43f5bffdb..000000000 --- a/shinkai-libs/shinkai-vector-resources/src/vector_resource/vrpack.rs +++ /dev/null @@ -1,928 +0,0 @@ -use std::collections::HashMap; - -use super::{ - deep_search_scores_average_out, BaseVectorResource, MapVectorResource, Node, NodeContent, RetrievedNode, - ScoringMode, TraversalMethod, TraversalOption, VRKai, VRPath, VRSourceReference, VectorSearchMode, -}; -#[cfg(feature = "desktop-only")] -use crate::embedding_generator::{EmbeddingGenerator, RemoteEmbeddingGenerator}; -use crate::model_type::EmbeddingModelTypeString; -use crate::{embeddings::Embedding, resource_errors::VRError}; -use base64::{decode, encode}; -use serde::{Deserialize, Serialize}; -use serde_json::json; -use serde_json::Value as JsonValue; -use utoipa::ToSchema; - -// Versions of VRPack that are supported -#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, ToSchema)] -pub enum VRPackVersion { - #[serde(rename = "V1")] - V1, -} - -impl VRPackVersion { - pub fn to_string(&self) -> String { - serde_json::to_string(self).unwrap() - } -} - -/// Represents a parsed VRPack file, which contains a Map Vector Resource that holds a tree structure of folders & encoded VRKai nodes. -/// In other words, a `.vrpack` file is akin to a "compressed archive" of internally held VRKais with folder structure preserved. -/// Of note, VRPacks are not compressed at the top level because the VRKais held inside already are. This improves performance for large VRPacks. -/// To save as a file or transfer the VRPack, call one of the `encode_as_` methods. To parse from a file/transfer, use the `from_` methods. -#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)] -pub struct VRPack { - pub name: String, - pub resource: BaseVectorResource, - pub version: VRPackVersion, - pub vrkai_count: u64, - pub folder_count: u64, - pub embedding_models_used: HashMap, - /// VRPack metadata enables users to add extra info that may be needed for unique use cases - pub metadata: HashMap, -} - -impl VRPack { - /// The default VRPack version which is used when creating new VRPacks - pub fn default_vrpack_version() -> VRPackVersion { - VRPackVersion::V1 - } - - /// Creates a new VRPack with the provided BaseVectorResource and the default version. - pub fn new( - name: &str, - resource: BaseVectorResource, - embedding_models_used: HashMap, - metadata: Option>, - ) -> Self { - let (vrkai_count, folder_count) = Self::num_of_vrkais_and_folders(&resource); - - VRPack { - name: name.to_string(), - resource, - version: Self::default_vrpack_version(), - vrkai_count, - folder_count, - embedding_models_used, - metadata: metadata.unwrap_or_default(), - } - } - - /// Creates a new empty VRPack with an empty BaseVectorResource and the default version. - pub fn new_empty(name: &str) -> Self { - VRPack { - name: name.to_string(), - resource: BaseVectorResource::Map(MapVectorResource::new_empty( - "vrpack", - None, - VRSourceReference::None, - true, - )), - version: Self::default_vrpack_version(), - vrkai_count: 0, - folder_count: 0, - embedding_models_used: HashMap::new(), - metadata: HashMap::new(), - } - } - - /// Prepares the VRPack to be saved or transferred as bytes. - /// Of note, this is the bytes of the UTF-8 base64 string. This allows for easy compatibility between the two. - pub fn encode_as_bytes(&self) -> Result, VRError> { - if let VRPackVersion::V1 = self.version { - let base64_encoded = self.encode_as_base64()?; - return Ok(base64_encoded.into_bytes()); - } - return Err(VRError::UnsupportedVRPackVersion(self.version.to_string())); - } - - /// Prepares the VRPack to be saved or transferred across the network as a base64 encoded string. - pub fn encode_as_base64(&self) -> Result { - if let VRPackVersion::V1 = self.version { - let json_str = serde_json::to_string(self)?; - let base64_encoded = encode(json_str.as_bytes()); - return Ok(base64_encoded); - } - return Err(VRError::UnsupportedVRPackVersion(self.version.to_string())); - } - - /// Parses a VRPack from an array of bytes, assuming the bytes are a Base64 encoded string. - pub fn from_bytes(base64_bytes: &[u8]) -> Result { - // If it is Version V1 - if let Ok(base64_str) = String::from_utf8(base64_bytes.to_vec()) - .map_err(|e| VRError::VRPackParsingError(format!("UTF-8 conversion error: {}", e))) - { - return Self::from_base64(&base64_str); - } - - return Err(VRError::UnsupportedVRPackVersion("".to_string())); - } - - /// Parses a VRPack from a Base64 encoded string without compression. - pub fn from_base64(base64_encoded: &str) -> Result { - // If it is Version V1 - let v1 = Self::from_base64_v1(base64_encoded); - if let Ok(vrkai) = v1 { - return Ok(vrkai); - } else if let Err(e) = v1 { - eprintln!("VRPack Error: {}", e); - } - - return Err(VRError::UnsupportedVRPackVersion("".to_string())); - } - - /// Parses a VRPack from a Base64 encoded string using V1 logic without compression. - fn from_base64_v1(base64_encoded: &str) -> Result { - let bytes = - decode(base64_encoded).map_err(|e| VRError::VRPackParsingError(format!("Base64 decoding error: {}", e)))?; - let json_str = String::from_utf8(bytes) - .map_err(|e| VRError::VRPackParsingError(format!("UTF-8 conversion error: {}", e)))?; - let vrkai = serde_json::from_str(&json_str) - .map_err(|e| VRError::VRPackParsingError(format!("JSON parsing error: {}", e)))?; - Ok(vrkai) - } - - /// Parses the VRPack into human-readable JSON (intended for readability in non-production use cases) - pub fn to_json(&self) -> Result { - serde_json::to_string(self) - } - - /// Parses the VRPack into human-readable JSON Value (intended for readability in non-production use cases) - pub fn to_json_value(&self) -> Result { - serde_json::to_value(self) - } - - /// Parses into a VRPack from human-readable JSON (intended for readability in non-production use cases) - pub fn from_json(json_str: &str) -> Result { - serde_json::from_str(json_str) - } - - /// Sets the name of the VRPack. - pub fn set_name(&mut self, name: &str) { - self.name = name.to_string(); - } - - /// Sets the resource of the VRPack. - pub fn set_resource( - &mut self, - resource: BaseVectorResource, - embedding_models_used: HashMap, - ) { - let (vrkai_count, folder_count) = Self::num_of_vrkais_and_folders(&resource); - self.resource = resource; - self.vrkai_count = vrkai_count; - self.folder_count = folder_count; - self.embedding_models_used = embedding_models_used; - } - - /// Returns the ID of the VRPack. - pub fn id(&self) -> String { - self.resource.as_trait_object().resource_id().to_string() - } - - /// Returns the Merkle root of the VRPack. - pub fn merkle_root(&self) -> Result { - self.resource.as_trait_object().get_merkle_root() - } - - /// Adds a VRKai into the VRPack inside of the specified parent path (folder or root). - pub fn insert_vrkai( - &mut self, - vrkai: &VRKai, - parent_path: VRPath, - update_merkle_hashes: bool, - ) -> Result<(), VRError> { - let resource_name = vrkai.resource.as_trait_object().name().to_string(); - let embedding = vrkai.resource.as_trait_object().resource_embedding().clone(); - let metadata = None; - let enc_vrkai = vrkai.encode_as_base64()?; - let mut node = Node::new_text(resource_name.clone(), enc_vrkai, metadata, &vec![]); - // We always take the merkle root of the resource, no matter what - node.merkle_hash = Some(vrkai.resource.as_trait_object().get_merkle_root()?); - - self.resource.as_trait_object_mut().insert_node_at_path( - parent_path, - resource_name, - node, - embedding, - update_merkle_hashes, - )?; - - // Add the embedding model used to the hashmap - let model = vrkai.resource.as_trait_object().embedding_model_used(); - if !self.embedding_models_used.contains_key(&model.to_string()) { - self.embedding_models_used - .entry(model.to_string()) - .and_modify(|count| *count += 1) - .or_insert(1); - } - self.vrkai_count += 1; - - Ok(()) - } - - /// Creates a folder inside the VRPack at the specified parent path. - pub fn create_folder(&mut self, folder_name: &str, parent_path: VRPath) -> Result<(), VRError> { - let resource = BaseVectorResource::Map(MapVectorResource::new_empty( - folder_name, - None, - VRSourceReference::None, - true, - )); - let node = Node::new_vector_resource(folder_name.to_string(), &resource, None); - let embedding = Embedding::new_empty(); - - self.resource.as_trait_object_mut().insert_node_at_path( - parent_path, - folder_name.to_string(), - node, - embedding, - true, - )?; - - self.folder_count += 1; - - Ok(()) - } - - /// Parses a node into a VRKai. - fn parse_node_to_vrkai(node: &Node) -> Result { - match &node.content { - NodeContent::Text(content) => { - return VRKai::from_base64(content); - } - _ => Err(VRError::VRKaiParsingError("Invalid node content type".to_string())), - } - } - - /// Fetches the VRKai node at the specified path and parses it into a VRKai. - pub fn get_vrkai(&self, path: VRPath) -> Result { - let node = self - .resource - .as_trait_object() - .retrieve_node_at_path(path.clone(), None)?; - Self::parse_node_to_vrkai(&node.node) - } - - /// Fetches the merkle hash of the folder at the specified path. - pub fn get_folder_merkle_hash(&self, path: VRPath) -> Result { - let node = self - .resource - .as_trait_object() - .retrieve_node_at_path(path.clone(), None)?; - match node.node.content { - NodeContent::Resource(resource) => Ok(resource.as_trait_object().get_merkle_root()?), - _ => Err(VRError::InvalidNodeType(format!( - "Node is not a folder: {} ", - path.format_to_string() - ))), - } - } - - /// Removes a node (VRKai or folder) from the VRPack at the specified path. - pub fn remove_at_path(&mut self, path: VRPath) -> Result<(), VRError> { - let removed_node = self.resource.as_trait_object_mut().remove_node_at_path(path, true)?; - match removed_node.0.content { - NodeContent::Text(vrkai_base64) => { - // Decrease the embedding model count in the hashmap - let vrkai = VRKai::from_base64(&vrkai_base64)?; - let model = vrkai.resource.as_trait_object().embedding_model_used(); - if let Some(count) = self.embedding_models_used.get_mut(&model.to_string()) { - if *count > 1 { - *count -= 1; - } else { - self.embedding_models_used.remove(&model.to_string()); - } - } - // Decrease vrkai count - self.vrkai_count -= 1; - } - NodeContent::Resource(_) => self.folder_count += 1, - _ => (), - } - Ok(()) - } - - /// Unpacks all VRKais in the VRPack, each as a tuple containing a VRKai and its corresponding VRPath where it was held at. - pub fn unpack_all_vrkais(&self) -> Result, VRError> { - let nodes = self - .resource - .as_trait_object() - .retrieve_nodes_exhaustive_unordered(None); - - let mut vrkais_with_paths = Vec::new(); - for retrieved_node in nodes { - match retrieved_node.node.content { - NodeContent::Text(_) => match Self::parse_node_to_vrkai(&retrieved_node.node) { - Ok(vrkai) => vrkais_with_paths.push((vrkai, retrieved_node.retrieval_path.clone())), - Err(e) => return Err(e), - }, - _ => continue, - } - } - - Ok(vrkais_with_paths) - } - - /// Prints the internal structure of the VRPack, starting from a given path. - pub fn print_internal_structure(&self, starting_path: Option) { - println!("{} VRPack Internal Structure:", self.name); - println!("------------------------------------------------------------"); - let nodes = self - .resource - .as_trait_object() - .retrieve_nodes_exhaustive_unordered(starting_path); - for node in nodes { - let ret_path = node.retrieval_path; - let _path = ret_path.format_to_string(); - let path_depth = ret_path.path_ids.len(); - let data = match &node.node.content { - NodeContent::Text(s) => { - let _text_content = if s.chars().count() > 25 { - s.chars().take(25).collect::() + "..." - } else { - s.to_string() - }; - format!("VRKai: {}", node.node.id) - } - NodeContent::Resource(resource) => { - if path_depth == 1 { - println!(" "); - } - format!( - "{} - {} Nodes Held Inside", - resource.as_trait_object().name(), - resource.as_trait_object().get_root_embeddings().len() - ) - } - _ => continue, // Skip ExternalContent and VRHeader - }; - // Adding merkle hash if it exists to output string - let mut merkle_hash = String::new(); - if let Ok(hash) = node.node.get_merkle_hash() { - if hash.chars().count() > 15 { - merkle_hash = hash.chars().take(15).collect::() + "..." - } else { - merkle_hash = hash.to_string() - } - } - - // Create indent string and do the final print - let indent_string = " ".repeat(path_depth * 2) + &">".repeat(path_depth); - if merkle_hash.is_empty() { - println!("{}{}", indent_string, data); - } else { - println!("{}{} | Merkle Hash: {}", indent_string, data, merkle_hash); - } - } - } - - /// Performs a standard vector search within the VRPack and returns the most similar VRKais based on the input query String. - /// Requires that there is only 1 single Embedding Model Used within the VRPack or errors. - pub async fn vector_search_vrkai(&self, query: Embedding, num_of_results: u64) -> Result, VRError> { - self.vector_search_vrkai_customized( - query, - num_of_results, - TraversalMethod::Exhaustive, - &vec![], - None, - vec![], - ) - .await - } - - /// Performs a standard vector search within the VRPack and returns the most similar VRKais based on the input query String. - /// Supports customizing the search starting path/traversal method/traversal options. - /// Requires that there is only 1 single Embedding Model Used within the VRPack or errors. - pub async fn vector_search_vrkai_customized( - &self, - query: Embedding, - num_of_results: u64, - traversal_method: TraversalMethod, - traversal_options: &Vec, - starting_path: Option, - vector_search_mode: Vec, - ) -> Result, VRError> { - let results = self - .vector_search_vrkai_with_score_customized( - query, - num_of_results, - traversal_method, - traversal_options, - starting_path, - vector_search_mode, - ) - .await?; - let vrkais: Vec = results.into_iter().map(|(vrkai, _)| vrkai).collect(); - Ok(vrkais) - } - - /// Performs a standard vector search within the VRPack and returns the most similar (VRKais, score) based on the input query String. - /// Supports customizing the search starting path/traversal method/traversal options. - /// Requires that there is only 1 single Embedding Model Used within the VRPack or errors. - pub async fn vector_search_vrkai_with_score_customized( - &self, - query: Embedding, - num_of_results: u64, - traversal_method: TraversalMethod, - traversal_options: &Vec, - starting_path: Option, - vector_search_mode: Vec, - ) -> Result, VRError> { - if self.embedding_models_used.keys().len() != 1 { - return Err(VRError::VRPackEmbeddingModelError( - "Multiple embedding models used within the VRPack, meaning standard vector searching is not supported." - .to_string(), - )); - } - - let retrieved_nodes = self.resource.as_trait_object().vector_search_customized( - query, - num_of_results, - traversal_method, - traversal_options, - starting_path, - vector_search_mode, - ); - - // Process the vrkais and the score - let vrkais_with_score: Vec<(VRKai, f32)> = retrieved_nodes - .into_iter() - .filter_map(|node| { - let vrkai = Self::parse_node_to_vrkai(&node.node); - if let Ok(vrkai) = vrkai { - Some((vrkai, node.score)) - } else { - None - } - }) - .collect(); - - Ok(vrkais_with_score) - } - - /// Performs a standard deep vector search within the VRPack, returning the highest scored `RetrievedNode`s across the VRKais stored in the VRPack. - /// Requires that there is only 1 single Embedding Model Used within the VRPack or errors. - pub async fn deep_vector_search( - &self, - query: Embedding, - num_of_vrkais_to_search_into: u64, - num_of_results: u64, - vector_search_mode: Vec, - ) -> Result, VRError> { - self.deep_vector_search_customized( - query, - num_of_vrkais_to_search_into, - TraversalMethod::Exhaustive, - &vec![], - None, - num_of_results, - TraversalMethod::Exhaustive, - &vec![TraversalOption::SetScoringMode(ScoringMode::HierarchicalAverageScoring)], - true, - vector_search_mode, - ) - .await - } - - /// Performs a standard deep vector search within the VRPack, returning the highest scored `RetrievedNode`s across - /// the VRKais stored in the VRPack. Requires that there is only 1 single Embedding Model Used within the VRPack or errors. - /// Customized allows specifying options for the first top-level search for VRKais, and then "deep" options/method for the vector searches into the VRKais to acquire the `RetrievedNode`s. - /// average_out_deep_search_scores: If true, averages out the VRKai top level search score, with the scores found in the nodes inside the VRKai. - pub async fn deep_vector_search_customized( - &self, - query: Embedding, - num_of_vrkais_to_search_into: u64, - traversal_method: TraversalMethod, - traversal_options: &Vec, - vr_pack_starting_path: Option, - num_of_results: u64, - deep_traversal_method: TraversalMethod, - deep_traversal_options: &Vec, - average_out_deep_search_scores: bool, - vector_search_mode: Vec, - ) -> Result, VRError> { - if self.embedding_models_used.keys().len() != 1 { - return Err(VRError::VRPackEmbeddingModelError( - "Multiple embedding models used within the VRPack, meaning standard vector searching is not supported." - .to_string(), - )); - } - - let vrkai_results = self - .vector_search_vrkai_with_score_customized( - query.clone(), - num_of_vrkais_to_search_into, - traversal_method, - traversal_options, - vr_pack_starting_path, - vector_search_mode.clone(), - ) - .await?; - - // Perform vector search on all VRKai resources - let mut retrieved_nodes = Vec::new(); - for (vrkai, score) in vrkai_results { - let mut results = vrkai.resource.as_trait_object().vector_search_customized( - query.clone(), - num_of_results, - deep_traversal_method.clone(), - deep_traversal_options, - None, - vector_search_mode.clone(), - ); - - // If the average out deep search scores flag is set, we average the scores of the retrieved nodes - if average_out_deep_search_scores { - for ret_node in &mut results { - ret_node.score = deep_search_scores_average_out( - None, - score, - vrkai - .resource - .as_trait_object() - .description() - .unwrap_or_else(|| "") - .to_string(), - ret_node.score, - ret_node.node.get_text_content().unwrap_or_else(|_| "").to_string(), - ); - } - } - retrieved_nodes.extend(results); - } - - // Sort the retrieved nodes by score before returning - let sorted_retrieved_nodes = RetrievedNode::sort_by_score(&retrieved_nodes, num_of_results); - - Ok(sorted_retrieved_nodes) - } - - #[cfg(feature = "desktop-only")] - /// Performs a dynamic vector search within the VRPack and returns the most similar VRKais based on the input query String. - /// This allows for multiple embedding models to be used within the VRPack, as it automatically generates the input query embedding. - pub async fn dynamic_vector_search_vrkai( - &self, - input_query: String, - num_of_results: u64, - embedding_generator: RemoteEmbeddingGenerator, - vector_search_mode: Vec, - ) -> Result, VRError> { - self.dynamic_vector_search_vrkai_customized( - input_query, - num_of_results, - &vec![], - None, - embedding_generator, - vector_search_mode, - ) - .await - } - - #[cfg(feature = "desktop-only")] - /// Performs a dynamic vector search within the VRPack and returns the most similar VRKais based on the input query String. - /// Supports customizing the search starting path/traversal options. - /// This allows for multiple embedding models to be used within the VRPack, as it automatically generates the input query embedding. - pub async fn dynamic_vector_search_vrkai_customized( - &self, - input_query: String, - num_of_results: u64, - traversal_options: &Vec, - starting_path: Option, - embedding_generator: RemoteEmbeddingGenerator, - vector_search_mode: Vec, - ) -> Result, VRError> { - let results = self - .dynamic_vector_search_vrkai_with_score_and_path_customized( - input_query, - num_of_results, - traversal_options, - starting_path, - embedding_generator, - vector_search_mode, - ) - .await?; - let vrkais: Vec = results.into_iter().map(|(vrkai, _, _)| vrkai).collect(); - Ok(vrkais) - } - - #[cfg(feature = "desktop-only")] - /// Performs a dynamic vector search within the VRPack and returns the most similar (VRKai, score) based on the input query String. - /// Supports customizing the search starting path/traversal options. - /// This allows for multiple embedding models to be used within the VRPack, as it automatically generates the input query embedding. - pub async fn dynamic_vector_search_vrkai_with_score_and_path_customized( - &self, - input_query: String, - num_of_results: u64, - traversal_options: &Vec, - starting_path: Option, - embedding_generator: RemoteEmbeddingGenerator, - vector_search_mode: Vec, - ) -> Result, VRError> { - let retrieved_nodes = self - .resource - .as_trait_object() - .dynamic_vector_search_customized( - input_query, - num_of_results, - traversal_options, - starting_path, - embedding_generator, - vector_search_mode, - ) - .await?; - - // Process the vrkais and the score - let vrkais_with_score: Vec<(VRKai, f32, VRPath)> = retrieved_nodes - .into_iter() - .filter_map(|node| { - let vrkai = Self::parse_node_to_vrkai(&node.node); - if let Ok(vrkai) = vrkai { - Some((vrkai, node.score, node.retrieval_path)) - } else { - None - } - }) - .collect(); - - Ok(vrkais_with_score) - } - - #[cfg(feature = "desktop-only")] - /// Performs a dynamic deep vector search within the VRPack, returning the highest scored `RetrievedNode`s across - /// the VRKais stored in the VRPack. - /// This allows for multiple embedding models to be used within the VRPack, as it automatically generates the input query embedding. - pub async fn dynamic_deep_vector_search( - &self, - input_query: String, - num_of_vrkais_to_search_into: u64, - num_of_results: u64, - embedding_generator: RemoteEmbeddingGenerator, - vector_search_mode: Vec, - ) -> Result, VRError> { - self.dynamic_deep_vector_search_customized( - input_query, - num_of_vrkais_to_search_into, - &vec![], - None, - num_of_results, - TraversalMethod::Exhaustive, - &vec![TraversalOption::SetScoringMode(ScoringMode::HierarchicalAverageScoring)], - embedding_generator, - true, - vector_search_mode, - ) - .await - } - - #[cfg(feature = "desktop-only")] - /// Performs a dynamic deep vector search within the VRPack, returning the highest scored `RetrievedNode`s across - /// the VRKais stored in the VRPack. This allows for multiple embedding models to be used within the VRPack, as it automatically generates the input query embedding. - /// Customized allows specifying options for the first top-level search for VRKais, and then "deep" options/method for the vector searches into the VRKais to acquire the `RetrievedNode`s. - /// average_out_deep_search_scores: If true, averages out the VRKai top level search score, with the scores found in the nodes inside the VRKai. - pub async fn dynamic_deep_vector_search_customized( - &self, - input_query: String, - num_of_vrkais_to_search_into: u64, - traversal_options: &Vec, - vr_pack_starting_path: Option, - num_of_results: u64, - deep_traversal_method: TraversalMethod, - deep_traversal_options: &Vec, - embedding_generator: RemoteEmbeddingGenerator, - average_out_deep_search_scores: bool, - vector_search_mode: Vec, - ) -> Result, VRError> { - self.dynamic_deep_vector_search_with_vrkai_path_customized( - input_query, - num_of_vrkais_to_search_into, - traversal_options, - vr_pack_starting_path, - num_of_results, - deep_traversal_method, - deep_traversal_options, - embedding_generator, - average_out_deep_search_scores, - vector_search_mode, - ) - .await - .map(|retrieved_nodes| retrieved_nodes.into_iter().map(|(ret_node, _)| ret_node).collect()) - } - - #[cfg(feature = "desktop-only")] - /// Performs a dynamic deep vector search within the VRPack, returning the highest scored `RetrievedNode`s across - /// the VRKais stored in the VRPack (with the relative VRPath of the VRKai in the VRPack). This allows for multiple embedding models to be used within the VRPack, as it automatically generates the input query embedding. - /// Customized allows specifying options for the first top-level search for VRKais, and then "deep" options/method for the vector searches into the VRKais to acquire the `RetrievedNode`s. - /// average_out_deep_search_scores: If true, averages out the VRKai top level search score, with the scores found in the nodes inside the VRKai. - pub async fn dynamic_deep_vector_search_with_vrkai_path_customized( - &self, - input_query: String, - num_of_vrkais_to_search_into: u64, - traversal_options: &Vec, - vr_pack_starting_path: Option, - num_of_results: u64, - deep_traversal_method: TraversalMethod, - deep_traversal_options: &Vec, - embedding_generator: RemoteEmbeddingGenerator, - average_out_deep_search_scores: bool, - vector_search_mode: Vec, - ) -> Result, VRError> { - let mut path_hashmap: HashMap = HashMap::new(); - - let vrkai_results = self - .dynamic_vector_search_vrkai_with_score_and_path_customized( - input_query.clone(), - num_of_vrkais_to_search_into, - traversal_options, - vr_pack_starting_path.clone(), - embedding_generator.clone(), - vector_search_mode.clone(), - ) - .await?; - - let mut retrieved_nodes = Vec::new(); - // Perform vector search on all VRKai resources - for (vrkai, score, path) in vrkai_results { - let query_embedding = embedding_generator.generate_embedding_default(&input_query).await?; - let mut results = vrkai.resource.as_trait_object().vector_search_customized( - query_embedding, - num_of_results, - deep_traversal_method.clone(), - &deep_traversal_options, - None, - vector_search_mode.clone(), - ); - - // Populate the path hashmap with the VRKai header string as the key and the VRPath as the value - let vrkai_header = vrkai.resource.as_trait_object().generate_resource_header(); - path_hashmap.entry(vrkai_header.reference_string()).or_insert(path); - - // If the average out deep search scores flag is set, we average the scores of the retrieved nodes - if average_out_deep_search_scores { - for ret_node in &mut results { - ret_node.score = deep_search_scores_average_out( - Some(input_query.clone()), - score, - vrkai - .resource - .as_trait_object() - .description() - .unwrap_or_else(|| "") - .to_string(), - ret_node.score, - ret_node.node.get_text_content().unwrap_or_else(|_| "").to_string(), - ); - } - } - - retrieved_nodes.extend(results); - } - - // Sort the retrieved nodes by score before returning - let sorted_retrieved_nodes = RetrievedNode::sort_by_score(&retrieved_nodes, num_of_results); - - // Reattach the VRPath from the path hashmap - let retrieved_nodes_with_path = sorted_retrieved_nodes - .into_iter() - .map(|retrieved_node| { - let ref_string = retrieved_node.resource_header.reference_string(); - let default_path = VRPath::root(); - let path = path_hashmap.get(&ref_string).unwrap_or_else(|| &default_path).clone(); - (retrieved_node, path) - }) - .collect(); - - Ok(retrieved_nodes_with_path) - } - - /// Counts the number of VRKais and folders in the BaseVectorResource. - fn num_of_vrkais_and_folders(resource: &BaseVectorResource) -> (u64, u64) { - let nodes = resource.as_trait_object().retrieve_nodes_exhaustive_unordered(None); - - let (vrkais_count, folders_count) = nodes.iter().fold((0u64, 0u64), |(vrkais, folders), retrieved_node| { - match retrieved_node.node.content { - NodeContent::Text(_) => (vrkais + 1, folders), - NodeContent::Resource(_) => (vrkais, folders + 1), - _ => (vrkais, folders), - } - }); - - (vrkais_count, folders_count) - } - - /// Generates a simplified JSON representation of the contents of the VRPack. - pub fn to_json_contents_simplified(&self) -> Result { - let nodes = self - .resource - .as_trait_object() - .retrieve_nodes_exhaustive_unordered(None); - - let mut content_vec = Vec::new(); - - for retrieved_node in nodes { - let ret_path = retrieved_node.retrieval_path; - let path = ret_path.format_to_string(); - let path_depth = ret_path.path_ids.len(); - - let json_node = match &retrieved_node.node.content { - NodeContent::Text(_) => { - json!({ - "name": retrieved_node.node.id, - "type": "vrkai", - "path": path, - "merkle_hash": retrieved_node.node.get_merkle_hash().unwrap_or_default(), - }) - } - NodeContent::Resource(_) => { - json!({ - "name": retrieved_node.node.id, - "type": "folder", - "path": path, - "contents": [], - }) - } - _ => continue, - }; - - if path_depth == 0 { - content_vec.push(json_node); - } else { - let parent_path = ret_path.parent_path().format_to_string(); - Self::insert_node_into_json_vec(&mut content_vec, parent_path, json_node); - } - } - - // Convert hashmap into simpler list of embedding model used strings - let embeddings_models_used_list = self - .embedding_models_used - .keys() - .map(|s| s.to_string()) - .collect::>(); - - let simplified_json = json!({ - "name": self.name, - "vrkai_count": self.vrkai_count, - "folder_count": self.folder_count, - "version": self.version.to_string(), - "embedding_models_used": embeddings_models_used_list, - "metadata": self.metadata, - "content": content_vec, - }); - - serde_json::to_string(&simplified_json) - .map_err(|e| VRError::VRPackParsingError(format!("JSON serialization error: {}", e))) - } - - fn insert_node_into_json_vec(content_vec: &mut Vec, parent_path: String, json_node: JsonValue) { - for node in content_vec.iter_mut() { - if let Some(path) = node["path"].as_str() { - if path == parent_path { - if let Some(contents) = node["contents"].as_array_mut() { - contents.push(json_node); - return; - } - } else if parent_path.starts_with(path) { - if let Some(contents) = node["contents"].as_array_mut() { - Self::insert_node_into_json_vec(contents, parent_path, json_node); - return; - } - } - } - } - // If the parent node is not found, it means the json_node should be added to the root content_vec - content_vec.push(json_node); - } - - /// Inserts a key-value pair into the VRPack's metadata. Replaces existing value if key already exists. - pub fn metadata_insert(&mut self, key: String, value: String) { - self.metadata.insert(key, value); - } - - /// Retrieves the value associated with a key from the VRPack's metadata. - pub fn metadata_get(&self, key: &str) -> Option<&String> { - self.metadata.get(key) - } - - /// Removes a key-value pair from the VRPack's metadata given the key. - pub fn metadata_remove(&mut self, key: &str) -> Option { - self.metadata.remove(key) - } - - /// Note: Intended for internal use only (used by VectorFS). - /// Sets the Merkle hash of a folder node at the specified path. - pub fn _set_folder_merkle_hash(&mut self, path: VRPath, merkle_hash: String) -> Result<(), VRError> { - self.resource - .as_trait_object_mut() - ._set_resource_merkle_hash_at_path(path, merkle_hash)?; - Ok(()) - } - - /// Generates 2 RetrievedNodes which contain either the description + 2nd node, or the first two nodes if no description is available. - /// Sets their score to `1.0` with empty retrieval path & id. This is intended for job vector searches to prepend the intro text about relevant VRs. - /// Only works on OrderedVectorResources, errors otherwise. - pub fn get_vrkai_intro_ret_nodes(&self, path: VRPath) -> Result, VRError> { - let vrkai = self.get_vrkai(path)?; - vrkai.resource.as_trait_object().generate_intro_ret_nodes() - } -} diff --git a/shinkai-libs/shinkai-vector-resources/tests/vector_resource_tests.rs b/shinkai-libs/shinkai-vector-resources/tests/vector_resource_tests.rs deleted file mode 100644 index 7f5033df7..000000000 --- a/shinkai-libs/shinkai-vector-resources/tests/vector_resource_tests.rs +++ /dev/null @@ -1,1377 +0,0 @@ -use shinkai_vector_resources::data_tags::DataTag; -use shinkai_vector_resources::embedding_generator::{EmbeddingGenerator, RemoteEmbeddingGenerator}; -use shinkai_vector_resources::file_parser::file_parser::ShinkaiFileParser; -use shinkai_vector_resources::source::{DistributionInfo, VRSourceReference}; -use shinkai_vector_resources::vector_resource::document_resource::DocumentVectorResource; -use shinkai_vector_resources::vector_resource::map_resource::MapVectorResource; -use shinkai_vector_resources::vector_resource::vrkai::VRKai; -use shinkai_vector_resources::vector_resource::vrpack::VRPack; -use shinkai_vector_resources::vector_resource::BaseVectorResource; -use shinkai_vector_resources::vector_resource::{ - FilterMode, NodeContent, ResultsMode, ScoringMode, TraversalMethod, TraversalOption, VectorResourceCore, - VectorResourceSearch, -}; -use shinkai_vector_resources::vector_resource::{RetrievedNode, VRPath}; -use std::collections::HashMap; - -pub fn default_vector_resource_doc() -> DocumentVectorResource { - let generator = RemoteEmbeddingGenerator::new_default(); - let mut doc = DocumentVectorResource::new_empty( - "3 Animal Facts", - Some("A bunch of facts about animals and wildlife"), - VRSourceReference::new_uri_ref("animalwildlife.com"), - true, - ); - - doc.set_embedding_model_used(generator.model_type()); // Not required, but good practice - doc.update_resource_embedding_blocking(&generator, Some(vec!["animal".to_string(), "wild life".to_string()])) - .unwrap(); - - // Prepare embeddings + data, then add it to the doc - let fact1 = "Dogs are creatures with 4 legs that bark."; - let fact1_embedding = generator.generate_embedding_default_blocking(fact1).unwrap(); - let fact2 = "Camels are slow animals with large humps."; - let fact2_embedding = generator.generate_embedding_default_blocking(fact2).unwrap(); - let fact3 = "Seals swim in the ocean."; - let fact3_embedding = generator.generate_embedding_default_blocking(fact3).unwrap(); - let _ = doc - .append_text_node(fact1, None, fact1_embedding.clone(), &vec![]) - .unwrap(); - let _ = doc - .append_text_node(fact2, None, fact2_embedding.clone(), &vec![]) - .unwrap(); - let _ = doc - .append_text_node(fact3, None, fact3_embedding.clone(), &vec![]) - .unwrap(); - return doc; -} - -fn default_vr_kai() -> VRKai { - let resource = BaseVectorResource::Document(default_vector_resource_doc()); - VRKai::new(resource, None) -} - -fn default_vr_pack() -> VRPack { - let vrkai = default_vr_kai(); - let mut vrpack = VRPack::new_empty(""); - let _ = vrpack.insert_vrkai(&vrkai, VRPath::root(), true); - vrpack -} - -#[test] -fn test_vr_kai_prepare_and_parse_methods() { - let vr_kai = default_vr_kai(); - - // Test encode_as_base64 and from_base64 - let base64_encoded = vr_kai.encode_as_base64().expect("Failed to prepare as base64"); - let parsed_from_base64 = VRKai::from_base64(&base64_encoded).expect("Failed to parse from base64"); - assert_eq!( - serde_json::to_string(&vr_kai).unwrap(), - serde_json::to_string(&parsed_from_base64).unwrap() - ); - - // Test encode_as_bytes and from_bytes - let bytes_encoded = vr_kai.encode_as_bytes().expect("Failed to prepare as bytes"); - let parsed_from_bytes = VRKai::from_bytes(&bytes_encoded).expect("Failed to parse from bytes"); - assert_eq!( - serde_json::to_string(&vr_kai).unwrap(), - serde_json::to_string(&parsed_from_bytes).unwrap() - ); - - // Test to_json and from_json for completeness - let json_str = vr_kai.to_json().expect("Failed to convert to JSON"); - let parsed_from_json = VRKai::from_json(&json_str).expect("Failed to parse from JSON"); - assert_eq!( - serde_json::to_string(&vr_kai).unwrap(), - serde_json::to_string(&parsed_from_json).unwrap() - ); -} - -#[test] -fn test_vr_pack_prepare_and_parse_methods() { - let vr_pack = default_vr_pack(); - - // Test encode_as_base64 and from_base64 - let base64_encoded = vr_pack.encode_as_base64().expect("Failed to prepare as base64"); - let parsed_from_base64 = VRPack::from_base64(&base64_encoded).expect("Failed to parse from base64"); - assert_eq!( - serde_json::to_string(&vr_pack).unwrap(), - serde_json::to_string(&parsed_from_base64).unwrap() - ); - - // Test encode_as_bytes and from_bytes - let bytes_encoded = vr_pack.encode_as_bytes().expect("Failed to prepare as bytes"); - let parsed_from_bytes = VRPack::from_bytes(&bytes_encoded).expect("Failed to parse from bytes"); - assert_eq!( - serde_json::to_string(&vr_pack).unwrap(), - serde_json::to_string(&parsed_from_bytes).unwrap() - ); - - // Test to_json and from_json for completeness - let json_str = vr_pack.to_json().expect("Failed to convert to JSON"); - let parsed_from_json = VRPack::from_json(&json_str).expect("Failed to parse from JSON"); - assert_eq!( - serde_json::to_string(&vr_pack).unwrap(), - serde_json::to_string(&parsed_from_json).unwrap() - ); -} - -#[test] -fn test_remote_embedding_generation() { - let generator = RemoteEmbeddingGenerator::new_default(); - - let dog_embedding = generator.generate_embedding_default_blocking("dog").unwrap(); - let cat_embedding = generator.generate_embedding_default_blocking("cat").unwrap(); - - assert_eq!(dog_embedding, dog_embedding); - assert_eq!(cat_embedding, cat_embedding); - assert_ne!(dog_embedding, cat_embedding); -} - -#[tokio::test] -async fn test_remote_embedding_generation_async_batched() { - let generator = RemoteEmbeddingGenerator::new_default(); - - let inputs = vec![ - "dog", "cat", "lion", "tiger", "elephant", "giraffe", "zebra", "bear", "wolf", "fox", - ] - .into_iter() - .map(|s| s.to_string()) - .collect::>(); - let ids = vec!["".to_string(); inputs.len()]; - let embeddings = generator.generate_embeddings(&inputs, &ids).await.unwrap(); - - for (animal, embedding) in inputs.iter().zip(embeddings.iter()) { - println!("Embedding for {}: {:?}", animal, embedding); - } - - assert_ne!(embeddings[0], embeddings[1]); - assert_ne!(embeddings[0], embeddings[2]); - assert_ne!(embeddings[0], embeddings[3]); - assert_ne!(embeddings[0], embeddings[4]); - assert_ne!(embeddings[0], embeddings[5]); - assert_ne!(embeddings[0], embeddings[6]); - assert_ne!(embeddings[0], embeddings[7]); - assert_ne!(embeddings[0], embeddings[8]); - assert_ne!(embeddings[0], embeddings[9]); -} - -#[test] -fn test_manual_resource_vector_search() { - let generator = RemoteEmbeddingGenerator::new_default(); - - // - // Create a first resource - // - let fact1 = "Dogs are creatures with 4 legs that bark."; - let _fact1_embedding = generator.generate_embedding_default_blocking(fact1).unwrap(); - let fact2 = "Camels are slow animals with large humps."; - let _fact2_embedding = generator.generate_embedding_default_blocking(fact2).unwrap(); - let fact3 = "Seals swim in the ocean."; - let _fact3_embedding = generator.generate_embedding_default_blocking(fact3).unwrap(); - - let doc = default_vector_resource_doc(); - - // Testing JSON serialization/deserialization - let json = doc.to_json().unwrap(); - let deserialized_doc: DocumentVectorResource = DocumentVectorResource::from_json(&json).unwrap(); - assert_eq!(doc, deserialized_doc); - - // Testing basic vector search works - let query_string = "What animal barks?"; - let query_embedding1 = generator.generate_embedding_default_blocking(query_string).unwrap(); - let res = doc.vector_search(query_embedding1.clone(), 1); - assert_eq!(fact1, res[0].node.get_text_content().unwrap().to_string()); - - let query_string2 = "What animal is slow?"; - let query_embedding2 = generator.generate_embedding_default_blocking(query_string2).unwrap(); - let res2 = doc.vector_search(query_embedding2.clone(), 3); - assert_eq!(fact2, res2[0].node.get_text_content().unwrap().to_string()); - - let query_string3 = "What animal swims in the ocean?"; - let query_embedding3 = generator.generate_embedding_default_blocking(query_string3).unwrap(); - let res3 = doc.vector_search(query_embedding3, 2); - assert_eq!(fact3, res3[0].node.get_text_content().unwrap().to_string()); - - // - // Create a 2nd resource, a MapVectorResource - // - let mut map_resource = MapVectorResource::new_empty( - "Tech Facts", - Some("A collection of facts about technology"), - VRSourceReference::new_uri_ref("veryrealtechfacts.com"), - true, - ); - - map_resource.set_embedding_model_used(generator.model_type()); // Not required, but good practice - map_resource - .update_resource_embedding_blocking(&generator, Some(vec!["technology".to_string(), "phones".to_string()])) - .unwrap(); - - // Prepare embeddings + data, then add it to the map resource - let fact4 = "Phones provide the power of the internet in your pocket."; - let fact4_embedding = generator.generate_embedding_default_blocking(fact4).unwrap(); - let _ = map_resource.insert_text_node( - "some_key".to_string(), - fact4.to_string(), - None, - fact4_embedding.clone(), - &vec![], - ); - - // Insert the document resource into the map resource - // To allow for this composability we need to convert the doc into a BaseVectorResource - let doc_resource = BaseVectorResource::from(doc); - let _ = map_resource.insert_vector_resource_node_auto("doc_key", doc_resource, None); - - // - // Create a third resource, a DocumentVectorResource about fruits - // - let mut fruit_doc = DocumentVectorResource::new_empty( - "Fruit Facts", - Some("A collection of facts about fruits"), - VRSourceReference::new_uri_ref("ostensiblyrealfruitfacts.com"), - true, - ); - fruit_doc.set_embedding_model_used(generator.model_type()); // Not required, but good practice - - // Prepare embeddings + data, then add it to the fruit doc - let fact5 = "Apples are sweet and crunchy."; - let fact5_embedding = generator.generate_embedding_default_blocking(fact5).unwrap(); - let fact6 = "Bananas are tasty and come in their own natural packaging."; - let fact6_embedding = generator.generate_embedding_default_blocking(fact6).unwrap(); - let _ = fruit_doc.append_text_node(fact5, None, fact5_embedding.clone(), &vec![]); - let _ = fruit_doc.append_text_node(fact6, None, fact6_embedding.clone(), &vec![]); - - // Insert the map resource into the fruit doc - let map_resource = BaseVectorResource::from(map_resource); - let mut new_map_resource = map_resource.as_map_resource_cloned().unwrap(); - let _ = fruit_doc.append_vector_resource_node_auto(map_resource, None); - - // - // Perform Vector Search Tests Through All Levels/Resources - // - - // Perform a vector search for data 2 levels lower in the fruit doc to ensure - // that vector searches propagate inwards through all resources - let res = fruit_doc.vector_search(query_embedding1.clone(), 5); - assert_eq!(fact1, res[0].node.get_text_content().unwrap().to_string()); - // Perform a VRPath test to validate depth & path formatting - assert_eq!("/3/doc_key/1", res[0].format_path_to_string()); - assert_eq!(2, res[0].retrieval_path.depth()); - - // Perform a vector search for data 1 level lower in the tech map resource - let query_string = "What can I use to access the internet?"; - let query_embedding = generator.generate_embedding_default_blocking(query_string).unwrap(); - let res = fruit_doc.vector_search(query_embedding, 5); - assert_eq!(fact4, res[0].node.get_text_content().unwrap().to_string()); - // Perform a VRPath test to validate depth & path formatting - assert_eq!("/3/some_key", res[0].format_path_to_string()); - assert_eq!(1, res[0].retrieval_path.depth()); - - // Perform a vector search on the fruit doc - // for data on the base level - let query_string = "What fruit has its own packaging?"; - let query_embedding = generator.generate_embedding_default_blocking(query_string).unwrap(); - let res = fruit_doc.vector_search(query_embedding.clone(), 10); - assert_eq!(fact6, res[0].node.get_text_content().unwrap().to_string()); - // Perform a VRPath test to validate depth & path formatting - assert_eq!("/2", res[0].format_path_to_string()); - assert_eq!(0, res[0].retrieval_path.depth()); - - // - // Traversal Tests - // - // Perform UntilDepth(0) traversal to ensure it is working properly, assert the dog fact1 cant be found - let res = fruit_doc.vector_search_customized( - query_embedding1.clone(), - 5, - TraversalMethod::Efficient, - &vec![TraversalOption::UntilDepth(0)], - None, - vec![], - ); - assert_ne!(fact1, res[0].node.get_text_content().unwrap().to_string()); - assert_eq!(0, res[0].retrieval_path.depth()); - // Perform UntilDepth(1) traversal to ensure it is working properly, assert the BaseVectorResource for animals is found (not fact1) - let res = fruit_doc.vector_search_customized( - query_embedding1.clone(), - 5, - TraversalMethod::Exhaustive, - &vec![TraversalOption::UntilDepth(1)], - None, - vec![], - ); - assert_eq!( - "3 Animal Facts", - res[0] - .node - .get_vector_resource_content() - .unwrap() - .as_trait_object() - .name() - ); - // Perform UntilDepth(2) traversal to ensure it is working properly, assert dog fact1 is found at the correct depth - let res = fruit_doc.vector_search_customized( - query_embedding1.clone(), - 5, - TraversalMethod::Exhaustive, - &vec![TraversalOption::UntilDepth(2)], - None, - vec![], - ); - assert_eq!(NodeContent::Text(fact1.to_string()), res[0].node.content); - // Perform MinimumScore option with impossible score to ensure it is working properly - let res = fruit_doc.vector_search_customized( - query_embedding1.clone(), - 5, - TraversalMethod::Exhaustive, - &vec![TraversalOption::MinimumScore(0.99)], - None, - vec![], - ); - assert_eq!(res.len(), 0); - - // Perform MinimumScore option with low score to ensure it is working properly - let res = fruit_doc.vector_search_customized( - query_embedding1.clone(), - 5, - TraversalMethod::Exhaustive, - &vec![TraversalOption::MinimumScore(0.01)], - None, - vec![], - ); - assert!(!res.is_empty()); - - // Perform a VRPath test to validate depth & path formatting - assert_eq!("/3/doc_key/1", res[0].format_path_to_string()); - assert_eq!(2, res[0].retrieval_path.depth()); - - // Perform Exhaustive traversal to ensure it is working properly, assert dog fact1 is found at the correct depth - // By requesting only 1 result, Efficient traversal does not go deeper, while Exhaustive makes it all the way to the bottom - let res = fruit_doc.vector_search_customized( - query_embedding1.clone(), - 1, - TraversalMethod::Exhaustive, - &vec![TraversalOption::SetScoringMode(ScoringMode::HierarchicalAverageScoring)], - None, - vec![], - ); - assert_eq!(NodeContent::Text(fact1.to_string()), res[0].node.content); - let res = fruit_doc.vector_search_customized( - query_embedding1.clone(), - 1, - TraversalMethod::Efficient, - &vec![TraversalOption::SetScoringMode(ScoringMode::HierarchicalAverageScoring)], - None, - vec![], - ); - assert_ne!(NodeContent::Text(fact1.to_string()), res[0].node.content); - - // - // Path Tests - // - let res = fruit_doc.vector_search_customized( - query_embedding1.clone(), - 100, - TraversalMethod::Exhaustive, - &vec![TraversalOption::SetScoringMode(ScoringMode::HierarchicalAverageScoring)], - None, - vec![], - ); - assert_eq!(res.len(), 6); - let path = VRPath::from_string("/3/").unwrap(); - let res = fruit_doc.vector_search_customized( - query_embedding1.clone(), - 100, - TraversalMethod::Exhaustive, - &vec![TraversalOption::SetScoringMode(ScoringMode::HierarchicalAverageScoring)], - Some(path), - vec![], - ); - assert_eq!(res.len(), 4); - let path = VRPath::from_string("/3/doc_key/").unwrap(); - let res = fruit_doc.vector_search_customized( - query_embedding1.clone(), - 100, - TraversalMethod::Exhaustive, - &vec![TraversalOption::SetScoringMode(ScoringMode::HierarchicalAverageScoring)], - Some(path), - vec![], - ); - assert_eq!(res.len(), 3); - - // Metadata Filter Tests - let res = fruit_doc.vector_search_customized( - query_embedding1.clone(), - 100, - TraversalMethod::Exhaustive, - &vec![TraversalOption::SetFilterMode( - FilterMode::ContainsAnyMetadataKeyValues(vec![ - ("key".to_string(), Some("value".to_string())), - ("other_key".to_string(), None), - ]), - )], - None, - vec![], - ); - assert_eq!(res.len(), 0); - - let res = fruit_doc.vector_search_customized( - query_embedding1.clone(), - 100, - TraversalMethod::Exhaustive, - &vec![TraversalOption::SetFilterMode( - FilterMode::ContainsAllMetadataKeyValues(vec![ - ("key".to_string(), Some("value".to_string())), - ("other_key".to_string(), None), - ]), - )], - None, - vec![], - ); - assert_eq!(res.len(), 0); - - // Creating fake metadata to test with - let mut hm1 = HashMap::new(); - hm1.insert("common_key".to_string(), "common_value".to_string()); - hm1.insert("unique_key1".to_string(), "unique_value1".to_string()); - - let mut hm2 = HashMap::new(); - hm2.insert("common_key".to_string(), "common_value".to_string()); - hm2.insert("unique_key2".to_string(), "unique_value2".to_string()); - - let _ = fruit_doc.append_text_node(fact5, Some(hm1), fact5_embedding.clone(), &vec![]); - let _ = fruit_doc.append_text_node(fact6, Some(hm2), fact6_embedding.clone(), &vec![]); - - // Check any filtering, with the common key/value - let res = fruit_doc.vector_search_customized( - query_embedding1.clone(), - 100, - TraversalMethod::Exhaustive, - &vec![TraversalOption::SetFilterMode( - FilterMode::ContainsAnyMetadataKeyValues(vec![ - ("uniq".to_string(), Some("e".to_string())), - ("common_key".to_string(), Some("common_value".to_string())), - ]), - )], - None, - vec![], - ); - assert_eq!(res.len(), 2); - - // Check all filtering, including with None value skipping - let res = fruit_doc.vector_search_customized( - query_embedding1.clone(), - 100, - TraversalMethod::Exhaustive, - &vec![TraversalOption::SetFilterMode( - FilterMode::ContainsAllMetadataKeyValues(vec![ - ("common_key".to_string(), None), - ("unique_key2".to_string(), Some("unique_value2".to_string())), - ]), - )], - None, - vec![], - ); - assert_eq!(res.len(), 1); - - // Check Proximity search results mode - let res = fruit_doc.vector_search_customized( - query_embedding1.clone(), - 100, - TraversalMethod::Exhaustive, - &vec![TraversalOption::SetResultsMode(ResultsMode::ProximitySearch(1, 1))], - None, - vec![], - ); - new_map_resource.print_all_nodes_exhaustive(None, true, false); - assert_eq!(res.len(), 2); - let res = fruit_doc.vector_search_customized( - query_embedding2.clone(), - 100, - TraversalMethod::Exhaustive, - &vec![TraversalOption::SetResultsMode(ResultsMode::ProximitySearch(1, 1))], - None, - vec![], - ); - new_map_resource.print_all_nodes_exhaustive(None, true, false); - assert_eq!(res.len(), 3); - - // The nodes are already included in the first top results proximity, so this checks that there's no more. - let res = fruit_doc.vector_search_customized( - query_embedding2.clone(), - 100, - TraversalMethod::Exhaustive, - &vec![TraversalOption::SetResultsMode(ResultsMode::ProximitySearch(2, 1))], - None, - vec![], - ); - assert_eq!(res.len(), 3); - - let _ = fruit_doc.append_text_node(fact6, None, fact6_embedding.clone(), &vec![]); - let _ = fruit_doc.append_text_node(fact6, None, fact6_embedding.clone(), &vec![]); - - println!("\n\nFruit doc:"); - fruit_doc.print_all_nodes_exhaustive(None, true, false); - - // Check that proximity window works - let query_string = "Whats an apple?"; - let query_embedding_fruit = generator.generate_embedding_default_blocking(query_string).unwrap(); - - let res = fruit_doc.vector_search_customized( - query_embedding_fruit.clone(), - 100, - TraversalMethod::Exhaustive, - &vec![TraversalOption::SetResultsMode(ResultsMode::ProximitySearch(1, 2))], - None, - vec![], - ); - assert_eq!(res.len(), 5); - - let res = fruit_doc.vector_search_customized( - query_embedding_fruit.clone(), - 100, - TraversalMethod::Exhaustive, - &vec![TraversalOption::SetResultsMode(ResultsMode::ProximitySearch(2, 2))], - None, - vec![], - ); - - assert_eq!(res.len(), 6); - - // Verify proximity grouping is working - let res = fruit_doc.vector_search_customized( - query_embedding_fruit.clone(), - 100, - TraversalMethod::Exhaustive, - &vec![TraversalOption::SetResultsMode(ResultsMode::ProximitySearch(1, 2))], - None, - vec![], - ); - - let grouped_results = RetrievedNode::group_proximity_results(&res).unwrap(); - - for (index, group) in grouped_results.iter().enumerate() { - println!("Group {}:", index); - for result in group { - println!("Result: {:?}", result.retrieval_path); - } - } - assert_eq!(grouped_results.len(), 2); - assert_eq!(grouped_results[0].len(), 3); - assert_eq!(grouped_results[1].len(), 2); - - // Check the metadata_index - println!("Metdata index: {:?}", fruit_doc.metadata_index()); - assert_eq!(fruit_doc.metadata_index().get_all_metadata_keys().len(), 3); - - // At path method tests - - // Insert/retrieve tests - let path = VRPath::from_string("/doc_key/").unwrap(); - new_map_resource - .insert_vector_resource_node_at_path( - path, - "4", - BaseVectorResource::Map(new_map_resource.clone()), - None, - new_map_resource.resource_embedding().clone(), - ) - .unwrap(); - let test_path = VRPath::from_string("/doc_key/4/doc_key/3").unwrap(); - let res = new_map_resource.retrieve_node_at_path(test_path.clone(), None).unwrap(); - assert_eq!(res.node.id, "3"); - assert_eq!(res.retrieval_path.to_string(), test_path.to_string()); - - // Validate embedding retrieval works by regenerating the embedding from the text - let embedding = new_map_resource.retrieve_embedding_at_path(test_path.clone()).unwrap(); - match res.node.content { - NodeContent::Text(text) => { - let regenerated_embedding = generator.generate_embedding_blocking(&text, "3").unwrap(); - assert_eq!(embedding, regenerated_embedding); - } - _ => panic!("Node content is not text"), - } - // Proximity retrieval test - let test_path = VRPath::from_string("/doc_key/4/doc_key/3").unwrap(); - new_map_resource.print_all_nodes_exhaustive(None, true, false); - let res = new_map_resource - .proximity_retrieve_nodes_at_path(test_path.clone(), 1, None) - .unwrap(); - assert_eq!(res.len(), 2); - let test_path = VRPath::from_string("/doc_key/4/doc_key/2").unwrap(); - let res = new_map_resource - .proximity_retrieve_nodes_at_path(test_path.clone(), 1, None) - .unwrap(); - assert_eq!(res.len(), 3); - let test_path = VRPath::from_string("/doc_key/4/doc_key/1").unwrap(); - let res = new_map_resource - .proximity_retrieve_nodes_at_path(test_path.clone(), 1, None) - .unwrap(); - assert_eq!(res.len(), 2); - let res = new_map_resource - .proximity_retrieve_nodes_at_path(test_path.clone(), 5000, None) - .unwrap(); - assert_eq!(res.len(), 3); - - // Check that no node is retrieved after removing it by path - let test_path = VRPath::from_string("/doc_key/4/doc_key/3").unwrap(); - let _ = new_map_resource.remove_node_at_path(test_path.clone(), true); - let res = new_map_resource.retrieve_node_at_path(test_path.clone(), None); - assert!(!res.is_ok()); - - // Replace an existing node in a Map Resource and validate it's been changed - let test_path = VRPath::from_string("/doc_key/4/some_key").unwrap(); - let initial_node = new_map_resource.retrieve_node_at_path(test_path.clone(), None).unwrap(); - new_map_resource - .replace_with_text_node_at_path( - test_path.clone(), - "----My new node value----".to_string(), - None, - fact6_embedding.clone(), - vec![], - ) - .unwrap(); - let new_node = new_map_resource.retrieve_node_at_path(test_path.clone(), None).unwrap(); - assert_ne!(initial_node, new_node); - assert_eq!( - NodeContent::Text("----My new node value----".to_string()), - new_node.node.content - ); - - // Replace an existing node in a Doc Resource and validate it's been changed - let test_path = VRPath::from_string("/doc_key/4/doc_key/2").unwrap(); - let initial_node = new_map_resource.retrieve_node_at_path(test_path.clone(), None).unwrap(); - new_map_resource - .replace_with_text_node_at_path( - test_path.clone(), - "----My new node value 2----".to_string(), - None, - fact6_embedding.clone(), - vec![], - ) - .unwrap(); - let new_node = new_map_resource.retrieve_node_at_path(test_path.clone(), None).unwrap(); - assert_ne!(initial_node, new_node); - assert_eq!( - NodeContent::Text("----My new node value 2----".to_string()), - new_node.node.content - ); - - // Append a node into a Doc Resource and validate it's been added - let mut fruit_doc = fruit_doc.clone(); - let path = VRPath::from_string("/3/doc_key/").unwrap(); - fruit_doc - .append_text_node_at_path( - path, - "--- appended text node ---", - None, - new_map_resource.resource_embedding().clone(), - &vec![], - ) - .unwrap(); - let test_path = VRPath::from_string("/3/doc_key/4").unwrap(); - let res = fruit_doc.retrieve_node_at_path(test_path.clone(), None).unwrap(); - assert_eq!(res.node.id, "4"); - assert_eq!(res.retrieval_path.to_string(), test_path.to_string()); - - // Pop the previously appended node - let path = VRPath::from_string("/3/doc_key/").unwrap(); - fruit_doc.pop_node_at_path(path, true).unwrap(); - let test_path = VRPath::from_string("/3/doc_key/4").unwrap(); - let res = fruit_doc.retrieve_node_at_path(test_path.clone(), None); - assert_eq!(res.is_ok(), false); - - // - // Merkelization Tests - // - let path = VRPath::from_string("/3/doc_key/2").unwrap(); - let res = fruit_doc.retrieve_node_at_path(path.clone(), None).unwrap(); - let regened_merkle_hash = res.node._generate_merkle_hash().unwrap(); - assert_eq!(regened_merkle_hash, res.node.get_merkle_hash().unwrap()); - - // Store the original Merkle hash - let original_merkle_hash = fruit_doc.get_merkle_root().unwrap(); - - // Append a node into a Doc Resource - let path = VRPath::from_string("/3/doc_key/").unwrap(); - fruit_doc - .append_text_node_at_path( - path.clone(), - "--- appended text node ---", - None, - new_map_resource.resource_embedding().clone(), - &vec![], - ) - .unwrap(); - - // Retrieve and store the new Merkle hash - let new_merkle_hash = fruit_doc.get_merkle_root().unwrap(); - assert_ne!( - original_merkle_hash, new_merkle_hash, - "Merkle hash should be different after append" - ); - - // Pop the previously appended node - fruit_doc.pop_node_at_path(path, true).unwrap(); - - // Retrieve the Merkle hash again and assert it's the same as the original - let reverted_merkle_hash = fruit_doc.get_merkle_root().unwrap(); - assert_eq!( - original_merkle_hash, reverted_merkle_hash, - "Merkle hash should be the same as original after pop" - ); -} - -#[test] -fn test_manual_syntactic_vector_search() { - let generator = RemoteEmbeddingGenerator::new_default(); - - // - // Create a first resource - // - let mut doc = DocumentVectorResource::new_empty( - "CV Data From Resume", - Some("A bunch of data theoretically parsed out of a CV"), - VRSourceReference::None, - true, - ); - doc.set_embedding_model_used(generator.model_type()); // Not required, but good practice - doc.update_resource_embedding_blocking(&generator, Some(vec!["cv".to_string(), "email".to_string()])) - .unwrap(); - - // Manually create a few test tags - let regex1 = r#"[€$¥£][0-9]{1,3}(,[0-9]{3})*(\.[0-9]{2})?\b|\b€[0-9]{1,3}(\.[0-9]{3})*,(0-9{2})?"#; - let price_tag = DataTag::new("Price", "A price in a major currency", regex1).unwrap(); - - let regex2 = r#"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"#; - let email_tag = DataTag::new("Email", "An email address", regex2).unwrap(); - - let regex3 = r#"(19|20)\d\d[- /.](0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])|(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19|20)\d\d|(0[1-9]|[12][0-9]|3[01])[- /.](0[1-9]|1[012])[- /.](19|20)\d\d"#; - let date_tag = DataTag::new( - "Date", - "Captures dates in three common formats - YYYY-MM-DD, MM/DD/YYYY, and DD/MM/YYYY.", - regex3, - ) - .unwrap(); - - let regex4 = r#"[0-9]+x"#; - let multiplier_tag = DataTag::new("Multiplier", "Strings like `100x` which denote a multiplier.", regex4).unwrap(); - - let data_tags = vec![ - price_tag.clone(), - email_tag.clone(), - date_tag.clone(), - multiplier_tag.clone(), - ]; - - // Prepare embeddings + data, then add it to the doc - let fact1 = "Name: Joe Smith - Email: joesmith@gmail.com"; - let fact1_embedding = generator.generate_embedding_default_blocking(fact1).unwrap(); - let fact2 = "Birthday: 23/03/1980"; - let fact2_embedding = generator.generate_embedding_default_blocking(fact2).unwrap(); - let fact3 = "Previous Accomplishments: Drove $1,500,000 in sales at my previous company, which translate to a 4x improvement compared to when I joined."; - let fact3_embedding = generator.generate_embedding_default_blocking(fact3).unwrap(); - let _ = doc.append_text_node(fact1, None, fact1_embedding.clone(), &data_tags); - let _ = doc.append_text_node(fact2, None, fact2_embedding.clone(), &data_tags); - let _ = doc.append_text_node(fact3, None, fact3_embedding.clone(), &data_tags); - - // println!("Doc data tag index: {:?}", doc.data_tag_index()); - - // Email syntactic vector search - // In Shinkai the LLM Agent would do a Tag Vector Search in node DB to find the email_tag based on user's prompt - // And then calls syntactic_vector_search to guarantee the data retrieved is of the correct structure/"type" - let query = generator - .generate_embedding_default_blocking("What is the applicant's email?") - .unwrap(); - let fetched_data = doc.syntactic_vector_search(query, 1, &[email_tag.name.clone()]); - let fetched_node = fetched_data.first().unwrap(); - assert_eq!(NodeContent::Text(fact1.to_string()), fetched_node.node.content); - - // Date syntactic vector search - let query = generator - .generate_embedding_default_blocking("What is the applicant's birthday?") - .unwrap(); - let fetched_data = doc.syntactic_vector_search(query, 10, &[date_tag.name.clone()]); - let fetched_node = fetched_data.first().unwrap(); - assert_eq!(NodeContent::Text(fact2.to_string()), fetched_node.node.content); - - // Price syntactic vector search - let query = generator - .generate_embedding_default_blocking("Any notable accomplishments in previous positions?") - .unwrap(); - let fetched_data = doc.syntactic_vector_search(query, 2, &[price_tag.name.clone()]); - let fetched_node = fetched_data.first().unwrap(); - assert_eq!(NodeContent::Text(fact3.to_string()), fetched_node.node.content); - - // Multiplier syntactic vector search - let query = generator - .generate_embedding_default_blocking("Any notable accomplishments in previous positions?") - .unwrap(); - let fetched_data = doc.syntactic_vector_search(query, 5, &[multiplier_tag.name.clone()]); - let fetched_node = fetched_data.first().unwrap(); - assert_eq!(NodeContent::Text(fact3.to_string()), fetched_node.node.content); -} - -// #[test] -fn test_checking_embedding_similarity() { - let generator = RemoteEmbeddingGenerator::new_default(); - - // - // Create a first resource - // - let mut doc = DocumentVectorResource::new_empty( - "3 Animal Facts", - Some("A bunch of facts about animals and wildlife"), - VRSourceReference::new_uri_ref("animalwildlife.com"), - true, - ); - - doc.set_embedding_model_used(generator.model_type()); // Not required, but good practice - doc.update_resource_embedding_blocking(&generator, Some(vec!["animal".to_string(), "wild life".to_string()])) - .unwrap(); - - // Prepare embeddings + data, then add it to the doc - let fact1 = "Dogs are creatures with 4 legs that bark."; - let fact1_embedding = generator.generate_embedding_default_blocking(fact1).unwrap(); - let fact2 = "Camels are slow animals with large humps."; - let fact2_embedding = generator.generate_embedding_default_blocking(fact2).unwrap(); - let fact3 = "Seals swim in the ocean."; - let fact3_embedding = generator.generate_embedding_default_blocking(fact3).unwrap(); - doc.append_text_node(fact1, None, fact1_embedding.clone(), &vec![]) - .unwrap(); - doc.append_text_node(fact2, None, fact2_embedding.clone(), &vec![]) - .unwrap(); - doc.append_text_node(fact3, None, fact3_embedding.clone(), &vec![]) - .unwrap(); - - // Testing small alternations to the input text still retain a high similarity score - let res = doc.vector_search(fact1_embedding.clone(), 1); - assert_eq!(fact1, res[0].node.get_text_content().unwrap().to_string()); - assert!(res[0].score > 0.98); - - let fact1_embedding_2 = generator.generate_embedding_default_blocking(fact1).unwrap(); - let res = doc.vector_search(fact1_embedding_2.clone(), 1); - assert!(res[0].score > 0.98); - - let similar_to_fact_1 = "Dogs are creatures with 4 legs that bark ."; - let similar_fact1_embedding = generator - .generate_embedding_default_blocking(similar_to_fact_1) - .unwrap(); - let res = doc.vector_search(similar_fact1_embedding.clone(), 1); - println!("{} : {}", res[0].score, similar_to_fact_1); - assert!(res[0].score > 0.98); - - let similar_to_fact_1 = "Dogs are creatures with 4 legs that bark"; - let similar_fact1_embedding = generator - .generate_embedding_default_blocking(similar_to_fact_1) - .unwrap(); - let res = doc.vector_search(similar_fact1_embedding.clone(), 1); - println!("{} : {}", res[0].score, similar_to_fact_1); - assert!(res[0].score > 0.98); - - let similar_to_fact_1 = "Dogs are creatures with 4 legs that bark"; - let similar_fact1_embedding = generator - .generate_embedding_default_blocking(similar_to_fact_1) - .unwrap(); - let res = doc.vector_search(similar_fact1_embedding.clone(), 1); - println!("{} : {}", res[0].score, similar_to_fact_1); - assert!(res[0].score > 0.98); - - let similar_to_fact_1 = "Dogs -- are || creatures ~ with 4 legs, that bark"; - let similar_fact1_embedding = generator - .generate_embedding_default_blocking(similar_to_fact_1) - .unwrap(); - let res = doc.vector_search(similar_fact1_embedding.clone(), 1); - println!("{} : {}", res[0].score, similar_to_fact_1); - assert!(res[0].score < 0.98); -} - -#[tokio::test] -async fn test_embeddings_coherence() { - let generator = RemoteEmbeddingGenerator::new_default(); - - let mut doc = DocumentVectorResource::new_empty( - "3 Animal Facts", - Some("A bunch of facts about animals and wildlife"), - VRSourceReference::new_uri_ref("animalwildlife.com"), - true, - ); - - doc.set_embedding_model_used(generator.model_type()); // Not required, but good practice - doc.update_resource_embedding(&generator, Some(vec!["animal".to_string(), "wild life".to_string()])) - .await - .unwrap(); - - // Prepare embeddings + data, then add it to the doc - let fact1 = "Dogs are creatures with 4 legs that bark."; - let fact1_embedding = generator.generate_embedding_default(fact1).await.unwrap(); - let fact2 = "Camels are slow animals with large humps."; - let fact2_embedding = generator.generate_embedding_default(fact2).await.unwrap(); - let fact3 = "Seals swim in the ocean."; - let fact3_embedding = generator.generate_embedding_default(fact3).await.unwrap(); - doc.append_text_node(fact1, None, fact1_embedding.clone(), &vec![]) - .unwrap(); - doc.append_text_node(fact2, None, fact2_embedding.clone(), &vec![]) - .unwrap(); - doc.append_text_node(fact3, None, fact3_embedding.clone(), &vec![]) - .unwrap(); - - let cloned_doc = BaseVectorResource::Document(doc.clone()); - let _ = doc.append_vector_resource_node_auto(cloned_doc, None); - - assert!(doc.verify_internal_embeddings_coherence(&generator, 0.5).await.is_ok()); - assert!(doc.verify_internal_embeddings_coherence(&generator, 0.0).await.is_ok()); - assert!(doc.verify_internal_embeddings_coherence(&generator, 23.4).await.is_ok()); -} - -#[tokio::test] -async fn local_txt_parsing_test() { - let generator = RemoteEmbeddingGenerator::new_default(); - let source_file_name = "canada.txt"; - let buffer = std::fs::read(format!("../../files/{}", source_file_name)).unwrap(); - let resource = ShinkaiFileParser::process_file_into_resource( - buffer, - &generator, - source_file_name.to_string(), - None, - &vec![], - generator.model_type().max_input_token_count() as u64, - DistributionInfo::new_empty(), - ) - .await - .unwrap(); - - // Perform vector search - let query_string = "Who's donnacona?".to_string(); - let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); - let results = resource.as_trait_object().vector_search(query_embedding, 3); - - assert!(results[0].score > 0.3); - assert!(results[0].node.get_text_content().unwrap().contains("Donnacona")); - for result in results { - // println!("{}:{}", result.score, result.node.get_text_content().unwrap()); - assert!(result.node.get_text_content().unwrap().len() > 200); - } -} - -#[tokio::test] -async fn local_csv_parsing_test() { - let generator = RemoteEmbeddingGenerator::new_default(); - let source_file_name = "cars.csv"; - let buffer = std::fs::read(format!("../../files/{}", source_file_name)).unwrap(); - let resource = ShinkaiFileParser::process_file_into_resource( - buffer, - &generator, - source_file_name.to_string(), - None, - &vec![], - generator.model_type().max_input_token_count() as u64, - DistributionInfo::new_empty(), - ) - .await - .unwrap(); - - // Perform vector search - let query_string = "Which car has 495 horsepower?".to_string(); - let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); - let results = resource.as_trait_object().vector_search(query_embedding, 3); - - assert!(results[0].score > 0.5); - assert!(results[0].node.get_text_content().unwrap().contains("Corvette")); -} - -#[tokio::test] -async fn local_malformed_csv_parsing_test() { - let malformed_csv = "\ - Year,Make,Model,Description,Price - 1997,Ford,E350,\"ac, abs, moon\",3000 - 1999,Chevy,\"Venture \"\"Extended Edition\"\"\",\"\""; - - let generator = RemoteEmbeddingGenerator::new_default(); - let source_file_name = "cars.csv"; - let buffer = malformed_csv.as_bytes().to_vec(); - let resource = ShinkaiFileParser::process_file_into_resource( - buffer, - &generator, - source_file_name.to_string(), - None, - &vec![], - generator.model_type().max_input_token_count() as u64, - DistributionInfo::new_empty(), - ) - .await - .unwrap(); - - // Perform vector search - let query_string = "What is the price of E350?".to_string(); - let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); - let results = resource.as_trait_object().vector_search(query_embedding, 3); - - assert!(results[0].score > 0.5); - assert!(results[0].node.get_text_content().unwrap().contains("3000")); -} - -#[tokio::test] -async fn local_txt_metadata_parsing_test() { - let input_text = "\ - This is a test content with metadata - timestamp: {{{timestamp:2024-04-17T23:41:30Z}}} - Username: {{{username:myCoolUsername}}} - - Main content should remain unaffected. - - Custom {{{metadata-key:metadata-value}}} should be parsed correctly. - - Likes: {{{likes:999}}} - Reposts: {{{reposts:99}}} - Replies: {{{replies:9}}} - - Invalid metadata values should be ignored. {{{timestamp:br0K3n}}} - - Pure metadata should be removed. - !{{{pg_nums:[19, 20]}}}! - - Make this long enough to exceed max node text size and add more metadata. - Datetime {{{datetime:2000-01-2T02:17:59Z}}} should be parsed too."; - - let generator = RemoteEmbeddingGenerator::new_default(); - let source_file_name = "test_input.txt"; - let buffer = input_text.as_bytes().to_vec(); - let resource = ShinkaiFileParser::process_file_into_resource( - buffer, - &generator, - source_file_name.to_string(), - None, - &vec![], - generator.model_type().max_input_token_count() as u64, - DistributionInfo::new_empty(), - ) - .await - .unwrap(); - - // Perform vector search - let query_string = "What is my username?".to_string(); - let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); - let results = resource.as_trait_object().vector_search(query_embedding, 3); - - assert!(results[0].node.get_text_content().unwrap().contains("myCoolUsername")); - assert!(!results[0] - .node - .get_text_content() - .unwrap() - .contains("{{{timestamp:2024-04-17T23:41:30Z}}}")); - assert!(results[0] - .node - .get_text_content() - .unwrap() - .contains("2024-04-17T23:41:30Z")); - assert!(results[0].node.metadata.as_ref().unwrap().contains_key("likes")); - assert!(!results[0].node.get_text_content().unwrap().contains("pg_nums")); - assert!(results[0].node.metadata.as_ref().unwrap().contains_key("pg_nums")); - assert_ne!( - results[0].node.metadata.as_ref().unwrap().get("datetime").unwrap(), - "br0K3n" - ); - - // Perform another vector search - let query_string2 = "What is the parsed datetime?".to_string(); - let query_embedding2 = generator.generate_embedding_default(&query_string2).await.unwrap(); - let results2 = resource.as_trait_object().vector_search(query_embedding2, 3); - - assert!(results2[0].node.get_text_content().unwrap().contains("2000")); - assert!(results2[0].node.metadata.as_ref().unwrap().contains_key("datetime")); -} - -#[tokio::test] -async fn local_csv_metadata_parsing_test() { - let csv_data = "\ - Country,City,Airline,Price - USA,New York,Delta Airlines,500 - USA,Los Angeles,United Airlines,450 - UK,London,British Airways,{{{price:600}}} - France,Paris,Air France,550 - Germany,Berlin,Lufthansa,400 - Australia,Sydney,Qantas Airways !{{{carry_pets:true}}}!,700"; - - let generator = RemoteEmbeddingGenerator::new_default(); - let source_file_name = "input.csv"; - let buffer = csv_data.as_bytes().to_vec(); - let resource = ShinkaiFileParser::process_file_into_resource( - buffer, - &generator, - source_file_name.to_string(), - None, - &vec![], - generator.model_type().max_input_token_count() as u64, - DistributionInfo::new_empty(), - ) - .await - .unwrap(); - - // Perform vector search - let query_string = "What is the price of a London ticket?".to_string(); - let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); - let results = resource.as_trait_object().vector_search(query_embedding, 3); - - assert!(results[0].score > 0.4); - assert!(results[0].node.get_text_content().unwrap().contains("600")); - assert!(!results[0].node.get_text_content().unwrap().contains("{{{price:600}}}")); - assert_eq!(results[0].node.metadata.as_ref().unwrap().get("price").unwrap(), "600"); - - // Perform another vector search - let query_string2 = "Which airline goes to Sydney?".to_string(); - let query_embedding2 = generator.generate_embedding_default(&query_string2).await.unwrap(); - let results2 = resource.as_trait_object().vector_search(query_embedding2, 3); - - assert!(results2[0].score > 0.4); - assert!(results2[0].node.get_text_content().unwrap().contains("Qantas")); - assert!(!results2[0] - .node - .get_text_content() - .unwrap() - .contains("!{{{carry_pets:true}}}!")); - assert_eq!( - results2[0].node.metadata.as_ref().unwrap().get("carry_pets").unwrap(), - "true" - ); -} - -// #[tokio::test] -async fn local_md_parsing_test() { - let generator = RemoteEmbeddingGenerator::new_default(); - let source_file_name = "parsed_channels.md"; - let buffer = std::fs::read(format!("../../files/{}", source_file_name)).unwrap(); - let resource = ShinkaiFileParser::process_file_into_resource( - buffer, - &generator, - source_file_name.to_string(), - None, - &vec![], - generator.model_type().max_input_token_count() as u64, - DistributionInfo::new_empty(), - ) - .await - .unwrap(); - - resource - .as_trait_object() - .print_all_nodes_exhaustive(None, false, false); - - // Perform vector search - let query_string = "What is happening on OpenSea?".to_string(); - let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); - let results = resource.as_trait_object().vector_search(query_embedding, 3); - - assert!(results[0].score > 0.7); - assert!(results[0] - .node - .get_text_content() - .unwrap() - .contains("KoL Token has successfully launched")); - assert_eq!(results[0].node.metadata.as_ref().unwrap().len(), 9); - assert_eq!(results[0].node.metadata.as_ref().unwrap().get("recasts").unwrap(), "0"); - assert_eq!( - results[0].node.metadata.as_ref().unwrap().get("hash").unwrap(), - "0x43b9a4bc24246855e3d5f4459a7a3d79e50505e6" - ); - - // Get Farcaster Posts - let query_string = "Get Farcaster Posts".to_string(); - let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); - let results = resource.as_trait_object().vector_search(query_embedding, 3); - - assert!(results.iter().all(|node| node.score > 0.6)); - assert!(results - .iter() - .any(|node| node.node.get_text_content().unwrap().contains("Pepe Runner 2049"))); - assert!(results - .iter() - .any(|node| node.node.get_text_content().unwrap().contains("i never remember"))); - assert!(results - .iter() - .any(|node| node.node.get_text_content().unwrap().contains("wowow.shibuya.xyz"))); - - // Shinkai Vector Resources - let query_string = "Explain Shinkai Vector Resources".to_string(); - let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); - let results = resource.as_trait_object().vector_search(query_embedding, 3); - - assert!(results[0].score > 0.6); - assert!(results[0] - .node - .get_text_content() - .unwrap() - .contains("A powerful native Rust")); - - // Test URL metadata parsing - let query_string = "How to import into project?".to_string(); - let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); - let results = resource.as_trait_object().vector_search(query_embedding, 3); - - assert_eq!( - results[0].node.metadata.as_ref().unwrap().get("link-urls").unwrap(), - &serde_json::to_string(&vec!["[desktop-only](https://www.shinkai.com/)"]).unwrap() - ); - assert!(results[0] - .node - .metadata - .as_ref() - .unwrap() - .get("image-urls") - .unwrap() - .contains("WebAssembly_Logo.svg")); - assert!(!results[0] - .node - .get_text_content() - .unwrap() - .contains("WebAssembly_Logo.svg")); -} - -// #[tokio::test] -async fn local_html_parsing_test() { - let generator = RemoteEmbeddingGenerator::new_default(); - let source_file_name = "sample.html"; - let buffer = std::fs::read(format!("../../files/{}", source_file_name)).unwrap(); - let resource = ShinkaiFileParser::process_file_into_resource( - buffer, - &generator, - source_file_name.to_string(), - None, - &vec![], - generator.model_type().max_input_token_count() as u64, - DistributionInfo::new_empty(), - ) - .await - .unwrap(); - - // Perform vector search - let query_string = "Explain Benefits of AI in Video Processing".to_string(); - let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); - let results = resource.as_trait_object().vector_search(query_embedding, 3); - - assert!(results[0].score > 0.8); - assert!(results[0] - .node - .get_text_content() - .unwrap() - .contains("Improved video analysis")); - - // Test URL metadata parsing - let query_string = "Video Processing Solutions with AI".to_string(); - let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); - let results = resource.as_trait_object().vector_search(query_embedding, 3); - - assert!(results[0].score > 0.7); - assert!(results.iter().any(|node| node - .node - .metadata - .as_ref() - .unwrap_or(&HashMap::new()) - .get("image-urls") - .unwrap_or(&String::new()) - .contains("Video Processing"))); - assert!(results.iter().any(|node| node - .node - .metadata - .as_ref() - .unwrap_or(&HashMap::new()) - .get("link-urls") - .unwrap_or(&String::new()) - .contains("AI Video"))); -} - -#[tokio::test] -async fn local_docx_parsing_test() { - let generator = RemoteEmbeddingGenerator::new_default(); - let source_file_name = "decision_log.docx"; - let buffer = std::fs::read(format!("../../files/{}", source_file_name)).unwrap(); - let resource = ShinkaiFileParser::process_file_into_resource( - buffer, - &generator, - source_file_name.to_string(), - None, - &vec![], - generator.model_type().max_input_token_count() as u64, - DistributionInfo::new_empty(), - ) - .await - .unwrap(); - - resource - .as_trait_object() - .print_all_nodes_exhaustive(None, false, false); - - // Perform vector search - let query_string = "What does this document track?".to_string(); - let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); - let results = resource.as_trait_object().vector_search(query_embedding, 3); - - assert!(results[0].score > 0.5); - assert!(results[0] - .node - .get_text_content() - .unwrap() - .contains("open and finalized decisions")); -} - -#[tokio::test] -async fn local_json_parsing_test() { - let generator = RemoteEmbeddingGenerator::new_default(); - let source_file_name = "echo_definition.json"; - let buffer = std::fs::read(format!("../../files/{}", source_file_name)).unwrap(); - let resource = ShinkaiFileParser::process_file_into_resource( - buffer, - &generator, - source_file_name.to_string(), - None, - &vec![], - generator.model_type().max_input_token_count() as u64, - DistributionInfo::new_empty(), - ) - .await - .unwrap(); - - resource - .as_trait_object() - .print_all_nodes_exhaustive(None, false, false); - - // Perform vector search - let query_string = "Shinkai echo description".to_string(); - let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); - let results = resource.as_trait_object().vector_search(query_embedding, 3); - - assert!(results.iter().all(|node| node.score > 0.6)); - assert!(results.iter().any(|node| node - .node - .get_text_content() - .unwrap() - .contains("Echoes the input message"))); -} - -#[tokio::test] -async fn local_xlsx_parsing_test() { - let generator = RemoteEmbeddingGenerator::new_default(); - let source_file_name = "cars.xlsx"; - let buffer = std::fs::read(format!("../../files/{}", source_file_name)).unwrap(); - let resource = ShinkaiFileParser::process_file_into_resource( - buffer, - &generator, - source_file_name.to_string(), - None, - &vec![], - generator.model_type().max_input_token_count() as u64, - DistributionInfo::new_empty(), - ) - .await - .unwrap(); - - // Perform vector search - let query_string = "Which car has 495 horsepower?".to_string(); - let query_embedding = generator.generate_embedding_default(&query_string).await.unwrap(); - let results = resource.as_trait_object().vector_search(query_embedding, 3); - - assert!(results[0].score > 0.5); - assert!(results[0].node.get_text_content().unwrap().contains("Corvette")); -}