@superblocksteam/sdk 1.5.0 → 1.5.2

package/src/socket/signing.ts

@@ -11,12 +11,12 @@ export async function signResource({
   token,
   branchName,
   resource,
-  agentUrls,
+  agentUrl,
 }: {
   token: string;
   branchName: string;
   resource: ApiResource | GenericResource;
-  agentUrls: string[];
+  agentUrl: string;
 }): Promise<Signature> {
   const requestResource: Record<string, any> = {
     branchName: branchName ?? "main",
@@ -28,22 +28,18 @@ export async function signResource({
     requestResource.literal = (resource as GenericResource).literal;
   }
 
-  try {
-    const resp = await callAgentFallBack<SignatureResponse>({
-      baseUrls: agentUrls,
-      path: "v1/signature/sign",
-      method: "post",
-      token: token,
-      data: { resource: requestResource },
-    });
-    return resp.signature;
-  } catch (e) {
-    throw new Error("No agents available to sign the resource");
-  }
+  const resp = await callAgent<SignatureResponse>({
+    baseUrl: agentUrl,
+    path: "v1/signature/sign",
+    method: "post",
+    token: token,
+    data: { resource: requestResource },
+  });
+  return resp.signature;
 }
 
 export async function verifyResources({
-  agentUrls,
+  agentUrl,
   token,
   branchName,
   resources,
@@ -51,63 +47,58 @@ export async function verifyResources({
   resources: Array<GenericResource | ApiResource>;
   token: string;
   branchName: string;
-  agentUrls: string[];
+  agentUrl: string;
 }): Promise<void> {
-  try {
-    await callAgentFallBack<{ keyId: string }>({
-      baseUrls: agentUrls,
-      path: "v1/signature/verify",
-      method: "post",
-      token: token,
-      data: {
-        resources: resources.map((res) => {
-          if ((res as ApiResource).api) {
-            return {
-              // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-              api: getSanitizedApi((res as ApiResource).api),
-              branchName: branchName ?? "main",
-            };
-          }
+  await callAgent<{ keyId: string }>({
+    baseUrl: agentUrl,
+    path: "v1/signature/verify",
+    method: "post",
+    token: token,
+    data: {
+      resources: resources.map((res) => {
+        if ((res as ApiResource).api) {
           return {
-            ...res,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            api: getSanitizedApi((res as ApiResource).api),
             branchName: branchName ?? "main",
           };
-        }),
-      },
-    });
-  } catch (e) {
-    throw new Error("No agents available to verify the resource");
-  }
+        }
+        return {
+          ...res,
+          branchName: branchName ?? "main",
+        };
+      }),
+    },
+  });
 }
 
-async function callAgentFallBack<T>({
-  baseUrls,
+async function callAgent<T>({
+  baseUrl,
   path,
   method,
   token,
   data,
 }: {
-  baseUrls: string[];
+  baseUrl: string;
   path: string;
   method: Method;
   token: string;
   data: any;
 }): Promise<T> {
-  for (const baseUrl of baseUrls) {
-    try {
-      const url = new URL(path, baseUrl);
-      const config: AxiosRequestConfig = {
-        url: url.toString(),
-        method: method,
-        headers: {
-          Authorization: "Bearer " + token,
-        },
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        data: data,
-      };
-      const resp = await axios<T>(config);
-      return resp.data;
-    } catch (e) {}
+  try {
+    const url = new URL(path, baseUrl);
+    const config: AxiosRequestConfig = {
+      url: url.toString(),
+      method: method,
+      headers: {
+        Authorization: "Bearer " + token,
+      },
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      data: data,
+    };
+    const resp = await axios<T>(config);
+    return resp.data;
+  } catch (error) {
+    throw new Error(`Failed to request the agent ${baseUrl}. Error: ${error}`);
   }
-  throw new Error("Failed to request ");
 }

package/src/utils.ts

@@ -1,3 +1,4 @@
+import axios, { AxiosRequestConfig } from "axios";
 import {
   Agent,
   AgentStatus,
@@ -7,11 +8,46 @@ import {
   transcribeAudioToTextTranslateToEnglishTruthyValues,
 } from "./types";
 
-export function getAgentUrls(agents: Agent[], agentType: AgentType): string[] {
-  const filtered = agents.filter(
+export async function getAgentUrl(
+  agents: Agent[],
+  agentType: AgentType,
+  profile?: string,
+  healthCheck = true
+): Promise<string> {
+  let filtered = agents.filter(
     (a) => a.type === agentType && a.status === AgentStatus.ACTIVE
   );
-  return filtered.map((f) => f.url);
+  if (profile) {
+    filtered = agents.filter(
+      (a) =>
+        a.tags.profile &&
+        (a.tags.profile.includes("*") || a.tags.profile.includes(profile))
+    );
+  }
+  if (healthCheck) {
+    const coroutines: Promise<string>[] = [];
+    for (const agent of filtered) {
+      const p: Promise<string> = (async () => {
+        const url = new URL("health", agent.url);
+        const config: AxiosRequestConfig = {
+          url: url.toString(),
+          method: "get",
+          headers: {},
+        };
+        await axios(config);
+        return agent.url;
+      })();
+      coroutines.push(p);
+    }
+    try {
+      return await Promise.any(coroutines);
+    } catch (e) {
+      throw new Error("No available agents");
+    }
+  } else {
+    const randomIndex = Math.floor(Math.random() * filtered.length);
+    return filtered[randomIndex].url;
+  }
 }
 
 export const sanitizeV2RequestBody = (

package/tsconfig.json

@@ -6,7 +6,7 @@
     "outDir": "dist",
     "rootDir": "src",
     "strict": true,
-    "target": "es2019",
+    "target": "es2021",
     "esModuleInterop": true,
     "skipLibCheck": true
   },