updated

Author: Nursid

docs/api/apiaccess/tool/configureToolBox.md

@@ -8,13 +8,13 @@ cbparameters:
       typeName: string
       description: The name of the toolbox to configure
     - name: config
-      typeName: any
-      description: Configuration object for the toolbox
+      typeName: object
+      description: Configuration object containing toolbox-specific settings
   returns:
     signatureTypeName: Promise
-    description: A promise that resolves when configuration is complete
+    description: A promise that resolves with configuration result status
     typeArgs:
-      - type: any
+      - type: object
 data:
   name: configureToolBox
   category: tool
@@ -23,10 +23,14 @@ data:
 <CBBaseInfo/>
 <CBParameters/>
 
-### Example
+### Simple Example
 ```js
-await codeboltMCP.configureToolBox("analyticsTools", {
-  apiKey: "12345",
-  logging: true
+// Basic SQLite toolbox configuration
+const result = await codebolt.tools.configureToolBox('sqlite', {
+  database_path: './my-database.db',
+  read_only: true
 });
-console.log("Toolbox configured successfully");
+
+console.log('Configuration successful:', result?.success);
+```
+

docs/api/apiaccess/tool/executeTool.md

@@ -12,12 +12,12 @@ cbparameters:
       description: The name of the tool to execute
     - name: params
       typeName: object
