@olane/o-tool 0.6.13 → 0.7.2

package/dist/src/o-tool.js

@@ -1,7 +1,4 @@
-import { CoreUtils, oAddress, oRequest, oToolError, oToolErrorCodes, } from '@olane/o-core';
-import { oProtocolMethods } from '@olane/o-protocol';
-import { ToolUtils } from './tool.utils.js';
-import { v4 as uuidv4 } from 'uuid';
+import { oAddress, oError, oErrorCodes, oRequest, } from '@olane/o-core';
 /**
  * oTool is a mixin that extends the base class and implements the oTool interface
  * @param Base - The base class to extend
@@ -13,289 +10,82 @@ export function oTool(Base) {
             super(...args);
             const config = args[0];
         }
-        validateToolCall(oRequest) {
-            const method = oRequest.method;
-            if (!method) {
-                throw new Error('method parameter is required');
-            }
-            // @ts-ignore
-            if (!this[`_tool_${method}`]) {
-                throw new Error(`Tool ${method} is not implemented`);
-            }
-            return true;
-        }
-        async handleProtocol(address) {
-            this.logger.debug('Handling protocol: ' + address.protocol);
-            await this.p2pNode.handle(address.protocol, this.handleStream.bind(this));
-        }
-        async initialize() {
-            await super.initialize();
-            await this.handleProtocol(this.address);
-            if (this.staticAddress &&
-                this.staticAddress?.toString() !== this.address.toString()) {
-                await this.handleProtocol(this.staticAddress);
-            }
-        }
-        async use(address, data) {
-            // check if we call ourselves
-            if (address.toString() === this.address.toString() ||
-                address.toString() === this.staticAddress.toString()) {
-                // let's call our own tool
-                this.logger.debug('Calling ourselves, skipping...', data);
-                const request = new oRequest({
-                    method: data.method,
-                    params: {
-                        _connectionId: 0,
-                        _requestMethod: data.method,
-                        ...data.params,
-                    },
-                    id: 0,
-                });
-                let success = true;
-                const result = await this.execute(request).catch((error) => {
-                    this.logger.error('Error executing tool: ', error);
-                    success = false;
-                    const responseError = error instanceof oToolError
-                        ? error
-                        : new oToolError(oToolErrorCodes.TOOL_ERROR, error.message);
-                    return {
-                        error: responseError.toJSON(),
-                    };
-                });
-                if (success) {
-                    this.successCount++;
-                }
-                else {
-                    this.errorCount++;
-                }
-                return ToolUtils.buildResponse(request, result, result?.error);
-            }
-            return super.use(address, data);
-        }
-        async handleStream(streamData) {
-            const { stream } = streamData;
-            const requestConfig = await CoreUtils.processStream(stream);
-            const request = new oRequest(requestConfig);
-            let success = true;
-            const result = await this.execute(request, stream).catch((error) => {
-                this.logger.error('Error executing tool: ', error, typeof error);
-                success = false;
-                const responseError = error instanceof oToolError
-                    ? error
-                    : new oToolError(oToolErrorCodes.TOOL_ERROR, error.message);
-                return {
-                    error: responseError.toJSON(),
-                };
-            });
-            if (success) {
-                this.successCount++;
-            }
-            else {
-                this.errorCount++;
-            }
-            // compose the response & add the expected connection + request fields
-            const response = ToolUtils.buildResponse(request, result, result?.error);
-            // add the request method to the response
-            return CoreUtils.sendResponse(response, streamData.stream);
-        }
-        async execute(req, stream) {
-            // const protocolUsageCounter = this.p2pNode.metrics?.registerCounter(
-            //   'libp2p_protocol_custom_track',
-            //   {
-            //     help: 'Total number of protocol interactions',
-            //     label: this.address.toString(),
-            //   },
-            // );
-            // protocolUsageCounter?.increment();
-            let request = req;
-            const requestConfig = req.toJSON();
-            // validate and run the tool
-            this.validateToolCall(request);
-            // check if it's a route and we have reached the destination
-            if (request.method === oProtocolMethods.ROUTE &&
-                request.params.address === this.address.value) {
-                const { payload } = request.params;
-                request = new oRequest({
-                    id: requestConfig.id,
-                    method: payload.method,
-                    params: {
-                        _connectionId: requestConfig.params?._connectionId,
-                        _requestMethod: payload.method,
-                        ...(payload.params || {}), // TODO: is this correct? this line used to be ...payload
-                    },
-                });
-            }
-            const result = await this.run(request, stream);
-            return result;
+        async _tool_stop(request) {
+            this.logger.debug('Stopping tool: ', request.params);
+            this.stop();
+            return {
+                message: 'Tool stopped',
+            };
         }
-        async run(request, stream) {
-            // TODO: this will process the input and prepare required parameters
-            // const processedParams = this.processRunInputs(params);
-            const missingParams = this.findMissingParams(request.method, request.params || {});
-            if (missingParams.length > 0) {
-                this.logger.error('Missing required parameters: ', missingParams, ' with passed params: ', request.params);
-                throw new oToolError(oToolErrorCodes.TOOL_MISSING_PARAMETERS, 'Missing required parameters', {
-                    parameters: missingParams,
-                    toolAddress: this.address.toString(),
-                    data: request.params,
-                });
-            }
-            // resolve o:// addresses
-            // THIS HAS A RECURSIVE CALL issue
-            this.logger.debug('Calling function at address: ', this.address.toString(), 'with request: ', request.method);
-            // const isPlaceholder = this.address.toString().includes('placeholder');
-            // request = await oRequest.translateToRawRequest(request, this);
-            let result = await this.callMyTool(request, stream);
-            // result = await oRequest.translateResultForAgent(result, this);
-            return result;
-            // translate to o:// addresses
+        async _tool_handshake(handshake) {
+            throw new oError(oErrorCodes.NOT_IMPLEMENTED, 'Handshake not implemented');
         }
-        myToolParams(tool) {
-            const func = Object.keys(this).find((key) => key.startsWith('_params_' + tool));
-            if (!func) {
-                throw new Error(`Tool ${tool} not found`);
-            }
-            // @ts-ignore
-            return this[func]();
+        /**
+         * Where all intents go to be resolved.
+         * @param request
+         * @returns
+         */
+        async _tool_intent(request) {
+            throw new oError(oErrorCodes.NOT_IMPLEMENTED, 'Intent not implemented');
         }
