@olane/os 0.7.12-alpha.6 → 0.7.12-alpha.60

package/dist/src/o-olane-os/config/default.config.js

@@ -1,5 +1,5 @@
 import { DEFAULT_INSTANCE_PATH, NodeType, oAddress } from '@olane/o-core';
-import path from 'path';
+import * as path from 'path';
 export const defaultOSInstanceConfig = (port) => {
     return {
         configFilePath: path.join(DEFAULT_INSTANCE_PATH, 'my-olane-os', 'config.json'),

package/dist/src/o-olane-os/o-os.d.ts

@@ -20,7 +20,7 @@ export declare class OlaneOS extends oObject {
     getOSInstanceName(): Promise<string | undefined>;
     startNodes(type: NodeType): Promise<void>;
     runSavedPlans(): Promise<void>;
-    use(oAddress: oAddress, params: any): Promise<any>;
+    use(oAddress: oAddress, params: any): Promise<import("@olane/o-core").oResponse>;
     start(): Promise<{
         peerId: string;
         transports: oTransport[];

package/dist/src/o-olane-os/o-os.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"o-os.d.ts","sourceRoot":"","sources":["../../../src/o-olane-os/o-os.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAG5D,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EAAU,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACtE,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAIzC,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAK1C,KAAK,WAAW,GAAG,SAAS,GAAG,WAAW,CAAC;AAC3C,qBAAa,OAAQ,SAAQ,OAAO;IAClC,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,KAAK,CAAqB;IAC3B,UAAU,EAAE,WAAW,GAAG,IAAI,CAAQ;IACtC,MAAM,EAAG,mBAAmB,CAAC;IACpC,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,eAAe,CAAa;gBAExB,MAAM,EAAE,aAAa;IAKjC,SAAS,IAAI,SAAS,GAAG,WAAW;IAMpC,SAAS,CAAC,MAAM,EAAE,WAAW;IAOvB,OAAO,CAAC,IAAI,EAAE,WAAW;YAiBjB,UAAU;IAwClB,iBAAiB;IASjB,UAAU,CAAC,IAAI,EAAE,QAAQ;IAmDzB,aAAa;IA6Bb,GAAG,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG;IAUnC,KAAK,IAAI,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,UAAU,EAAE,CAAA;KAAE,CAAC;IAiC9D,IAAI;IAwBJ,OAAO;CAKd"}
+{"version":3,"file":"o-os.d.ts","sourceRoot":"","sources":["../../../src/o-olane-os/o-os.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAG5D,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EAAU,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACtE,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAIzC,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAK1C,KAAK,WAAW,GAAG,SAAS,GAAG,WAAW,CAAC;AAC3C,qBAAa,OAAQ,SAAQ,OAAO;IAClC,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,KAAK,CAAqB;IAC3B,UAAU,EAAE,WAAW,GAAG,IAAI,CAAQ;IACtC,MAAM,EAAG,mBAAmB,CAAC;IACpC,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,eAAe,CAAa;gBAExB,MAAM,EAAE,aAAa;IAKjC,SAAS,IAAI,SAAS,GAAG,WAAW;IAMpC,SAAS,CAAC,MAAM,EAAE,WAAW;IAOvB,OAAO,CAAC,IAAI,EAAE,WAAW;YAiBjB,UAAU;IAwClB,iBAAiB;IASjB,UAAU,CAAC,IAAI,EAAE,QAAQ;IAmDzB,aAAa;IA6Bb,GAAG,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG;IASnC,KAAK,IAAI,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,UAAU,EAAE,CAAA;KAAE,CAAC;IAiC9D,IAAI;IAwBJ,OAAO;CAKd"}

package/dist/src/o-olane-os/o-os.js

@@ -1,5 +1,5 @@
 import { OlaneOSSystemStatus } from './enum/o-os.status-enum.js';
-import touch from 'touch';
+import * as touch from 'touch';
 import { readFile } from 'fs/promises';
 import { oLeaderNode } from '@olane/o-leader';
 import { oAddress, oObject } from '@olane/o-core';
@@ -163,7 +163,6 @@ export class OlaneOS extends oObject {
         if (!entryNode) {
             throw new Error('Entry node not found');
         }
-        this.logger.debug('Using address: ' + oAddress.toString());
         const result = await entryNode.use(oAddress, params);
         return result;
     }

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

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/utils/config.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE7C,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,mBAAmB,CAAC;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,cAAc,CAAC,EAAE,aAAa,CAAC;IAC/B,mBAAmB,CAAC,EAAE,YAAY,CAAC;CACpC;AAED,MAAM,WAAW,SAAS;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC;CAC5C;AAED,eAAO,MAAM,gBAAgB,gBAAgB,CAAC;AAE9C,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAC,UAAU,CAAuB;IAChD,OAAO,CAAC,MAAM,CAAC,aAAa,CAAyB;IACrD,OAAO,CAAC,MAAM,CAAC,UAAU,CAAuB;WAEnC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IASxC,MAAM,CAAC,gBAAgB,IAAI,SAAS;WAOvB,SAAS,IAAI,OAAO,CAAC,SAAS,CAAC;WAM/B,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;WAOrD,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;WAItD,mBAAmB,CAC9B,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC;WAO3B,WAAW,CACtB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC;WAY3B,cAAc,CACzB,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC;WAQ3B,YAAY,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;WAS1D,eAAe,IAAI,OAAO,CAAC,qBAAqB,EAAE,CAAC;WAuBnD,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAO3D"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/utils/config.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE7C,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,mBAAmB,CAAC;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,cAAc,CAAC,EAAE,aAAa,CAAC;IAC/B,mBAAmB,CAAC,EAAE,YAAY,CAAC;CACpC;AAED,MAAM,WAAW,SAAS;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC;CAC5C;AAED,eAAO,MAAM,gBAAgB,gBAAgB,CAAC;AAE9C,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAC,UAAU,CAAuB;IAChD,OAAO,CAAC,MAAM,CAAC,aAAa,CAAyB;IACrD,OAAO,CAAC,MAAM,CAAC,UAAU,CAAuB;WAEnC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IASxC,MAAM,CAAC,gBAAgB,IAAI,SAAS;WAOvB,SAAS,IAAI,OAAO,CAAC,SAAS,CAAC;WAM/B,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;WAOrD,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;WAItD,mBAAmB,CAC9B,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC;WAO3B,WAAW,CACtB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC;WAY3B,cAAc,CACzB,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC;WAQ3B,YAAY,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;WAS1D,eAAe,IAAI,OAAO,CAAC,qBAAqB,EAAE,CAAC;WAuBnD,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAM3D"}

package/dist/src/utils/config.js

@@ -1,5 +1,5 @@
-import fs from 'fs-extra';
-import path from 'path';
+import * as fs from 'fs-extra';
+import * as path from 'path';
 import { DEFAULT_CONFIG_PATH, DEFAULT_INSTANCE_PATH, DEFAULT_CONFIG_FILE, } from '@olane/o-core';
 export const CONFIG_FILE_NAME = 'config.json';
 export class ConfigManager {

package/dist/test/basic/basic-usage.spec.d.ts

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

package/dist/test/basic/basic-usage.spec.js

@@ -1,118 +1,148 @@
-import { NodeState } from '@olane/o-core';
-import { expect } from 'chai';
-import dotenv from 'dotenv';
-import { defaultOSInstance } from '../utils/os.default.js';
-import { OlaneOSSystemStatus } from '../../src/o-olane-os/enum/o-os.status-enum.js';
-import { oNodeAddress, oNodeTransport } from '@olane/o-node';
-import { multiaddr } from '@olane/o-config';
-dotenv.config();
-const network = defaultOSInstance;
-describe('basic-usage @initialize', async () => {
-    it('should be able to startup the network', async () => {
-        await network.start();
-        expect(network.status).to.equal(OlaneOSSystemStatus.RUNNING);
-    });
-    // disabled for now, to avoid unecessary indexing costs
-    // it('should be able to index the network', async () => {
-    //   const entryNode = network.entryNode();
-    //   expect(entryNode).to.exist;
-    //   expect(entryNode.state).to.equal(NodeState.RUNNING);
-    //   const response = await entryNode.use(new oAddress('o://leader'), {
-    //     method: 'index_network',
-    //     params: {},
-    //   });
-    //   const data = response.result.data;
-    //   expect(data).to.exist;
-    //   expect(data.error).to.be.undefined;
-    //   expect(data.message).to.equal('Network indexed!');
-    // });
-    it('should be able to use olane remote services', async () => {
-        const entryNode = network.entryNode();
-        expect(entryNode).to.exist;
-        expect(entryNode.state).to.equal(NodeState.RUNNING);
-        // configure the intelligence tool
-        // await entryNode.use(new oAddress('o://intelligence'), {
-        //   method: 'configure',
-        //   params: {
-        //     modelProvider: 'anthropic',
-        //     hostingProvider: 'olane',
-        //     accessToken: 'test',
-        //     address: 'o://leader/intelligence',
-        //   },
-        // });
-        // use the intelligence tool
-        const response2 = await entryNode.use(new oNodeAddress('o://perplexity', [
-            new oNodeTransport(multiaddr('/ip4/127.0.0.1/tcp/4000/ws/p2p/12D3KooWPHdsHhEdyBd9DS2zHJ1vRSyqSkZ97iT7F8ByYJ7U7bw8')),
-        ]), {
-            method: 'completion',
-            params: {
-                model: 'sonar',
-                messages: [
-                    {
-                        role: 'user',
-                        content: 'What is the weather in Tokyo?',
-                    },
-                ],
-            },
-        });
-        console.log(response2.result.data);
-    });
-});
-// describe('olane network usage', async () => {
-//   it('should be able to use the olane network', async () => {
-//     // let's dial the other network
-//     const response = await network.use(
-//       new oAddress('o://leader', [
-//         multiaddr('/dns4/leader.olane.com/tcp/4000/tls/ws'),
+"use strict";
+// import { oAddress, NodeState } from '@olane/o-core';
+// import { expect } from 'chai';
+// import dotenv from 'dotenv';
+// import { defaultOSInstance } from '../utils/os.default.js';
+// import { OlaneOSSystemStatus } from '../../src/o-olane-os/enum/o-os.status-enum.js';
+// import { oNodeAddress, oNodeTransport } from '@olane/o-node';
+// import { multiaddr } from '@olane/o-config';
+// dotenv.config();
+// const network = defaultOSInstance;
+// describe('basic-usage @initialize', async () => {
+//   it('should be able to startup the network', async () => {
+//     await network.start();
+//     expect(network.status).to.equal(OlaneOSSystemStatus.RUNNING);
+//   });
+//   // disabled for now, to avoid unecessary indexing costs
+//   // it('should be able to index the network', async () => {
+//   //   const entryNode = network.entryNode();
+//   //   expect(entryNode).to.exist;
+//   //   expect(entryNode.state).to.equal(NodeState.RUNNING);
+//   //   const response = await entryNode.use(new oAddress('o://leader'), {
+//   //     method: 'index_network',
+//   //     params: {},
+//   //   });
+//   //   const data = response.result.data;
+//   //   expect(data).to.exist;
+//   //   expect(data.error).to.be.undefined;
+//   //   expect(data.message).to.equal('Network indexed!');
+//   // });
+//   it('should be able to use stream from a provider service', async () => {
+//     const entryNode = network.entryNode();
+//     expect(entryNode).to.exist;
+//     expect(entryNode.state).to.equal(NodeState.RUNNING);
+//     // configure the intelligence tool
+//     // await entryNode.use(new oAddress('o://intelligence'), {
+//     //   method: 'configure',
+//     //   params: {
+//     //     modelProvider: 'anthropic',
+//     //     hostingProvider: 'olane',
+//     //     accessToken: 'test',
+//     //     address: 'o://leader/intelligence',
+//     //   },
+//     // });
+//     // console.log('Pinging relay');
+//     // await (entryNode.p2pNode.services as any).ping.ping(
+//     //   multiaddr('/dns4/relay.olane.com/tcp/4000/tls/ws'),
+//     // );
+//     console.log('Pinged relay');
+//     // use the intelligence tool
+//     await entryNode.useStream(
+//       new oNodeAddress('o://leader', [
+//         new oNodeTransport(
+//           '/ip4/127.0.0.1/tcp/4000/ws/p2p/12D3KooWPHdsHhEdyBd9DS2zHJ1vRSyqSkZ97iT7F8ByYJ7U7bw8',
+//         ),
 //       ]),
 //       {
 //         method: 'intent',
 //         params: {
-//           intent: 'What can I do?',
+//           _isStream: true,
+//           intent: 'What is the official endpoint for github mcp server?',
 //         },
 //       },
-//     );
-//     console.log(response.result.data);
-//   });
-// });
-// describe('external-networks', async () => {
-//   it('should be able to use an external network', async () => {
-//     const network2 = new oNetwork({
-//       // configFilePath: path.join(os.homedir(), '.olane', 'config.json'),
-//       nodes: [
-//         {
-//           type: NodeType.LEADER,
-//           address: new oAddress('o://leader'),
-//           leader: null,
-//           parent: null,
-//         },
-//         {
-//           type: NodeType.NODE,
-//           address: new oAddress('o://node2'),
-//           leader: null,
-//           parent: null,
-//         },
-//       ],
-//       plans: [],
-//       noIndexNetwork: true,
-//     });
-//     await network2.start();
-//     expect(network2.status).to.equal(NetworkStatus.RUNNING);
-//     // let's dial the other network
-//     await network2.use(
-//       new oAddress('o://leader', [
-//         ...(network?.rootLeader?.address.libp2pTransports || []),
-//       ]),
 //       {
-//         method: 'index_network',
-//         params: {},
+//         onChunk: (chunk) => {
+//           console.log(
+//             'Received chunk: ',
+//             JSON.stringify(chunk.result.data, null, 2),
+//           );
+//         },
 //       },
 //     );
+//     // await entryNode.use(
+//     //   new oNodeAddress('o://intelligence'),
+//     //   {
+//     //     method: 'prompt',
+//     //     params: {
+//     //       _isStream: true,
+//     //       prompt: 'What is the capital of France?',
+//     //     },
+//     //   },
+//     //   {
+//     //     isStream: true,
+//     //     onChunk: (chunk) => {
+//     //       console.log('FINAL Received chunk: ', JSON.stringify(chunk, null, 2));
+//     //     },
+//     //   },
+//     // );
+//     // await new Promise((resolve) => setTimeout(resolve, 20_000));
+//   });
+// });
+// // describe('olane network usage', async () => {
+// //   it('should be able to use the olane network', async () => {
+// //     // let's dial the other network
+// //     const response = await network.use(
+// //       new oAddress('o://leader', [
+// //         multiaddr('/dns4/leader.olane.com/tcp/4000/tls/ws'),
+// //       ]),
+// //       {
+// //         method: 'intent',
+// //         params: {
+// //           intent: 'What can I do?',
+// //         },
+// //       },
+// //     );
+// //     console.log(response.result.data);
+// //   });
+// // });
+// // describe('external-networks', async () => {
+// //   it('should be able to use an external network', async () => {
+// //     const network2 = new oNetwork({
+// //       // configFilePath: path.join(os.homedir(), '.olane', 'config.json'),
+// //       nodes: [
+// //         {
+// //           type: NodeType.LEADER,
+// //           address: new oAddress('o://leader'),
+// //           leader: null,
+// //           parent: null,
+// //         },
+// //         {
+// //           type: NodeType.NODE,
+// //           address: new oAddress('o://node2'),
+// //           leader: null,
+// //           parent: null,
+// //         },
+// //       ],
+// //       plans: [],
+// //       noIndexNetwork: true,
+// //     });
+// //     await network2.start();
+// //     expect(network2.status).to.equal(NetworkStatus.RUNNING);
+// //     // let's dial the other network
+// //     await network2.use(
+// //       new oAddress('o://leader', [
+// //         ...(network?.rootLeader?.address.libp2pTransports || []),
+// //       ]),
+// //       {
+// //         method: 'index_network',
+// //         params: {},
+// //       },
+// //     );
+// //   });
+// // });
+// describe('basic-usage @stop-network', async () => {
+//   it('should be able to stop the network', async () => {
+//     await network.stop();
+//     expect(network.status).to.equal(OlaneOSSystemStatus.STOPPED);
 //   });
 // });
-describe('basic-usage @stop-network', async () => {
-    it('should be able to stop the network', async () => {
-        await network.stop();
-        expect(network.status).to.equal(OlaneOSSystemStatus.STOPPED);
-    });
-});

package/dist/test/basic/playground.spec.d.ts

@@ -0,0 +1,2 @@
+import 'dotenv/config';
+//# sourceMappingURL=playground.spec.d.ts.map

package/dist/test/basic/playground.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playground.spec.d.ts","sourceRoot":"","sources":["../../../test/basic/playground.spec.ts"],"names":[],"mappings":"AAAA,OAAO,eAAe,CAAC"}

package/dist/test/basic/playground.spec.js

@@ -0,0 +1,108 @@
+import 'dotenv/config';
+import { NodeState } from '@olane/o-core';
+import { expect } from 'chai';
+import { defaultOSInstance } from '../utils/os.default.js';
+import { oNodeAddress, oNodeTransport } from '@olane/o-node';
+import { tmpNode } from '../utils/tmp.node.js';
+const network = defaultOSInstance;
+const entryNode = tmpNode;
+let humanNode;
+describe('playground running', async () => {
+    it('should be able to use stream from a provider service', async () => {
+        await entryNode.start();
+        expect(entryNode).to.exist;
+        expect(entryNode.state).to.equal(NodeState.RUNNING);
+        const leader = new oNodeAddress('o://leader', [
+            new oNodeTransport(
+            // '/dns4/leader.olane.com/tcp/4000/tls/ws',
+            '/ip4/127.0.0.1/tcp/4000/ws/p2p/12D3KooWPHdsHhEdyBd9DS2zHJ1vRSyqSkZ97iT7F8ByYJ7U7bw8'),
+        ]);
+        // const joinedNode = new oLimitedTool({
+        //   address: new oNodeAddress('o://joined'),
+        //   leader: leader,
+        //   parent: leader,
+        //   joinToken: 'test',
+        // });
+        // await joinedNode.start(); // should join the network
+        // humanNode = new oHumanLoginTool({
+        //   address: new oNodeAddress('o://human'),
+        //   leader: leader,
+        //   parent: leader,
+        //   respond: async (intent: string) => {
+        //     return 'Request approved';
+        //   },
+        //   answer: async (question: string) => {
+        //     return 'Request approved';
+        //   },
+        //   receiveStream: async (data: any) => {
+        //     console.log('Received stream:', data);
+        //   },
+        // });
+        // await humanNode.start();
+        const response = await entryNode.useStream(leader, {
+            method: 'intent',
+            params: {
+                _isStreaming: true,
+                intent: 'Use o://intelligence to generate the expo react native code for a new table view with example data populated',
+                _token: 'test',
+            },
+        }, {
+            abortSignal: AbortSignal.timeout(5000),
+            onChunk: (chunk) => {
+                console.log('Received chunk:', JSON.stringify(chunk.result.data, null, 2));
+            },
+        });
+        console.log('Response:', JSON.stringify(response, null, 2));
+        // const response = await entryNode.use(
+        //   new oNodeAddress('o://leader/joined', leader.transports),
+        //   {
+        //     method: 'ping',
+        //     params: {},
+        //   },
+        // );
+        // console.log('Response:', response.result.data);
+        await entryNode.stop();
+    });
+    // it('should fail when action is not approved', async () => {
+    //   const entryNode = tmpNode;
+    //   // await entryNode.start();
+    //   expect(entryNode).to.exist;
+    //   expect(entryNode.state).to.equal(NodeState.RUNNING);
+    //   console.log('Setting approval preference to deny a specific action');
+    //   // Set a preference to deny a specific tool/method combination
+    //   const setPreferenceResponse = await entryNode.use(
+    //     new oNodeAddress('o://approval'),
+    //     {
+    //       method: 'set_preference',
+    //       params: {
+    //         toolMethod: 'o://storage/delete',
+    //         preference: 'deny',
+    //       },
+    //     },
+    //   );
+    //   console.log('Set preference response:', setPreferenceResponse.result.data);
+    //   expect(setPreferenceResponse.result.data).to.exist;
+    //   console.log('Attempting to request approval for denied action');
+    //   // Now request approval for the denied action
+    //   const approvalResponse = await entryNode.use(
+    //     new oNodeAddress('o://approval'),
+    //     {
+    //       method: 'request_approval',
+    //       params: {
+    //         toolAddress: 'o://storage',
+    //         method: 'delete',
+    //         params: { key: 'test-key' },
+    //         intent: 'Testing approval denial',
+    //       },
+    //     },
+    //   );
+    //   console.log('Approval response:', approvalResponse.result.data);
+    //   // Verify the action was denied
+    //   expect(approvalResponse.result.data).to.exist;
+    //   expect((approvalResponse.result.data as any).approved).to.be.false;
+    //   expect((approvalResponse.result.data as any).decision).to.equal('deny');
+    //   console.log('✓ Action was successfully denied by approval system');
+    //   await entryNode.stop();
+    //   await humanNode.stop();
+    // });
+});

package/dist/test/capabilities/base-capability.spec.d.ts

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

package/dist/test/capabilities/base-capability.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-capability.spec.d.ts","sourceRoot":"","sources":["../../../test/capabilities/base-capability.spec.ts"],"names":[],"mappings":""}

package/dist/test/capabilities/base-capability.spec.js

@@ -0,0 +1,174 @@
+import { expect } from 'chai';
+import { oCapability, oCapabilityType, oCapabilityResult } from '@olane/o-lane';
+import { createTestOS, createTestLaneTool, createMockCapabilityConfig } from './utils/capability-test-utils.js';
+/**
+ * Test implementation of oCapability for testing base functionality
+ */
+class TestCapability extends oCapability {
+    constructor() {
+        super(...arguments);
+        this.runCalled = false;
+        this.cancelCalled = false;
+        this.shouldThrowError = false;
+        this.customResult = { data: 'test result' };
+    }
+    async run() {
+        this.runCalled = true;
+        if (this.shouldThrowError) {
+            throw new Error('Test error from capability');
+        }
+        return new oCapabilityResult({
+            type: oCapabilityType.TASK,
+            result: this.customResult,
+            humanResult: 'Test capability executed successfully'
+        });
+    }
+    cancel() {
+        this.cancelCalled = true;
+    }
+    get type() {
+        return oCapabilityType.TASK;
+    }
+    static get type() {
+        return oCapabilityType.TASK;
+    }
+}
+describe('oCapability Base Class @capability @base', () => {
+    let os;
+    let laneTool;
+    let testCapability;
+    before(async () => {
+        os = await createTestOS();
+        laneTool = await createTestLaneTool(os);
+    });
+    after(async () => {
+        if (laneTool) {
+            await laneTool.stop();
+        }
+        if (os) {
+            await os.stop();
+        }
+    });
+    beforeEach(() => {
+        testCapability = new TestCapability();
+    });
+    describe('execute() method', () => {
+        it('should execute the capability and call run()', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test intent');
+            const result = await testCapability.execute(config);
+            expect(testCapability.runCalled).to.be.true;
+            expect(result).to.exist;
+            expect(result.type).to.equal(oCapabilityType.TASK);
+        });
+        it('should store the config in the capability', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test intent');
+            await testCapability.execute(config);
+            expect(testCapability.config).to.equal(config);
+        });
+        it('should return the result from run()', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test intent');
+            testCapability.customResult = { custom: 'data', value: 123 };
+            const result = await testCapability.execute(config);
+            expect(result.result).to.deep.equal({ custom: 'data', value: 123 });
+            expect(result.humanResult).to.equal('Test capability executed successfully');
+        });
+        it('should propagate errors from run()', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test intent');
+            testCapability.shouldThrowError = true;
+            try {
+                await testCapability.execute(config);
+                expect.fail('Should have thrown an error');
+            }
+            catch (error) {
+                expect(error.message).to.equal('Test error from capability');
+            }
+        });
+    });
+    describe('getter methods', () => {
+        it('should provide access to node via getter', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test intent');
+            await testCapability.execute(config);
+            expect(testCapability.node).to.equal(laneTool);
+        });
+        it('should provide access to intent via getter', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test intent with params', { param1: 'value1' });
+            await testCapability.execute(config);
+            expect(testCapability.intent).to.exist;
+            expect(testCapability.intent.value).to.equal('Test intent with params');
+            expect(testCapability.config.params).to.deep.equal({ param1: 'value1' });
+        });
+        it('should provide access to type via instance getter', () => {
+            expect(testCapability.type).to.equal(oCapabilityType.TASK);
+        });
+        it('should provide access to type via static getter', () => {
+            expect(TestCapability.type).to.equal(oCapabilityType.TASK);
+        });
+    });
+    describe('cancel() method', () => {
+        it('should call cancel on the capability', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test intent');
+            await testCapability.execute(config);
+            testCapability.cancel();
+            expect(testCapability.cancelCalled).to.be.true;
+        });
+        it('should be callable before execution', () => {
+            testCapability.cancel();
+            expect(testCapability.cancelCalled).to.be.true;
+        });
+    });
+    describe('config handling', () => {
+        it('should handle config with streaming enabled', async () => {
+            const chunks = [];
+            const config = createMockCapabilityConfig(laneTool, 'Test intent', {}, {
+                useStream: true,
+                onChunk: (chunk) => chunks.push(chunk)
+            });
+            await testCapability.execute(config);
+            expect(testCapability.config.useStream).to.be.true;
+            expect(testCapability.config.onChunk).to.be.a('function');
+        });
+        it('should handle config with replay flag', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test intent', {}, { isReplay: true });
+            await testCapability.execute(config);
+            expect(testCapability.config.isReplay).to.be.true;
+        });
+        it('should handle config with history', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test intent');
+            config.history = 'Previous execution context';
+            await testCapability.execute(config);
+            expect(testCapability.config.history).to.equal('Previous execution context');
+        });
+        it('should handle config with custom params', async () => {
+            const customParams = {
+                toolAddress: 'o://test-tool',
+                method: 'testMethod',
+                methodParams: { arg1: 'value1', arg2: 123 }
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Test intent', customParams);
+            await testCapability.execute(config);
+            expect(testCapability.config.params).to.deep.equal(customParams);
+        });
+    });
+    describe('lifecycle', () => {
+        it('should be able to execute multiple times', async () => {
+            const config1 = createMockCapabilityConfig(laneTool, 'First intent');
+            const config2 = createMockCapabilityConfig(laneTool, 'Second intent');
+            const result1 = await testCapability.execute(config1);
+            testCapability.runCalled = false; // Reset flag
+            const result2 = await testCapability.execute(config2);
+            expect(result1).to.exist;
+            expect(result2).to.exist;
+            expect(testCapability.config).to.equal(config2);
+        });
+        it('should allow cancellation between executions', async () => {
+            const config1 = createMockCapabilityConfig(laneTool, 'First intent');
+            await testCapability.execute(config1);
+            testCapability.cancel();
+            expect(testCapability.cancelCalled).to.be.true;
+            testCapability.cancelCalled = false;
+            const config2 = createMockCapabilityConfig(laneTool, 'Second intent');
+            await testCapability.execute(config2);
+            expect(testCapability.runCalled).to.be.true;
+        });
+    });
+});

package/dist/test/capabilities/capability-errors.spec.d.ts

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

package/dist/test/capabilities/capability-errors.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capability-errors.spec.d.ts","sourceRoot":"","sources":["../../../test/capabilities/capability-errors.spec.ts"],"names":[],"mappings":""}