feat: Add load toolset method (#17)

twishabansal · web-flow · commit 2449b1867780 · 2025-05-26T10:35:12.000+05:30
* feat: Add basic client and tool * cleanup * clean * add unit tests * increase test cov * test file cleanup * clean * small fix * Added unit tests for tool * cleanup * test cleanup * new tests * del e2e file * test * chore: lint (#11) * lint * lint * lint * move files to different PR * move files to different pr * move files to correct pr * lint * lint * lint * lint * lint * fix test file * lint * rebase * Update protocol.ts * package file cleanup * try * fix config * lint fix * cleanup * clean * fix tests * lint * lint * fix * fix config * fix * fix tests * lint * fix tests * fix docstrings * fix e2e tests * Update test.e2e.ts * feat: add load toolset method * Update client.ts * lint * add e2e tests * lint * Update integration.cloudbuild.yaml * fix test * move files to correct pr * lint * lint * lint * lint * fix test file * lint * fix docstrings * Update client.ts * lint * fix any type errors * lint * clean * remove any * "any" type lint * fix method * change any to unknown * lint * remove unused deps * move deps to correct pr * rename methods * lint * fix method name * rename methods * resolve comments * lint * use parse instead of safeparse * use parse instead of safeparse * any issue fix * any lint * fix any type issue * resolve comments * correct type annotations * rename methods correctly * move from safeparse to parse in tests * update unit tests * fix tests * modularise code * lint * better error handling for manifest parsing * fix type annotations * lint
diff --git a/packages/toolbox-core/src/toolbox_core/client.ts b/packages/toolbox-core/src/toolbox_core/client.ts
@@ -17,6 +17,10 @@ import axios from 'axios';
 import {type AxiosInstance, type AxiosResponse} from 'axios';
 import {ZodManifestSchema, createZodSchemaFromParams} from './protocol';
 import {logApiError} from './errorUtils';
+import {ZodError} from 'zod';
+
+type Manifest = import('zod').infer<typeof ZodManifestSchema>;
+type ToolSchemaFromManifest = Manifest['tools'][string];
 
 /**
  * An asynchronous client for interacting with a Toolbox service.
@@ -34,62 +38,119 @@ class ToolboxClient {
    */
   constructor(url: string, session?: AxiosInstance) {
     this._baseUrl = url;
-    this._session = session || axios.create({baseURL: url});
+    this._session = session || axios.create({baseURL: this._baseUrl});
   }
 
   /**
-   * Asynchronously loads a tool from the server.
-   * Retrieves the schema for the specified tool from the Toolbox server and
-   * returns a callable (`ToolboxTool`) that can be used to invoke the
-   * tool remotely.
-   *
-   * @param {string} name - The unique name or identifier of the tool to load.
-   * @returns {Promise<ReturnType<typeof ToolboxTool>>} A promise that resolves
-   * to a ToolboxTool function, ready for execution.
-   * @throws {Error} If the tool is not found in the manifest, the manifest structure is invalid,
-   * or if there's an error fetching data from the API.
+   * Fetches and parses the manifest from a given API path.
+   * @param {string} apiPath - The API path to fetch the manifest from (e.g., "/api/tool/mytool").
+   * @returns {Promise<Manifest>} A promise that resolves to the parsed manifest.
+   * @throws {Error} If there's an error fetching data or if the manifest structure is invalid.
+   * @private
    */
-  async loadTool(name: string): Promise<ReturnType<typeof ToolboxTool>> {
-    const url = `${this._baseUrl}/api/tool/${name}`;
+  private async _fetchAndParseManifest(apiPath: string): Promise<Manifest> {
+    const url = `${this._baseUrl}${apiPath}`;
     try {
       const response: AxiosResponse = await this._session.get(url);
       const responseData = response.data;
 
       try {
         const manifest = ZodManifestSchema.parse(responseData);
-        if (
-          manifest.tools &&
-          Object.prototype.hasOwnProperty.call(manifest.tools, name)
-        ) {
-          const specificToolSchema = manifest.tools[name];
-          const paramZodSchema = createZodSchemaFromParams(
-            specificToolSchema.parameters
-          );
-          return ToolboxTool(
-            this._session,
-            this._baseUrl,
-            name,
-            specificToolSchema.description,
-            paramZodSchema
-          );
-        } else {
-          throw new Error(`Tool "${name}" not found in manifest.`);
-        }
+        return manifest;
       } catch (validationError) {
-        if (validationError instanceof Error) {
-          throw new Error(
-            `Invalid manifest structure received: ${validationError.message}`
-          );
+        let detailedMessage = `Invalid manifest structure received from ${url}: `;
+        if (validationError instanceof ZodError) {
+          const issueDetails = validationError.issues;
+          detailedMessage += JSON.stringify(issueDetails, null, 2);
+        } else if (validationError instanceof Error) {
+          detailedMessage += validationError.message;
+        } else {
+          detailedMessage += 'Unknown validation error.';
         }
-        throw new Error(
-          'Invalid manifest structure received: Unknown validation error.'
-        );
+        throw new Error(detailedMessage);
       }
     } catch (error) {
+      if (
+        error instanceof Error &&
+        error.message.startsWith('Invalid manifest structure received from')
+      ) {
+        throw error;
+      }
       logApiError(`Error fetching data from ${url}:`, error);
       throw error;
     }
   }
+
+  /**
+   * Creates a ToolboxTool instance from its schema.
+   * @param {string} toolName - The name of the tool.
+   * @param {ToolSchemaFromManifest} toolSchema - The schema definition of the tool from the manifest.
+   * @returns {ReturnType<typeof ToolboxTool>} A ToolboxTool function.
+   * @private
+   */
+  private _createToolInstance(
+    toolName: string,
+    toolSchema: ToolSchemaFromManifest
+  ): ReturnType<typeof ToolboxTool> {
+    const paramZodSchema = createZodSchemaFromParams(toolSchema.parameters);
+    return ToolboxTool(
+      this._session,
+      this._baseUrl,
+      toolName,
+      toolSchema.description,
+      paramZodSchema
+    );
+  }
+
+  /**
+   * Asynchronously loads a tool from the server.
+   * Retrieves the schema for the specified tool from the Toolbox server and
+   * returns a callable (`ToolboxTool`) that can be used to invoke the
+   * tool remotely.
+   *
+   * @param {string} name - The unique name or identifier of the tool to load.
+   * @returns {Promise<ReturnType<typeof ToolboxTool>>} A promise that resolves
+   * to a ToolboxTool function, ready for execution.
+   * @throws {Error} If the tool is not found in the manifest, the manifest structure is invalid,
+   * or if there's an error fetching data from the API.
+   */
+  async loadTool(name: string): Promise<ReturnType<typeof ToolboxTool>> {
+    const apiPath = `/api/tool/${name}`;
+    const manifest = await this._fetchAndParseManifest(apiPath);
+
+    if (
+      manifest.tools && // Zod ensures manifest.tools exists if schema requires it
+      Object.prototype.hasOwnProperty.call(manifest.tools, name)
+    ) {
+      const specificToolSchema = manifest.tools[name];
+      return this._createToolInstance(name, specificToolSchema);
+    } else {
+      throw new Error(`Tool "${name}" not found in manifest from ${apiPath}.`);
+    }
+  }
+
+  /**
+   * Asynchronously fetches a toolset and loads all tools defined within it.
+   *
+   * @param {string | null} [name] - Name of the toolset to load. If null or undefined, loads the default toolset.
+   * @returns {Promise<Array<ReturnType<typeof ToolboxTool>>>} A promise that resolves
+   * to a list of ToolboxTool functions, ready for execution.
+   * @throws {Error} If the manifest structure is invalid or if there's an error fetching data from the API.
+   */
+  async loadToolset(
+    name?: string
+  ): Promise<Array<ReturnType<typeof ToolboxTool>>> {
+    const toolsetName = name || '';
+    const apiPath = `/api/toolset/${toolsetName}`;
+    const manifest = await this._fetchAndParseManifest(apiPath);
+    const tools: Array<ReturnType<typeof ToolboxTool>> = [];
+
+    for (const [toolName, toolSchema] of Object.entries(manifest.tools)) {
+      const toolInstance = this._createToolInstance(toolName, toolSchema);
+      tools.push(toolInstance);
+    }
+    return tools;
+  }
 }
 
 export {ToolboxClient};
diff --git a/packages/toolbox-core/test/e2e/test.e2e.ts b/packages/toolbox-core/test/e2e/test.e2e.ts
@@ -18,9 +18,10 @@ import {ToolboxTool} from '../../src/toolbox_core/tool';
 describe('ToolboxClient E2E Tests', () => {
   let commonToolboxClient: ToolboxClient;
   let getNRowsTool: ReturnType<typeof ToolboxTool>;
+  const testBaseUrl = 'http://localhost:5000';
 
   beforeAll(async () => {
-    commonToolboxClient = new ToolboxClient('http://localhost:5000');
+    commonToolboxClient = new ToolboxClient(testBaseUrl);
   });
 
   beforeEach(async () => {
@@ -50,4 +51,80 @@ describe('ToolboxClient E2E Tests', () => {
       );
     });
   });
+
+  describe('loadToolset', () => {
+    const specificToolsetTestCases = [
+      {
+        name: 'my-toolset',
+        expectedLength: 1,
+        expectedTools: ['get-row-by-id'],
+      },
+      {
+        name: 'my-toolset-2',
+        expectedLength: 2,
+        expectedTools: ['get-n-rows', 'get-row-by-id'],
+      },
+    ];
+
+    specificToolsetTestCases.forEach(testCase => {
+      it(`should successfully load the specific toolset "${testCase.name}"`, async () => {
+        const loadedTools = await commonToolboxClient.loadToolset(
+          testCase.name
+        );
+
+        expect(Array.isArray(loadedTools)).toBe(true);
+        expect(loadedTools.length).toBe(testCase.expectedLength);
+
+        const loadedToolNames = new Set(
+          loadedTools.map(tool => tool.getName())
+        );
+        expect(loadedToolNames).toEqual(new Set(testCase.expectedTools));
+
+        for (const tool of loadedTools) {
+          expect(typeof tool).toBe('function');
+          expect(tool.getName).toBeInstanceOf(Function);
+          expect(tool.getDescription).toBeInstanceOf(Function);
+          expect(tool.getParamSchema).toBeInstanceOf(Function);
+        }
+      });
+    });
+
+    it('should successfully load the default toolset (all tools)', async () => {
+      const loadedTools = await commonToolboxClient.loadToolset(); // Load the default toolset (no name provided)
+      expect(Array.isArray(loadedTools)).toBe(true);
+      expect(loadedTools.length).toBeGreaterThan(0);
+      const getNRowsToolFromSet = loadedTools.find(
+        tool => tool.getName() === 'get-n-rows'
+      );
+
+      expect(getNRowsToolFromSet).toBeDefined();
+      expect(typeof getNRowsToolFromSet).toBe('function');
+      expect(getNRowsToolFromSet?.getName()).toBe('get-n-rows');
+      expect(getNRowsToolFromSet?.getDescription()).toBeDefined();
+      expect(getNRowsToolFromSet?.getParamSchema()).toBeDefined();
+
+      const loadedToolNames = new Set(loadedTools.map(tool => tool.getName()));
+      const expectedDefaultTools = new Set([
+        'get-row-by-content-auth',
+        'get-row-by-email-auth',
+        'get-row-by-id-auth',
+        'get-row-by-id',
+        'get-n-rows',
+      ]);
+      expect(loadedToolNames).toEqual(expectedDefaultTools);
+
+      for (const tool of loadedTools) {
+        expect(typeof tool).toBe('function');
+        expect(tool.getName).toBeInstanceOf(Function);
+        expect(tool.getDescription).toBeInstanceOf(Function);
+        expect(tool.getParamSchema).toBeInstanceOf(Function);
+      }
+    });
+
+    it('should throw an error when trying to load a non-existent toolset', async () => {
+      await expect(
+        commonToolboxClient.loadToolset('non-existent-toolset')
+      ).rejects.toThrow('Request failed with status code 404');
+    });
+  });
 });
diff --git a/packages/toolbox-core/test/test.client.ts b/packages/toolbox-core/test/test.client.ts
