@olane/o-tool 0.3.9 → 0.4.0

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './o-tool.js';
+export * from './interfaces/tool.interface.js';
+export * from './interfaces/run-result.interface.js';
+export * from './interfaces/run-params.interface.js';
+export * from './interfaces/run-tool.interface.js';
+export * from './interfaces/tool-result.interface.js';
+export * from './tool.utils.js';
+export * from './virtual.tool.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,gCAAgC,CAAC;AAC/C,cAAc,sCAAsC,CAAC;AACrD,cAAc,sCAAsC,CAAC;AACrD,cAAc,oCAAoC,CAAC;AACnD,cAAc,uCAAuC,CAAC;AACtD,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from './o-tool.js';
+export * from './interfaces/tool.interface.js';
+export * from './interfaces/run-result.interface.js';
+export * from './interfaces/run-params.interface.js';
+export * from './interfaces/run-tool.interface.js';
+export * from './interfaces/tool-result.interface.js';
+export * from './tool.utils.js';
+export * from './virtual.tool.js';

package/dist/interfaces/run-params.interface.d.ts

@@ -0,0 +1,4 @@
+export interface RunToolParams {
+    [key: string]: unknown;
+}
+//# sourceMappingURL=run-params.interface.d.ts.map

package/dist/interfaces/run-params.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-params.interface.d.ts","sourceRoot":"","sources":["../../src/interfaces/run-params.interface.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC5B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB"}

package/dist/interfaces/run-params.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/run-result.interface.d.ts

@@ -0,0 +1,4 @@
+export interface RunResult {
+    [key: string]: unknown;
+}
+//# sourceMappingURL=run-result.interface.d.ts.map

package/dist/interfaces/run-result.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-result.interface.d.ts","sourceRoot":"","sources":["../../src/interfaces/run-result.interface.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,SAAS;IACxB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB"}

package/dist/interfaces/run-result.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/run-tool.interface.d.ts

@@ -0,0 +1,6 @@
+import { RequestParams } from '@olane/o-protocol';
+export interface RunTool extends RequestParams {
+    tool: string;
+    [key: string]: unknown;
+}
+//# sourceMappingURL=run-tool.interface.d.ts.map

package/dist/interfaces/run-tool.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-tool.interface.d.ts","sourceRoot":"","sources":["../../src/interfaces/run-tool.interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAElD,MAAM,WAAW,OAAQ,SAAQ,aAAa;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB"}

package/dist/interfaces/run-tool.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/tool-result.interface.d.ts

@@ -0,0 +1,4 @@
+export interface ToolResult {
+    [key: string]: any;
+}
+//# sourceMappingURL=tool-result.interface.d.ts.map

package/dist/interfaces/tool-result.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-result.interface.d.ts","sourceRoot":"","sources":["../../src/interfaces/tool-result.interface.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB"}

package/dist/interfaces/tool-result.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/tool.interface.d.ts

@@ -0,0 +1,4 @@
+import { CoreConfig } from '@olane/o-core';
+export interface oToolConfig extends Omit<CoreConfig, 'address'> {
+}
+//# sourceMappingURL=tool.interface.d.ts.map

package/dist/interfaces/tool.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.interface.d.ts","sourceRoot":"","sources":["../../src/interfaces/tool.interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,MAAM,WAAW,WAAY,SAAQ,IAAI,CAAC,UAAU,EAAE,SAAS,CAAC;CAAG"}

package/dist/interfaces/tool.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/o-tool.d.ts

@@ -0,0 +1,8 @@
+import { oCoreNode } 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
+ * @returns A new class that extends the base class and implements the oTool interface
+ */
+export declare function oTool<T extends new (...args: any[]) => oCoreNode>(Base: T): T;
+//# sourceMappingURL=o-tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"o-tool.d.ts","sourceRoot":"","sources":["../src/o-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,SAAS,EAMV,MAAM,eAAe,CAAC;AASvB;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,SAAS,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAkV7E"}

package/dist/o-tool.js

@@ -0,0 +1,284 @@
+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';
+/**
+ * oTool is a mixin that extends the base class and implements the oTool interface
+ * @param Base - The base class to extend
+ * @returns A new class that extends the base class and implements the oTool interface
+ */
+export function oTool(Base) {
+    return class extends Base {
+        constructor(...args) {
+            super(...args);
+            const config = args[0];
+        }
+        validateToolCall(oRequest) {
+            this.logger.debug('Validating tool call: ' + oRequest.method);
+            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();
+            this.logger.debug('Handling protocol: ' + this.address.protocol);
+            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;
+                    return {
+                        error: error.message,
+                    };
+                });
+                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,
+                };
+            });
+            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) {
+            this.logger.debug('Tool handling incoming stream: ' + this.address.protocol);
+            // 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;
+                this.logger.debug('Reached destination, processing payload', payload);
+                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
+                    },
+                });
+                this.logger.debug('Processed request: ', request);
+            }
+            const result = await this.run(request, stream);
+            return result;
+        }
+        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,
+                });
+            }
+            return this.callMyTool(request, stream);
+        }
+        myTools() {
+            return Object.getOwnPropertyNames(this.constructor.prototype)
+                .filter((key) => key.startsWith('_tool_'))
+                .filter((key) => !!key)
+                .map((key) => key.replace('_tool_', ''));
+        }
+        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]();
+        }
+        async callMyTool(request, stream) {
+            const method = request.method;
+            this.logger.debug('Calling tool: ' + method);
+            // @ts-ignore
+            return this[`_tool_${method}`]({ ...request.toJSON(), stream });
+        }
+        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;
+            }
+            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(),
+                                    },
+                                },
+                            ],
+                        },
+                    });
+                }
+                return {
+                    summary: summary,
+                };
+            }
+            catch (e) {
+                this.logger.error('Error indexing network: ', e);
+                throw e;
+            }
+        }
+        async _tool_index_network(request) {
+            this.logger.debug('Indexing network...');
+            // collect all the information from the child nodes
+            return await this.index();
+        }
+        async whoami() {
+            const metadata = await super.whoami();
+            return {
+                tools: this.myTools(),
+                description: this.description,
+            };
+        }
+        async _tool_hello_world(request) {
+            return {
+                message: 'Hello, world!',
+            };
+        }
+        // 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/nodes/client.node.d.ts

