@olane/o-tool 0.6.13 → 0.7.2

package/README.md

@@ -1 +1,382 @@
-# o-tool
+# @olane/o-tool
+
+> Tool augmentation system for Olane OS - build specialized tool nodes (applications) that AI agents use
+
+The tool system layer of Olane OS. Transform generalist LLMs into specialists through tool augmentation and context injection - create discoverable, validated capabilities without fine-tuning models.
+
+[![npm version](https://img.shields.io/npm/v/@olane/o-tool.svg)](https://www.npmjs.com/package/@olane/o-tool)
+[![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](https://opensource.org/licenses/ISC)
+
+## Features
+
+- 🔧 **Convention-Based Tool Registration** - Automatic discovery via `_tool_` prefix
+- ✅ **Built-in Parameter Validation** - Type-safe parameter checking with clear error messages
+- 🔍 **Automatic Discovery** - Tools indexed in vector store for semantic search by agents
+- 🏗️ **Mixin Architecture** - Compose tool capabilities with any `oCore` class
+- 🌲 **Hierarchical Organization** - Inherit context and capabilities from parent tools
+- 📡 **Streaming Support** - Handle long-running operations with progress updates
+- 🎯 **Built-in Tools** - Handshake, routing, indexing, and lifecycle management included
+
+## Installation
+
+```bash
+npm install @olane/o-tool
+```
+
+## Quick Start
+
+### Creating a Simple Tool
+
+```typescript
+import { oToolBase, oRequest, ToolResult } from '@olane/o-tool';
+import { oAddress } from '@olane/o-core';
+
+class CalculatorTool extends oToolBase {
+  constructor() {
+    super({
+      address: new oAddress('o://calculator'),
+      description: 'Performs mathematical calculations',
+      methods: {
+        add: {
+          description: 'Add two numbers',
+          parameters: {
+            a: { type: 'number', required: true },
+            b: { type: 'number', required: true }
+          }
+        }
+      }
+    });
+  }
+
+  // Tool methods use _tool_ prefix for automatic registration
+  async _tool_add(request: oRequest): Promise<ToolResult> {
+    const { a, b } = request.params;
+    return { result: a + b };
+  }
+}
+
+// Start the tool
+const calculator = new CalculatorTool();
+await calculator.start();
+
+// Use the tool
+const response = await calculator.use({
+  method: 'add',
+  params: { a: 5, b: 3 }
+});
+
+console.log(response.result); // { result: 8 }
+```
+
+### Using the Mixin Pattern
+
+Extend any `oCore` class with tool capabilities:
+
+```typescript
+import { oTool } from '@olane/o-tool';
+import { oNode } from '@olane/o-node';
+
+class MyNetworkTool extends oTool(oNode) {
+  constructor(config) {
+    super(config);
+  }
+
+  async _tool_process(request: oRequest): Promise<ToolResult> {
+    // Your custom logic here
+    return { status: 'processed' };
+  }
+}
+```
+
+## Core Concepts
+
+### Tool Convention Pattern
+
+Tools are automatically discovered using naming conventions:
+
+- **`_tool_methodName`** - Defines an executable tool method
+- **`_params_methodName`** - Defines parameter schema (optional)
+
+```typescript
+class WeatherTool extends oToolBase {
+  // Executable tool method
+  async _tool_get_forecast(request: oRequest): Promise<ToolResult> {
+    const { city } = request.params;
+    return { forecast: '☀️ Sunny, 72°F' };
+  }
+
+  // Parameter schema (optional)
+  _params_get_forecast() {
+    return {
+      city: { type: 'string', required: true, description: 'City name' }
+    };
+  }
+}
+```
+
+### Built-in Tools
+
+Every tool automatically includes these methods:
+
+| Method | Description |
+|--------|-------------|
+| `handshake` | Capability negotiation between agents |
+| `route` | Route requests through the hierarchy |
+| `index_network` | Index tool in vector store for discovery |
+| `hello_world` | Connectivity test |
+| `stop` | Graceful shutdown |
+| `child_register` | Register child tools in hierarchy |
+
+### Automatic Validation
+
+Parameter validation happens automatically before tool execution:
+
+```typescript
+// Missing required parameters trigger clear errors
+try {
+  await tool.use({ method: 'add', params: { a: 5 } });
+} catch (error) {
+  // Error: Missing required parameters: ["b"]
+  console.log(error.message);
+}
+```
+
+## Examples
+
+### Search Tool with Vector Store Integration
+
+```typescript
+import { oLaneTool } from '@olane/o-lane';
+import { oAddress, oRequest } from '@olane/o-core';
+
+class SearchTool extends oLaneTool {
+  constructor(config) {
+    super({
+      ...config,
+      address: new oAddress('o://search'),
+      description: 'Search for information in the network'
+    });
+  }
+
+  async _tool_vector(request: oRequest): Promise<ToolResult> {
+    const { query } = request.params;
+    
+    const response = await this.use(new oAddress('o://vector-store'), {
+      method: 'search_similar',
+      params: { query, limit: 10 }
+    });
+    
+    return response.result.data;
+  }
+}
+```
+
+### Tool with Streaming Support
+
+```typescript
+class DataProcessorTool extends oToolBase {
+  async _tool_process_large_file(request: oRequest & { stream?: Stream }): Promise<ToolResult> {
+    const { filePath } = request.params;
+    const { stream } = request;
+    
+    // Send progress updates
+    for (let i = 0; i < 100; i += 10) {
+      if (stream) {
+        await CoreUtils.sendResponse(
+          { progress: i, status: 'processing' },
+          stream
+        );
+      }
+    }
+    
+    return { status: 'complete', processed: true };
+  }
+}
+```
+
+### Hierarchical Tool Organization
+
+```typescript
+// Parent tool
+const parentTool = new CalculatorTool();
+await parentTool.start();
+
+// Child tool inherits context from parent
+class AdvancedCalculatorTool extends oToolBase {
+  async initialize() {
+    await super.initialize();
+    
+    // Register with parent
+    await this.use(new oAddress('o://calculator'), {
+      method: 'child_register',
+      params: { address: this.address.toString() }
+    });
+  }
+
+  async _tool_complex_calculation(request: oRequest): Promise<ToolResult> {
+    // Can leverage parent tool capabilities
+    const result = await this.use(new oAddress('o://calculator'), {
+      method: 'add',
+      params: { a: 10, b: 20 }
+    });
+    
+    return { result: result.result * 2 };
+  }
+}
+```
+
+## API Reference
+
+### `oToolBase`
+
+Base class for creating tools.
+
+**Key Methods:**
+- `execute(request: oRequest, stream?: Stream): Promise<RunResult>` - Execute tool with request
+- `run(request: oRequest, stream?: Stream): Promise<RunResult>` - Run with validation
+- `myTools(): Promise<string[]>` - Get list of available tool methods
+- `callMyTool(request: oRequest, stream?: Stream): Promise<ToolResult>` - Call specific tool method
+- `index(): Promise<{summary: string}>` - Index tool in vector store
+- `whoami(): Promise<object>` - Get tool metadata
+
+### `oTool(Base)`
+
+Mixin function that adds tool capabilities to any `oCore` class.
+
+```typescript
+function oTool<T extends new (...args: any[]) => oToolBase>(Base: T): T
+```
+
+**Usage:**
+```typescript
+class CustomTool extends oTool(MyBaseClass) {
+  // Tool methods...
+}
+```
+
+### Interfaces
+
+#### `oToolConfig`
+```typescript
+interface oToolConfig extends Omit<oCoreConfig, 'address'> {
+  description?: string;
+  methods?: Record<string, MethodMetadata>;
+}
+```
+
+#### `ToolResult`
+```typescript
+interface ToolResult {
+  [key: string]: unknown;
+}
+```
+
+#### `RunResult`
+```typescript
+interface RunResult extends ToolResult {
+  error?: oError;
+}
+```
+
+### Utilities
+
+#### `MethodUtils.findMissingParams(tool, method, params)`
+
+Validates parameters against tool method requirements.
+
+```typescript
+const missing = MethodUtils.findMissingParams(tool, 'add', { a: 5 });
+// Returns: ['b']
+```
+
+## Tool Discovery & Indexing
+
+Tools automatically integrate with Olane's vector store for semantic discovery:
+
+```typescript
+// Index your tool for agent discovery
+await tool.use({ method: 'index_network' });
+
+// Agents can now discover your tool semantically
+const results = await this.use(new oAddress('o://vector-store'), {
+  method: 'search_similar',
+  params: { query: 'calculate numbers' }
+});
+// Returns: o://calculator with tool descriptions
+```
+
+## Error Handling
+
+Tools use structured error handling with `oError`:
+
+```typescript
+import { oError, oErrorCodes } from '@olane/o-core';
+
+async _tool_divide(request: oRequest): Promise<ToolResult> {
+  const { a, b } = request.params;
+  
+  if (b === 0) {
+    throw new oError(
+      oErrorCodes.INVALID_PARAMETERS,
+      'Cannot divide by zero',
+      { a, b }
+    );
+  }
+  
+  return { result: a / b };
+}
+```
+
+## Testing
+
+```typescript
+import { oRequest } from '@olane/o-core';
+
+describe('CalculatorTool', () => {
+  let tool: CalculatorTool;
+  
+  beforeEach(async () => {
+    tool = new CalculatorTool();
+    await tool.start();
+  });
+  
+  it('should add two numbers', async () => {
+    const request = new oRequest({
+      method: 'add',
+      params: { a: 5, b: 3 },
+      id: '123'
+    });
+    
+    const result = await tool.callMyTool(request);
+    expect(result.result).toBe(8);
+  });
+  
+  afterEach(async () => {
+    await tool.stop();
+  });
+});
+```
+
+## Related Packages
+
+- **[@olane/o-core](../o-core)** - Core OS functionality and base classes
+- **[@olane/o-node](../o-node)** - Network-connected tools with P2P capabilities
+- **[@olane/o-protocol](../o-protocol)** - Protocol definitions and types
+- **[@olane/o-lane](../o-lane)** - Lane-based tool organization
+- **[@olane/o-tools-common](../o-tools-common)** - Pre-built common tools
+
+## Contributing
+
+Contributions are welcome! Please read our [Contributing Guide](../../CONTRIBUTING.md) for details on our code of conduct and development process.
+
+## License
+
+ISC © oLane Inc.
+
+## Resources
+
+- [Full Documentation](../../docs)
+- [Olane OS Overview](../../README.md)
+- [Examples](../../examples)
+- [GitHub Repository](https://github.com/olane-labs/olane)
+- [Report Issues](https://github.com/olane-labs/olane/issues)

package/dist/src/index.d.ts

@@ -4,9 +4,6 @@ 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';
-export * from './nodes/index.js';
-export * from './server.tool.js';
-export * from './client.tool.js';
+export * from './router/index.js';
+export * from './o-tool.base.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +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;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC"}
+{"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,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC"}

package/dist/src/index.js

@@ -4,8 +4,5 @@ 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';
-export * from './nodes/index.js';
-export * from './server.tool.js';
-export * from './client.tool.js';
+export * from './router/index.js';
+export * from './o-tool.base.js';

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

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

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

@@ -1 +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"}
+{"version":3,"file":"tool.interface.d.ts","sourceRoot":"","sources":["../../../src/interfaces/tool.interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,MAAM,WAAW,WAAY,SAAQ,IAAI,CAAC,WAAW,EAAE,SAAS,CAAC;CAAG"}

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

@@ -0,0 +1,36 @@
+import { oAddress, oConnection, oCore, oRequest } from '@olane/o-core';
+import { Stream } from '@olane/o-config';
+import { RunResult } from './interfaces/run-result.interface.js';
+import { ToolResult } from './interfaces/tool-result.interface.js';
+/**
+ * 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 class oToolBase extends oCore {
+    private indexed;
+    validateToolCall(oRequest: oRequest): boolean;
+    configureTransports(): any[];
+    connect(nextHopAddress: oAddress, targetAddress: oAddress): Promise<oConnection>;
+    initializeRouter(): Promise<void>;
+    unregister(): Promise<void>;
+    register(): Promise<void>;
+    execute(req: oRequest, stream?: Stream): Promise<RunResult>;
+    run(request: oRequest, stream?: Stream): Promise<RunResult>;
+    myTools(obj?: any): Promise<string[]>;
+    findMethod(method: string): Promise<string | undefined>;
+    myToolParams(tool: string): Record<string, any>;
+    callMyTool(request: oRequest, stream?: Stream): Promise<ToolResult>;
+    index(): Promise<{
+        provider: string;
+        summary: string;
+    } | {
+        summary: string | null;
+        provider?: undefined;
+    }>;
+    whoami(): Promise<{
+        tools: string[];
+        description: string;
+    }>;
+}
+//# sourceMappingURL=o-tool.base.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"o-tool.base.d.ts","sourceRoot":"","sources":["../../src/o-tool.base.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,WAAW,EACX,KAAK,EAGL,QAAQ,EAET,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AACjE,OAAO,EAAE,UAAU,EAAE,MAAM,uCAAuC,CAAC;AAInE;;;;GAIG;AACH,qBAAa,SAAU,SAAQ,KAAK;IAClC,OAAO,CAAC,OAAO,CAAkB;IAEjC,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO;IAY7C,mBAAmB,IAAI,GAAG,EAAE;IAI5B,OAAO,CACL,cAAc,EAAE,QAAQ,EACxB,aAAa,EAAE,QAAQ,GACtB,OAAO,CAAC,WAAW,CAAC;IAGvB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAMjC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAG3B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAInB,OAAO,CAAC,GAAG,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;IA8B3D,GAAG,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;IA2BjE,OAAO,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAS/B,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAI7D,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAWzC,UAAU,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAqBnE,KAAK;;;;;;;IA4FL,MAAM;;;;CAQb"}

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

@@ -0,0 +1,207 @@
+import { oAddress, oCore, oError, oErrorCodes, oRequest, } from '@olane/o-core';
+import { oProtocolMethods } from '@olane/o-protocol';
+import { v4 as uuidv4 } from 'uuid';
+import { MethodUtils } from './utils/method.utils.js';
+/**
+ * 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 class oToolBase extends oCore {
+    constructor() {
+        super(...arguments);
+        this.indexed = false;
+    }
+    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;
+    }
+    configureTransports() {
+        return [];
+    }
+    connect(nextHopAddress, targetAddress) {
+        throw new oError(oErrorCodes.NOT_IMPLEMENTED, 'Connect not implemented');
+    }
+    initializeRouter() {
+        throw new oError(oErrorCodes.NOT_IMPLEMENTED, 'Initialize router not implemented');
+    }
+    unregister() {
+        throw new oError(oErrorCodes.NOT_IMPLEMENTED, 'Unregister not implemented');
+    }
+    register() {
+        throw new oError(oErrorCodes.NOT_IMPLEMENTED, 'Register not implemented');
+    }
+    async execute(req, stream) {
+        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 run(request, stream) {
+        const missingParams = MethodUtils.findMissingParams(this, request.method, request.params || {});
+        if (missingParams.length > 0) {
+            this.logger.error('Missing required parameters: ', missingParams, ' with passed params: ', request.params);
+            throw new oError(oErrorCodes.MISSING_PARAMETERS, 'Missing required parameters', {
+                parameters: missingParams,
+                toolAddress: this.address.toString(),
+                data: request.params,
+            });
+        }
+        let result = await this.callMyTool(request, stream);
+        return result;
+    }
+    myTools(obj) {
+        return Promise.resolve(Object.getOwnPropertyNames(obj || this.constructor.prototype)
+            .filter((key) => key.startsWith('_tool_'))
+            .filter((key) => !!key)
+            .map((key) => key.replace('_tool_', '')));
+    }
+    async findMethod(method) {
+        return (await this.myTools()).find((key) => key.startsWith(method));
+    }
+    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, 'Origin caller address: ', request?.params?._callerAddress);
+        // TODO: implement this
+        // 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() {
+        if (this.indexed) {
+            this.logger.debug('Tool already indexed, skipping...');
+            return {
+                summary: 'Tool already indexed',
+            };
+        }
+        this.indexed = true;
+        // perform 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;
+            // update the description to avoid re-indexing
+            if (summary) {
+                this.config.description = 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 whoami() {
+        const metadata = await super.whoami();
+        return {
+            // @ts-ignore
+            tools: await this.myTools(),
+            description: this.description,
+        };
+    }
+}

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

@@ -1,8 +1,8 @@
-import { oCoreNode } from '@olane/o-core';
+import { oToolBase } from './o-tool.base.js';
 /**
  * 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;
+export declare function oTool<T extends new (...args: any[]) => oToolBase>(Base: T): T;
 //# sourceMappingURL=o-tool.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"o-tool.d.ts","sourceRoot":"","sources":["../../src/o-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,SAAS,EAKV,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,CAsW7E"}
+{"version":3,"file":"o-tool.d.ts","sourceRoot":"","sources":["../../src/o-tool.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAI7C;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,SAAS,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CA0G7E"}