Merge remote-tracking branch 'origin/main' into feature/ws-proxy

Author: guillevalin

Cargo.lock

@@ -16,7 +16,7 @@ members = [
 resolver = "2"
 
 [workspace.package]
-version = "1.0.4"
+version = "1.0.5"
 edition = "2021"
 authors = ["Nico Arqueros <nico@shinkai.com>"]
 

Cargo.toml

@@ -2011,18 +2011,26 @@ impl Node {
         }
 
         // Get the internal_comms preference from the database
-        match db.get_preference::<ShinkaiInternalComms>("internal_comms") {
-            Ok(Some(internal_comms)) => {
-                let _ = res.send(Ok(internal_comms.internal_has_sync_default_tools)).await;
-            }
-            Ok(None) => {
-                let _ = res.send(Ok(false)).await;
-            }
+        let internal_comms_synced = match db.get_preference::<ShinkaiInternalComms>("internal_comms") {
+            Ok(Some(internal_comms)) => internal_comms.internal_has_sync_default_tools,
+            Ok(None) => false,
             Err(e) => {
                 eprintln!("Error getting internal_comms preference: {}", e);
-                let _ = res.send(Ok(false)).await;
+                false
             }
-        }
+        };
+
+        // Check if Rust tools are installed
+        let rust_tools_installed = match db.has_rust_tools() {
+            Ok(installed) => installed,
+            Err(e) => {
+                eprintln!("Error checking Rust tools: {}", e);
+                false
+            }
+        };
+
+        // Both conditions must be true
+        let _ = res.send(Ok(internal_comms_synced && rust_tools_installed)).await;
         Ok(())
     }
 

shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands.rs

@@ -40,6 +40,7 @@ use shinkai_message_primitives::{
     },
 };
 use shinkai_sqlite::{errors::SqliteManagerError, SqliteManager};