-      description: Parameters to pass to the tool execution
+      description: Parameters to pass to the tool execution (must match tool's input schema)
   returns:
     signatureTypeName: Promise
     description: A promise that resolves with the tool execution result
     typeArgs:
-      - type: any
+      - type: object
 data:
   name: executeTool
   category: tool
@@ -26,11 +26,34 @@ data:
 <CBBaseInfo/>
 <CBParameters/>
 
-### Example
+### Simple Example
 ```js
-const result = await codeboltMCP.executeTool(
-  "myToolBox",
-  "dataProcessor",
-  { inputData: "test" }
-);
-console.log("Tool execution result:", result);
+// Read a file using filesystem toolbox
+const fsResult = await codebolt.tools.executeTool('filesystem', 'read_file', {
+  path: './index.js'
+});
+
+console.log('✅ Tool execution result:', JSON.stringify(fsResult, null, 2));
+```
+
+```js
+// Different tools require different parameters
+
+// Filesystem tools
+await codebolt.tools.executeTool('filesystem', 'read_file', {
+  path: './file.txt'
+});
+
+await codebolt.tools.executeTool('filesystem', 'write_file', {
+  path: './output.txt',
+  content: 'Hello World'
+});
+
+// SQLite tools
+await codebolt.tools.executeTool('sqlite', 'list_tables', {
+  random_string: 'test'
+});
+
+await codebolt.tools.executeTool('sqlite', 'read_query', {
+  query: 'SELECT * FROM users LIMIT 5'
+});

docs/api/apiaccess/tool/getAvailableToolBoxes.md

@@ -8,7 +8,7 @@ cbparameters:
     signatureTypeName: Promise
     description: A promise resolving to an array of registry toolbox configurations
     typeArgs:
-      - type: any
+      - type: array
 data:
   name: getAvailableToolBoxes
   category: tool
@@ -17,7 +17,19 @@ data:
 <CBBaseInfo/>
 <CBParameters/>
 
+
 ### Example
 ```js
-const availableToolBoxes = await codeboltMCP.getAvailableToolBoxes();
-console.log("Available ToolBoxes:", availableToolBoxes);
+const codebolt = require('@codebolt/codeboltjs');
+
+
+  try {
+        const  getTools= await codebolt.tools.getEnabledToolBoxes();
+        console.log('✅ Toolbox configuration result:', JSON.stringify(getTools, null, 2));
+    } catch (error) {
+        console.log('⚠️  Toolbox configuration failed:', error.message);
+    }
+```
+
+### Status 
+Comming Soon....

docs/api/apiaccess/tool/getEnabledToolBoxes.md

@@ -6,9 +6,9 @@ cbparameters:
   parameters: []
   returns:
     signatureTypeName: Promise
-    description: A promise that resolves to an array of enabled toolbox configurations.
+    description: A promise that resolves to an object containing enabled toolbox configurations with their details.
     typeArgs:
-      - type: any
+      - type: object
 data:
   name: getEnabledToolBoxes
   category: tool
@@ -17,7 +17,27 @@ data:
 <CBBaseInfo/>
 <CBParameters/>
 
+### Response Structure
+```typescript
+{
+  data: {
+    [toolboxName: string]: {
+      name: string;
+      version?: string;
+      description?: string;
+      enabled: boolean;
+      // Additional toolbox configuration properties
+    }
+  }
+}
+```
+
 ### Example
 ```js
-const enabledToolBoxes = await codeboltMCP.getEnabledToolBoxes();
-console.log("Enabled ToolBoxes:", enabledToolBoxes);
+const codebolt = require('@codebolt/codeboltjs');
+
+
+const enabledToolBoxes = await codebolt.tools.getEnabledToolBoxes();
+console.log("Enabled ToolBoxes:", enabledToolBoxes);
+
+```

docs/api/apiaccess/tool/getLocalToolBoxes.md

@@ -8,7 +8,7 @@ cbparameters:
     signatureTypeName: Promise
     description: A promise resolving to an array of locally available toolbox configurations
     typeArgs:
-      - type: any
+      - type: array
 data:
   name: getLocalToolBoxes
   category: tool
@@ -17,7 +17,24 @@ data:
 <CBBaseInfo/>
 <CBParameters/>
 
+### Response Structure
+```typescript
+Array<{
+  name: string;
+  version?: string;
+  description?: string;
+  path?: string;
+  // Additional local toolbox properties
+}>
+```
+
 ### Example
 ```js
-const localToolBoxes = await codeboltMCP.getLocalToolBoxes();
-console.log("Local ToolBoxes:", localToolBoxes);
+const codebolt = require('@codebolt/codeboltjs');
+
+
+const localToolBoxes = await codebolt.tools.getLocalToolBoxes();
+console.log("Local ToolBoxes:", localToolBoxes);
+
+
+```

docs/api/apiaccess/tool/getMentionedToolBoxes.md

@@ -1,17 +1,17 @@
 ---
 name: getMentionedToolBoxes
 cbbaseinfo:
-  description: Extracts toolbox mentions from a user message object.
+  description: Extracts toolbox mentions from a user message object containing MCP references.
 cbparameters:
   parameters:
     - name: userMessage
       typeName: UserMessage
-      description: Message object containing user input with toolbox mentions
+      description: Message object containing user input with toolbox mentions in mentionedMCPs array
   returns:
     signatureTypeName: Promise
-    description: A promise resolving to an array of mentioned toolbox names
+    description: A promise resolving to a response object containing toolbox data and configuration
     typeArgs:
-      - type: any
+      - type: GetMentionedToolBoxesResponse
 data:
   name: getMentionedToolBoxes
   category: tool
@@ -20,11 +20,71 @@ data:
 <CBBaseInfo/>
 <CBParameters/>
 
-### Example
+### UserMessage Structure
 ```js
-const message = {
-  content: "Please use @analyticsTools and @dataProcessing",
-  mentionedMCPs: ["analyticsTools", "dataProcessing"]
+// UserMessage object structure
+const userMessage = {
+  content: "Please use @sqlite and @filesystem for this task",
+  mentionedMCPs: ["sqlite", "filesystem"]  // Array of toolbox names mentioned
 };
-const mentioned = await codeboltMCP.getMentionedToolBoxes(message);
-console.log("Mentioned ToolBoxes:", mentioned);
+```
+
+### Response Structure
+```js
+// GetMentionedToolBoxesResponse object structure
+const response = {
+  data: {
+    mcpServers: {
+      // Each server has configuration details
+      "filesystem": {
+        command: "npx",
+        args: ["-y", "@modelcontextprotocol/server-filesystem"]
+      },
+      "sqlite": {
+        command: "npx",
+        args: ["-y", "@modelcontextprotocol/server-sqlite"],
+        env: {
+          // Optional environment variables
+        }
+      }
+    },
+    enabled: [],  // Array of enabled toolbox names
+    codeboltTools: []  // Array of available Codebolt tool definitions
+  },
+  type: "getAvailableToolBoxesResponse"
+};
+```
+
+### Example
+```js
+// Testing mentioned toolboxes from user message
+try {
+  const message = {
+    content: "Please use @sqlite and @filesystem for this task",
+    mentionedMCPs: ["sqlite", "filesystem"]
+  };
+  
+  const mentionedToolBoxes = await codebolt.tools.getMentionedToolBoxes(message);
+  console.log('   - Message content:', message.content);
+  console.log('   - Mentioned MCPs:', message.mentionedMCPs);
+  
+  // Extract available MCP servers from response
+  const mcpServers = mentionedToolBoxes?.data?.mcpServers || {};
+  const availableServers = Object.keys(mcpServers);
+  console.log('   - Available MCP servers:', availableServers);
+  console.log('   - Enabled toolboxes:', mentionedToolBoxes?.data?.enabled || []);
+  
+} catch (error) {
+  console.log('⚠️  Getting mentioned toolboxes failed:', error.message);
+}
+```
+
+### Error Handling
+```js
+try {
+  const mentionedToolBoxes = await codebolt.tools.getMentionedToolBoxes(userMessage);
+  console.log("Successfully retrieved toolbox data");
+} catch (error) {
+  console.error("Getting mentioned toolboxes failed:", error.message);
+}
+```

docs/api/apiaccess/tool/getTools.md

@@ -1,19 +1,19 @@
 ---
-name: GetTools
+name: getTools
 cbbaseinfo:
-  description: Retrieves detailed information about specific tools from their toolboxes.
+  description: Retrieves detailed information about specific tools from their toolboxes, including schemas and parameters.
 cbparameters:
   parameters:
     - name: tools
       typeName: "Array<{ toolbox: string, toolName: string }>"
-      description: Array of tool identifiers to retrieve
+      description: Array of tool identifiers specifying toolbox and tool name pairs
   returns:
     signatureTypeName: Promise
-    description: A promise resolving to an array of tool configurations
+    description: A promise resolving to an array of detailed tool configurations
     typeArgs:
-      - type: any[]
+      - type: array
 data:
-  name: GetTools
+  name: getTools
   category: tool
   link: getTools.md
 ---
@@ -22,8 +22,33 @@ data:
 
 ### Example
 ```js
-const toolInfo = await codeboltMCP.getTools([
-  { toolbox: "analyticsTools", toolName: "dataAnalyzer" },
-  { toolbox: "dataProcessing", toolName: "csvParser" }
+// Get details for specific tools
+const toolsToGet = [
+  { toolbox: 'filesystem', toolName: 'read_file' },
+  { toolbox: 'sqlite', toolName: 'list_tables' },
+  { toolbox: 'filesystem', toolName: 'write_file' }
+];
+
+const toolDetails = await codeboltMCP.getTools(toolsToGet);
+console.log("Tool Details:", toolDetails);
+
+// Process tool information
+console.log("Tools requested:", toolsToGet.length);
+console.log("Tool details received:", toolDetails?.length || 0);
+
+```
+
+### Single Tool Query
+```js
+// Get details for a single tool
+const singleTool = await codeboltMCP.getTools([
+  { toolbox: 'filesystem', toolName: 'read_file' }
 ]);
-console.log("Tool Details:", toolInfo);
+
+console.log(singleTool)
+
+```
+
+
+### Status 
+comming soon....