-        async _tool_cancel_request(request) {
-            const { requestId } = request.params;
-            delete this.requests[requestId];
+        async _tool_hello_world(request) {
             return {
-                message: 'Request cancelled',
+                message: 'Hello, world!',
             };
         }
-        async callMyTool(request, stream) {
-            const method = request.method;
-            this.logger.debug('Calling tool: ' + method);
-            this.requests[request.id] = request;
-            // @ts-ignore
-            const result = await this[`_tool_${method}`]({
-                ...request.toJSON(),
-                stream,
-            }).catch((error) => {
-                delete this.requests[request.id];
-                throw error;
-            });
-            delete this.requests[request.id];
-            return result;
-        }
-        async index() {
-            const metadata = await this.whoami();
-            if (!metadata.tools.length && !metadata.description) {
-                this.logger.warn('No metadata found, skipping...');
-                return {
-                    provider: 'Empty node',
-                    summary: 'Empty node',
-                };
-            }
-            for (const method in this.methods) {
-                const m = this.methods[method];
-                await this.use(new oAddress('o://vector-store'), {
-                    method: 'add_documents',
-                    params: {
-                        documents: [
-                            {
-                                pageContent: m.description,
-                                metadata: {
-                                    address: this.address?.toString() + '/' + method,
-                                    id: uuidv4(),
-                                },
-                            },
-                        ],
-                    },
-                });
-            }
-            let summary = metadata.description ? metadata.description : null;
-            if (!summary) {
-                this.logger.debug('No description found, generating summary...');
-                const response = await this.use(new oAddress('o://intelligence'), {
-                    method: 'prompt',
-                    params: {
-                        prompt: `You are a helpful assistant that summarizes what a service does by looking at the service description and the details of the tools that the service contains. \n
-                Format the output in JSON using this template:` +
-                            JSON.stringify({
-                                summary: 'string',
-                            }) +
-                            'Do NOT include any other text other than the JSON response. The following is the JSON input of the service: ' +
-                            JSON.stringify(metadata),
-                    },
-                });
-                const { result } = response;
-                const { success } = result;
-                if (!success) {
-                    this.logger.error('Failed to index network: ', result);
-                    throw new Error('Failed to index network');
-                }
-                const data = result.data;
-                const { message } = data;
-                const json = JSON.parse(message);
-                summary = json.summary;
-            }
+        async _tool_index_network(request) {
+            this.logger.debug('Indexing network...');
+            // collect all the information from the child nodes
+            let result = {};
             try {
-                if (summary) {
-                    await this.use(new oAddress('o://vector-store'), {
-                        method: 'add_documents',
-                        params: {
-                            documents: [
-                                {
-                                    pageContent: summary,
-                                    metadata: {
-                                        address: this.address?.toString(),
-                                        id: uuidv4(),
-                                    },
-                                },
-                            ],
-                        },
+                result = await this.index();
+                // index children
+                const children = this.hierarchyManager.getChildren();
+                for (const child of children) {
+                    await this.useChild(child, {
+                        method: 'index_network',
+                        params: {},
                     });
                 }
-                return {
-                    summary: summary,
-                };
+                this.logger.debug('Node + children indexed!');
             }
-            catch (e) {
-                this.logger.error('Error indexing network: ', e);
-                throw e;
+            catch (error) {
+                this.logger.error('Failed to index node:', error);
+                throw error;
             }
+            return result;
         }
-        async _tool_index_network(request) {
-            this.logger.debug('Indexing network...');
-            // collect all the information from the child nodes
-            return await this.index();
+        async _tool_route(request) {
+            if (request.params.address === this.address.toString() ||
+                request.params.address === this.staticAddress.toString()) {
+                this.logger.debug('Route to self, calling tool...');
+                const { payload } = request.params;
+                return this.callMyTool(new oRequest({
+                    method: payload.method,
+                    params: payload.params,
+                    id: request.id,
+                }), request.stream);
+            }
+            return this.router.route(request, this);
+        }
+        async _tool_add_child(request) {
+            throw new oError(oErrorCodes.NOT_IMPLEMENTED, 'Add child not implemented');
         }
-        async whoami() {
-            const metadata = await super.whoami();
+        async _tool_child_register(request) {
+            const { address } = request.params;
+            const childAddress = new oAddress(address);
+            this.hierarchyManager.addChild(childAddress);
             return {
-                // @ts-ignore
-                tools: this.myTools(),
-                description: this.description,
+                message: 'Child node registered with parent!',
             };
         }
-        async _tool_hello_world(request) {
+        // TODO: implement this
+        async _tool_cancel_request(request) {
+            const { requestId } = request.params;
+            // delete this.requestManager.remove(requestId as string);
             return {
-                message: 'Hello, world!',
+                message: 'Request cancelled',
             };
         }
-        // ensure that the required parameters are present
-        findMissingParams(methodName, params) {
-            const method = this.methods[methodName];
-            const protectedMethods = Object.values(oProtocolMethods);
-            if (protectedMethods.includes(methodName)) {
-                return [];
-            }
-            if (!method) {
-                this.logger.warn('No parameter configuration found for method. This is expected for some methods, but may impact AI performance around improvisation.', methodName);
-                return [];
-            }
-            const requiredParams = method.parameters;
-            if (!requiredParams || !requiredParams.filter) {
-                this.logger.error('[Provider] No handshake parameters found for method: ', methodName);
-                return [];
-            }
-            const missingParams = requiredParams
-                .filter((p) => !params[p.name])
-                .filter((p) => p.required === undefined || p.required === true);
-            return missingParams;
-        }
     };
 }

package/dist/src/router/index.d.ts

@@ -0,0 +1,3 @@
+export * from './o-tool.router.js';
+export * from './resolvers/method.resolver.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/router/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/router/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,gCAAgC,CAAC"}

package/dist/src/router/index.js

@@ -0,0 +1,2 @@
+export * from './o-tool.router.js';
+export * from './resolvers/method.resolver.js';

package/dist/src/router/o-request.router.d.ts

@@ -0,0 +1,15 @@
+import { oProtocolMethods, oRouterRequest as oRouterRequestInterface, RequestParams } from '@olane/o-protocol';
+import { oRequest } from '@olane/o-core';
+import { Stream } from '@olane/o-config';
+export declare class oRouterRequest extends oRequest implements oRouterRequestInterface {
+    method: oProtocolMethods.ROUTE;
+    stream?: Stream | undefined;
+    params: RequestParams & {
+        address: string;
+        payload: {
+            [key: string]: unknown;
+        };
+    };
+    constructor(config: oRouterRequestInterface);
+}
+//# sourceMappingURL=o-request.router.d.ts.map

package/dist/src/router/o-request.router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-request.router.d.ts","sourceRoot":"","sources":["../../../src/router/o-request.router.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,cAAc,IAAI,uBAAuB,EACzC,aAAa,EACd,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,qBAAa,cACX,SAAQ,QACR,YAAW,uBAAuB;IAElC,MAAM,EAAE,gBAAgB,CAAC,KAAK,CAAC;IAC/B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,MAAM,EAAE,aAAa,GAAG;QACtB,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE;YACP,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;SACxB,CAAC;KACH,CAAC;gBACU,MAAM,EAAE,uBAAuB;CAO5C"}

package/dist/src/router/o-request.router.js

@@ -0,0 +1,10 @@
+import { oRequest } from '@olane/o-core';
+export class oRouterRequest extends oRequest {
+    constructor(config) {
+        super(config);
+        this.method = config.method;
+        this.params = config.params;
+        this.stream = config.stream;
+        this.id = config.id;
+    }
+}

package/dist/src/router/o-tool.router.d.ts

@@ -0,0 +1,6 @@
+import { oAddress, oCore, oRequest, oRouter, oRouterRequest } from '@olane/o-core';
+export declare abstract class oToolRouter extends oRouter {
+    protected abstract forward(address: oAddress, request: oRequest | oRouterRequest, node?: oCore): Promise<any>;
+    route(request: oRouterRequest, node: oCore): Promise<any>;
+}
+//# sourceMappingURL=o-tool.router.d.ts.map

package/dist/src/router/o-tool.router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-tool.router.d.ts","sourceRoot":"","sources":["../../../src/router/o-tool.router.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,KAAK,EACL,QAAQ,EACR,OAAO,EACP,cAAc,EACf,MAAM,eAAe,CAAC;AAGvB,8BAAsB,WAAY,SAAQ,OAAO;IAC/C,SAAS,CAAC,QAAQ,CAAC,OAAO,CACxB,OAAO,EAAE,QAAQ,EACjB,OAAO,EAAE,QAAQ,GAAG,cAAc,EAClC,IAAI,CAAC,EAAE,KAAK,GACX,OAAO,CAAC,GAAG,CAAC;IAET,KAAK,CAAC,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC;CA+ChE"}

package/dist/src/router/o-tool.router.js

@@ -0,0 +1,49 @@
+import { oAddress, oRouter, oRouterRequest, } from '@olane/o-core';
+import { JSONRPC_VERSION, oProtocolMethods } from '@olane/o-protocol';
+export class oToolRouter extends oRouter {
+    async route(request, node) {
+        const { payload } = request.params;
+        const { address } = request.params;
+        const { method } = payload;
+        const isHandshake = method === oProtocolMethods.HANDSHAKE;
+        const destinationAddress = new oAddress(address);
+        // determine the next hop address from the encapsulated address
+        const { nextHopAddress, targetAddress, requestOverride } = await this.translate(destinationAddress, node);
+        const finalRequest = requestOverride || request;
+        const req = new oRouterRequest({
+            method: finalRequest.method,
+            params: finalRequest.params,
+            id: finalRequest.id,
+            jsonrpc: JSONRPC_VERSION,
+            stream: request.stream,
+        });
+        if (finalRequest && targetAddress) {
+            finalRequest.params.address = targetAddress.toString();
+        }
+        const params = req.params.payload.params;
+        // override the method if it is a handshake
+        if (isHandshake) {
+            try {
+                if (requestOverride) {
+                    // this is likely a method resolver, so we need to override the method
+                    // let's specify the method in the request params to optimize on context window
+                    params.tool = req.params?.payload?.method;
+                }
+            }
+            catch (e) {
+                this.logger.error('Error assigning tool to handshake: ', e);
+            }
+            // update the method to be the handshake
+            req.params.payload.method = method;
+        }
+        else if (requestOverride) {
+            // method resolved
+            req.params.payload.params = {
+                ...payload.params, // initial params
+                ...params, // overloaded params
+            };
+        }
+        // TODO: send the request to the destination
+        return this.forward(nextHopAddress, req, node);
+    }
+}

package/dist/src/router/resolvers/method.resolver.d.ts

@@ -0,0 +1,8 @@
+import { oAddress, oAddressResolver, oTransport, ResolveRequest, RouteResponse } from '@olane/o-core';
+export declare class oMethodResolver extends oAddressResolver {
+    protected readonly address: oAddress;
+    constructor(address: oAddress);
+    get customTransports(): oTransport[];
+    resolve(request: ResolveRequest): Promise<RouteResponse>;
+}
+//# sourceMappingURL=method.resolver.d.ts.map

package/dist/src/router/resolvers/method.resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"method.resolver.d.ts","sourceRoot":"","sources":["../../../../src/router/resolvers/method.resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,gBAAgB,EAIhB,UAAU,EACV,cAAc,EACd,aAAa,EACd,MAAM,eAAe,CAAC;AAKvB,qBAAa,eAAgB,SAAQ,gBAAgB;IACvC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,QAAQ;gBAAjB,OAAO,EAAE,QAAQ;IAIhD,IAAI,gBAAgB,IAAI,UAAU,EAAE,CAEnC;IAEK,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;CAkC/D"}

package/dist/src/router/resolvers/method.resolver.js

@@ -0,0 +1,46 @@
+import { oAddress, oAddressResolver, oCustomTransport, oRouterRequest, } from '@olane/o-core';
+import { JSONRPC_VERSION, oProtocolMethods } from '@olane/o-protocol';
+import { v4 as uuidv4 } from 'uuid';
+export class oMethodResolver extends oAddressResolver {
+    constructor(address) {
+        super(address);
+        this.address = address;
+    }
+    get customTransports() {
+        return [new oCustomTransport('/method')];
+    }
+    async resolve(request) {
+        const { address, node, request: resolveRequest, targetAddress } = request;
+        const nextHopAddress = oAddress.next(node?.address, address);
+        const method = nextHopAddress.protocol.split('/').pop();
+        if (method) {
+            const methodName = await node.findMethod(method);
+            if (methodName) {
+                const req = new oRouterRequest({
+                    method: oProtocolMethods.ROUTE,
+                    params: {
+                        _connectionId: '',
+                        _requestMethod: oProtocolMethods.ROUTE,
+                        address: node.address.toString(),
+                        payload: {
+                            method: methodName,
+                            params: {},
+                        },
+                    },
+                    jsonrpc: JSONRPC_VERSION,
+                    id: uuidv4(),
+                });
+                return {
+                    nextHopAddress: node.address,
+                    targetAddress: node.address,
+                    requestOverride: req,
+                };
+            }
+        }
+        return {
+            nextHopAddress: address,
+            targetAddress: targetAddress,
+            requestOverride: resolveRequest,
+        };
+    }
+}

package/dist/src/utils/method.utils.d.ts

@@ -0,0 +1,7 @@
+import { oAddress, oParameter } from '@olane/o-core';
+import type { oToolBase } from '../o-tool.base';
+export declare class MethodUtils {
+    static getMethod(address: oAddress): string;
+    static findMissingParams(tool: oToolBase, methodName: string, params: any): oParameter[];
+}
+//# sourceMappingURL=method.utils.d.ts.map

package/dist/src/utils/method.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"method.utils.d.ts","sourceRoot":"","sources":["../../../src/utils/method.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAGhD,qBAAa,WAAW;IACtB,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,QAAQ,GAAG,MAAM;IAI3C,MAAM,CAAC,iBAAiB,CACtB,IAAI,EAAE,SAAS,EACf,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,GAAG,GACV,UAAU,EAAE;CA0BhB"}

package/dist/src/utils/method.utils.js

@@ -0,0 +1,26 @@
+import { oProtocolMethods } from '@olane/o-protocol';
+export class MethodUtils {
+    static getMethod(address) {
+        return address.protocol.split('/').pop() || '';
+    }
+    static findMissingParams(tool, methodName, params) {
+        const method = tool.methods[methodName];
+        const protectedMethods = Object.values(oProtocolMethods);
+        if (protectedMethods.includes(methodName)) {
+            return [];
+        }
+        if (!method) {
+            tool.logger.warn('No parameter configuration found for method. This is expected for some methods, but may impact AI performance around improvisation.', methodName);
+            return [];
+        }
+        const requiredParams = method.parameters;
+        if (!requiredParams || !requiredParams.filter) {
+            tool.logger.error('[Provider] No handshake parameters found for method: ', methodName);
+            return [];
+        }
+        const missingParams = requiredParams
+            .filter((p) => !params[p.name])
+            .filter((p) => p.required === undefined || p.required === true);
+        return missingParams;
+    }
+}

package/dist/src/utils/tool.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.utils.d.ts","sourceRoot":"","sources":["../../../src/utils/tool.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C,qBAAa,SAAS;IACpB,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,SAAS;CAc5E"}

package/dist/test/method.spec.d.ts

@@ -1,2 +1 @@
-export {};
 //# sourceMappingURL=method.spec.d.ts.map

package/dist/test/method.spec.js

@@ -1,28 +1,29 @@
-import { oAddress, NodeState, oRequest } from '@olane/o-core';
-import { oVirtualTool } from '../src/virtual.tool.js';
-import { expect } from 'chai';
-describe('o-tool @methods', () => {
-    it('should call the hello_world method', async () => {
-        const node = new oVirtualTool({
-            address: new oAddress('o://test'),
-            leader: null,
-            parent: null,
-        });
-        await node.start();
-        expect(node.state).to.equal(NodeState.RUNNING);
-        // call the tool
-        const req = new oRequest({
-            method: 'hello_world',
-            id: '123',
-            params: {
-                _connectionId: '123',
-                _requestMethod: 'hello_world',
-            },
-        });
-        const data = await node.callMyTool(req);
-        expect(data.message).to.equal('Hello, world!');
-        // stop the node
-        await node.stop();
-        expect(node.state).to.equal(NodeState.STOPPED);
-    });
-});
+"use strict";
+// import { oAddress, NodeState, oRequest } from '@olane/o-core';
+// import { oVirtualTool } from '../src/virtual.tool.js';
+// import { expect } from 'chai';
+// describe('o-tool @methods', () => {
+//   it('should call the hello_world method', async () => {
+//     const node = new oVirtualTool({
+//       address: new oAddress('o://test'),
+//       leader: null,
+//       parent: null,
+//     });
+//     await node.start();
+//     expect(node.state).to.equal(NodeState.RUNNING);
+//     // call the tool
+//     const req = new oRequest({
+//       method: 'hello_world',
+//       id: '123',
+//       params: {
+//         _connectionId: '123',
+//         _requestMethod: 'hello_world',
+//       },
+//     });
+//     const data = await node.callMyTool(req);
+//     expect(data.message).to.equal('Hello, world!');
+//     // stop the node
+//     await node.stop();
+//     expect(node.state).to.equal(NodeState.STOPPED);
+//   });
+// });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olane/o-tool",
-  "version": "0.6.13",
+  "version": "0.7.2",
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -55,9 +55,9 @@
     "typescript": "^5.8.3"
   },
   "peerDependencies": {
-    "@olane/o-config": "^0.6.12",
-    "@olane/o-core": "^0.6.12",
-    "@olane/o-protocol": "^0.6.12"
+    "@olane/o-config": "^0.7.1",
+    "@olane/o-core": "^0.7.1",
+    "@olane/o-protocol": "^0.7.1"
   },
   "dependencies": {
     "debug": "^4.4.1",