+use rusqlite::Error as RusqliteError;
 use shinkai_tools_primitives::tools::{
     deno_tools::DenoTool,
     error::ToolError,
@@ -164,7 +165,7 @@ impl Node {
         let vector_start_time = Instant::now();
 
         // Use different search method based on whether we have allowed_tools
-        let vector_search_result = if let Some(tools) = allowed_tools {
+        let vector_search_res = if let Some(tools) = allowed_tools {
             // First generate the embedding from the query
             let embedding = db
                 .generate_embeddings(&sanitized_query)
@@ -186,10 +187,24 @@ impl Node {
 
         // Start the timer for FTS search
         let fts_start_time = Instant::now();
-        let fts_search_result = db.search_tools_fts(&sanitized_query);
+        let fts_search_res = db.search_tools_fts(&sanitized_query);
         let fts_elapsed_time = fts_start_time.elapsed();
         println!("Time taken for FTS search: {:?}", fts_elapsed_time);
 
+        let vector_search_result = match vector_search_res {
+            Ok(v) => Ok(v),
+            Err(SqliteManagerError::ToolNotFound(_))
+            | Err(SqliteManagerError::DatabaseError(RusqliteError::QueryReturnedNoRows)) => Ok(Vec::new()),
+            Err(e) => Err(e),
+        };
+
+        let fts_search_result = match fts_search_res {
+            Ok(v) => Ok(v),
+            Err(SqliteManagerError::ToolNotFound(_))
+            | Err(SqliteManagerError::DatabaseError(RusqliteError::QueryReturnedNoRows)) => Ok(Vec::new()),
+            Err(e) => Err(e),
+        };
+
         match (vector_search_result, fts_search_result) {
             (Ok(vector_tools), Ok(fts_tools)) => {
                 let mut combined_tools = Vec::new();

shinkai-bin/shinkai-node/src/network/v2_api/api_v2_commands_tools.rs

@@ -37,6 +37,9 @@ pub async fn try_to_execute_rust_tool(
 ) -> Result<Value, ToolError> {
     println!("[executing_rust_tool] {}", tool_router_key);
 
+    // Note(Important): if you update the # of tools, you need to update the # of tools in fn has_rust_tools(&self) ->
+    // Result<bool, SqliteManagerError> { ... } in shinkai_sqlite/src/shinkai_tool_manager.rs
+
     let result = match tool_router_key {
         // TODO Keep in sync with definitions_custom.rs
         s if s == "local:::__official_shinkai:::shinkai_llm_map_reduce_processor" => {

shinkai-bin/shinkai-node/src/tools/tool_execution/execution_custom.rs

@@ -44,7 +44,7 @@ fn test_tool_execution_with_config_override() {
     std::env::set_var("WELCOME_MESSAGE", "false");
     let api_key_bearer = std::env::var("API_V2_KEY").unwrap_or_else(|_| "my_api_v2_key".to_string());
     std::env::set_var("API_V2_KEY", api_key_bearer.clone());
-    std::env::set_var("NODE_API_PORT", "9550");
+    std::env::set_var("NODE_API_PORT", "9570");
     std::env::set_var("SKIP_IMPORT_FROM_DIRECTORY", "true");
     std::env::set_var("IS_TESTING", "1");
     let node1_db_path = format!("db_tests/{}", hash_signature_public_key(&unsafe_deterministic_signature_keypair(0).1));
@@ -147,10 +147,10 @@ fn test_tool_execution_with_config_override() {
         .await;
 
         // Create node1 and node2
-        assert!(port_is_available(9550), "Port 9550 is not available");
+        assert!(port_is_available(9570), "Port 9570 is not available");
         assert!(port_is_available(9560), "Port 9560 is not available");
         // Setup API Server task
-        let api_listen_address = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 9550);
+        let api_listen_address = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 9570);
         let api_https_listen_address = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 9560);
 
         let node1_commands_sender_clone = node1_commands_sender.clone();

shinkai-bin/shinkai-node/tests/it/tool_config_override_test.rs

@@ -0,0 +1,42 @@
+import { assertEquals } from "https://deno.land/std/assert/mod.ts";
+import { run } from "./getIdentityDataImpl.ts";
+
+Deno.test(
+  "getIdentityDataImpl - should return identity data for a valid identity",
+  async () => {
+    console.log("Current location:", Deno.cwd());
+    const result = await run(
+      {
+        rpc_urls: [
+          "https://base-sepolia.blockpi.network/v1/rpc/public",
+          "https://sepolia.base.org",
+          "https://base-sepolia-rpc.publicnode.com",
+          "https://base-sepolia.gateway.tenderly.co",
+        ],
+        contract_address: "0x425Fb20ba3874e887336aAa7f3fab32D08135BA9",
+        contract_abi: await Deno.readTextFile(
+          "shinkai-libs/shinkai-crypto-identities/src/abi/ShinkaiRegistry.sol/ShinkaiRegistry.json"
+        ),
+        timeout_rpc_request_ms: 5000,
+      },
+      {
+        identityId: "official.sep-shinkai",
+      }
+    );
+
+    assertEquals(result, {
+      identityData: {
+        boundNft: "4n",
+        stakedTokens: "165000000000000000000n",
+        encryptionKey:
+          "9d89af22de24fcc621ed47a08e98f1c52fada3e49b98462cb02c48237940c85b",
+        signatureKey:
+          "1ffbfa5d90e7b79b395d034f81ec07ea0c7eabd6c9a510014173c6e5081411d1",
+        routing: true,
+        addressOrProxyNodes: [],
+        delegatedTokens: "0n",
+        lastUpdated: 1715000000,
+      },
+    });
+  }
+);

shinkai-libs/shinkai-non-rust-code/src/functions/getIdentityDataImpl.test.ts

@@ -0,0 +1,93 @@
+import { ethers, FetchRequest } from "npm:ethers@6.14.1";
+
+type Configurations = {
+  rpc_urls: string[];
+  contract_address: string;
+  contract_abi: string;
+  timeout_rpc_request_ms: number;
+};
+
+type Parameters = {
+  identityId: string;
+};
+
+type IdentityData = [
+  boundNft: string,
+  stakedTokens: number,
+  encryptionKey: string,
+  signatureKey: string,
+  routing: boolean,
+  addressOrProxyNodes: string[],
+  delegatedTokens: number,
+  lastUpdated: number
+];
+
+export async function run(
+  configurations: Configurations,
+  parameters: Parameters
+) {
+  let identityData: IdentityData | null = null;
+
+  for (const url of configurations.rpc_urls) {
+    const rpcRequest = new FetchRequest(url);
+    rpcRequest.timeout = configurations.timeout_rpc_request_ms;
+    const provider = new ethers.JsonRpcProvider(rpcRequest);
+
+    const contract = new ethers.Contract(
+      configurations.contract_address,
+      configurations.contract_abi,
+      provider
+    );
+    console.log("trying to call getIdentityData", parameters.identityId);
+    try {
+      const identityDataResult = await contract.getIdentityData(
+        parameters.identityId
+      );
+      if (identityDataResult) {
+        const [
+          boundNft,
+          stakedTokens,
+          encryptionKey,
+          signatureKey,
+          routing,
+          addressOrProxyNodes,
+          delegatedTokens,
+          lastUpdated,
+        ] = identityDataResult;
+
+        // Default data is equivalent to unexisting identity
+        if (
+          boundNft == 0 &&
+          stakedTokens == 0 &&
+          encryptionKey === "" &&
+          signatureKey === "" &&
+          !routing &&
+          addressOrProxyNodes.length === 0 &&
+          delegatedTokens == 0 &&
+          lastUpdated == 0
+        ) {
+          console.log("identityData is empty");
+          continue;
+        }
+
+        identityData = {
+          boundNft: boundNft.toString() + "n",
+          stakedTokens: stakedTokens.toString() + "n",
+          encryptionKey,
+          signatureKey,
+          routing,
+          addressOrProxyNodes,
+          delegatedTokens: delegatedTokens.toString() + "n",
+          lastUpdated: parseInt(lastUpdated.toString()),
+        };
+        console.log("identityData", identityData);
+        break;
+      } else {
+        console.log("identityData is empty");
+      }
+    } catch (error) {
+      console.log(`getIdentityData failed for rpc:${url} with error:${error}`);
+    }
+  }
+  return { identityData };
+}