@@ -1,5 +1,5 @@
 import { CoreConfig } from '@olane/o-core';
-import { oVirtualTool } from '../virtual.tool';
+import { oVirtualTool } from '../virtual.tool.js';
 export declare class oClientNode extends oVirtualTool {
     constructor(config: CoreConfig);
     configureTransports(): any[];

package/dist/src/nodes/client.node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.node.d.ts","sourceRoot":"","sources":["../../../src/nodes/client.node.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAS,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C,qBAAa,WAAY,SAAQ,YAAY;gBAC/B,MAAM,EAAE,UAAU;IAU9B,mBAAmB,IAAI,GAAG,EAAE;CAG7B"}
+{"version":3,"file":"client.node.d.ts","sourceRoot":"","sources":["../../../src/nodes/client.node.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAS,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,qBAAa,WAAY,SAAQ,YAAY;gBAC/B,MAAM,EAAE,UAAU;IAU9B,mBAAmB,IAAI,GAAG,EAAE;CAG7B"}

package/dist/src/nodes/client.node.js

@@ -1,5 +1,5 @@
 import { defaultLibp2pConfig } from '@olane/o-config';
-import { oVirtualTool } from '../virtual.tool';
+import { oVirtualTool } from '../virtual.tool.js';
 export class oClientNode extends oVirtualTool {
     constructor(config) {
         super({

package/dist/tool.utils.d.ts

@@ -0,0 +1,6 @@
+import { oResponse } from '@olane/o-core';
+import { oRequest } from '@olane/o-protocol';
+export declare class ToolUtils {
+    static buildResponse(request: oRequest, result: any, error: any): oResponse;
+}
+//# sourceMappingURL=tool.utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool.utils.d.ts","sourceRoot":"","sources":["../src/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/tool.utils.js

@@ -0,0 +1,17 @@
+import { oResponse } from '@olane/o-core';
+export class ToolUtils {
+    static buildResponse(request, result, error) {
+        let success = true;
+        if (error) {
+            success = false;
+        }
+        return new oResponse({
+            id: request.id,
+            data: result,
+            error: result?.error,
+            ...{ success },
+            _requestMethod: request.method,
+            _connectionId: request.params?._connectionId,
+        });
+    }
+}

package/dist/virtual.tool.d.ts

@@ -0,0 +1,10 @@
+import { oToolConfig } from './interfaces/tool.interface.js';
+import { oAddress } from '@olane/o-core';
+declare const oVirtualTool_base: any;
+export declare class oVirtualTool extends oVirtualTool_base {
+    constructor(config: oToolConfig & {
+        address: oAddress;
+    });
+}
+export {};
+//# sourceMappingURL=virtual.tool.d.ts.map

package/dist/virtual.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"virtual.tool.d.ts","sourceRoot":"","sources":["../src/virtual.tool.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAC7D,OAAO,EAAE,QAAQ,EAAgB,MAAM,eAAe,CAAC;iCAEG,GAAG;AAA7D,qBAAa,YAAa,SAAQ,iBAA4B;gBAChD,MAAM,EAAE,WAAW,GAAG;QAAE,OAAO,EAAE,QAAQ,CAAA;KAAE;CAGxD"}

package/dist/virtual.tool.js

@@ -0,0 +1,7 @@
+import { oTool } from './o-tool.js';
+import { oVirtualNode } from '@olane/o-core';
+export class oVirtualTool extends oTool(oVirtualNode) {
+    constructor(config) {
+        super(config);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olane/o-tool",
-  "version": "0.3.9",
+  "version": "0.4.0",
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -34,9 +34,9 @@
   "devDependencies": {
     "@eslint/eslintrc": "^3.3.1",
     "@eslint/js": "^9.29.0",
-    "@olane/o-config": "0.3.9",
-    "@olane/o-core": "0.3.9",
-    "@olane/o-protocol": "0.3.9",
+    "@olane/o-config": "file:../o-config",
+    "@olane/o-core": "file:../..",
+    "@olane/o-protocol": "file:../o-protocol",
     "@tsconfig/node20": "^20.1.6",
     "@types/jest": "^30.0.0",
     "@types/uuid": "^10.0.0",
@@ -56,9 +56,9 @@
     "typescript": "^5.8.3"
   },
   "peerDependencies": {
-    "@olane/o-config": "^0.3.9",
-    "@olane/o-core": "^0.3.9",
-    "@olane/o-protocol": "^0.3.9"
+    "@olane/o-config": "^0.4.0",
+    "@olane/o-core": "^0.4.0",
+    "@olane/o-protocol": "^0.4.0"
   },
   "dependencies": {
     "debug": "^4.4.1",