@olane/o-tool-registry 0.1.0 → 0.1.1

package/dist/embeddings/text-embeddings.tool.d.ts

@@ -6,13 +6,13 @@ declare const TextEmbeddingsTool_base: (new (...args: any[]) => {
     initialize(): Promise<void>;
     use(address: oAddress, data: {
         [key: string]: unknown;
-    }, config?: import("@olane/o-core").UseOptions): Promise<import("@olane/o-core").oResponse>;
-    handleStream(streamData: import("@olane/o-config/dist").IncomingStreamData): Promise<void>;
-    execute(req: oRequest, stream?: import("@olane/o-config/dist").Stream): Promise<import("@olane/o-tool").RunResult>;
-    run(request: oRequest, stream?: import("@olane/o-config/dist").Stream): Promise<import("@olane/o-tool").RunResult>;
+    }, config?: import("@olane/o-core").UseOptions | undefined): Promise<import("@olane/o-core").oResponse>;
+    handleStream(streamData: import("@libp2p/interface", { with: { "resolution-mode": "import" } }).IncomingStreamData): Promise<void>;
+    execute(req: oRequest, stream?: import("@libp2p/interface", { with: { "resolution-mode": "import" } }).Stream | undefined): Promise<import("@olane/o-tool").RunResult>;
+    run(request: oRequest, stream?: import("@libp2p/interface", { with: { "resolution-mode": "import" } }).Stream | undefined): Promise<import("@olane/o-tool").RunResult>;
     myTools(): string[];
     myToolParams(tool: string): Record<string, any>;
-    callMyTool(request: oRequest, stream?: import("@olane/o-config/dist").Stream): Promise<import("@olane/o-tool").ToolResult>;
+    callMyTool(request: oRequest, stream?: import("@libp2p/interface", { with: { "resolution-mode": "import" } }).Stream | undefined): Promise<import("@olane/o-tool").ToolResult>;
     index(): Promise<{
         provider: string;
         summary: string;
@@ -25,31 +25,31 @@ declare const TextEmbeddingsTool_base: (new (...args: any[]) => {
         tools: string[];
         description: string;
     }>;
-    findMissingParams(methodName: string, params: any): import("@olane/o-protocol/dist").oParameter[];
+    findMissingParams(methodName: string, params: any): import("@olane/o-protocol").oParameter[];
     readonly config: import("@olane/o-core").CoreConfig;
-    p2pNode: import("@olane/o-config/dist").Libp2p;
+    p2pNode: import("libp2p", { with: { "resolution-mode": "import" } }).Libp2p<import("@libp2p/interface", { with: { "resolution-mode": "import" } }).ServiceMap>;
     logger: import("@olane/o-core").Logger;
-    networkConfig: import("@olane/o-config/dist").Libp2pConfig;
+    networkConfig: import("@olane/o-config").Libp2pConfig;
     address: oAddress;
     readonly staticAddress: oAddress;
-    peerId: import("@olane/o-config/dist").PeerId;
+    peerId: import("@libp2p/interface-peer-id", { with: { "resolution-mode": "import" } }).PeerId;
     state: import("@olane/o-core").NodeState;
     errors: Error[];
     connectionManager: import("@olane/o-core").oConnectionManager;
-    leaders: import("@olane/o-config/dist").Multiaddr[];
+    leaders: import("@multiformats/multiaddr", { with: { "resolution-mode": "import" } }).Multiaddr[];
     addressResolution: import("@olane/o-core").oAddressResolution;
     readonly description: string;
     dependencies: import("@olane/o-core").oDependency[];
     methods: {
-        [key: string]: import("@olane/o-protocol/dist").oMethod;
+        [key: string]: import("@olane/o-protocol").oMethod;
     };
     successCount: number;
     errorCount: number;
-    get type(): import("@olane/o-core").NodeType;
-    get transports(): string[];
-    get parent(): oAddress | null;
-    get parentTransports(): import("@olane/o-config/dist").Multiaddr[];
-    getTransports(address: oAddress): import("@olane/o-config/dist").Multiaddr[];
+    readonly type: import("@olane/o-core").NodeType;
+    readonly transports: string[];
+    readonly parent: oAddress | null;
+    readonly parentTransports: import("@multiformats/multiaddr", { with: { "resolution-mode": "import" } }).Multiaddr[];
+    getTransports(address: oAddress): import("@multiformats/multiaddr", { with: { "resolution-mode": "import" } }).Multiaddr[];
     handleStaticAddressTranslation(addressInput: oAddress): Promise<oAddress>;
     translateAddress(addressWithLeaderTransports: oAddress): Promise<{
         nextHopAddress: oAddress;

package/dist/embeddings/text-embeddings.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"text-embeddings.tool.d.ts","sourceRoot":"","sources":["../../src/embeddings/text-embeddings.tool.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;;;;;;;aAexB,CAAC;;iCAEuE,CAAC;iCAAoE,CAAC;;;wCAAiK,CAAC;;;;;;gBAA4L,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAbjgB,8BAAsB,kBAAmB,SAAQ,uBAAmB;gBACtD,MAAM,EAAE,WAAW;IAS/B,QAAQ,CAAC,qBAAqB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;IACtE,QAAQ,CAAC,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;CACjE"}
+{"version":3,"file":"text-embeddings.tool.d.ts","sourceRoot":"","sources":["../../src/embeddings/text-embeddings.tool.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAI5C,8BAAsB,kBAAmB,SAAQ,uBAAmB;gBACtD,MAAM,EAAE,WAAW;IAS/B,QAAQ,CAAC,qBAAqB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;IACtE,QAAQ,CAAC,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;CACjE"}

package/dist/embeddings/text-embeddings.tool.js

@@ -1,14 +1,17 @@
-import { oTool } from '@olane/o-tool';
-import { oAddress, oVirtualNode } from '@olane/o-core';
-import { TEXT_EMBEDDINGS_PARAMS } from './methods/text-embeddings.method';
-export class TextEmbeddingsTool extends oTool(oVirtualNode) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextEmbeddingsTool = void 0;
+const o_tool_1 = require("@olane/o-tool");
+const o_core_1 = require("@olane/o-core");
+const text_embeddings_method_1 = require("./methods/text-embeddings.method");
+class TextEmbeddingsTool extends (0, o_tool_1.oTool)(o_core_1.oVirtualNode) {
     constructor(config) {
         super({
             ...config,
-            address: new oAddress('o://embeddings-text'),
-            methods: TEXT_EMBEDDINGS_PARAMS,
+            address: new o_core_1.oAddress('o://embeddings-text'),
+            methods: text_embeddings_method_1.TEXT_EMBEDDINGS_PARAMS,
             description: config.description || 'Tool to generate text embeddings',
         });
     }
 }
-//# sourceMappingURL=text-embeddings.tool.js.map
+exports.TextEmbeddingsTool = TextEmbeddingsTool;

package/dist/index.js

@@ -1,7 +1,22 @@
-export * from './intelligence';
-export * from './init';
-export * from './nlp';
-export * from './vector-store';
-export * from './mcp';
-export * from './auth';
-//# sourceMappingURL=index.js.map
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./intelligence"), exports);
+__exportStar(require("./init"), exports);
+__exportStar(require("./nlp"), exports);
+__exportStar(require("./vector-store"), exports);
+__exportStar(require("./mcp"), exports);
+__exportStar(require("./auth"), exports);

package/dist/init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../src/init.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAOtC,eAAO,MAAM,iBAAiB,GAAI,OAAO,KAAK,SA8B7C,CAAC"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../src/init.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAOtC,eAAO,MAAM,iBAAiB,UAAW,KAAK,SA8B7C,CAAC"}

package/dist/init.js

@@ -1,31 +1,34 @@
-import { NERTool } from './nlp/ner.tool';
-import { HuggingfaceTextEmbeddingsTool } from './embeddings';
-import { LangchainMemoryVectorStoreTool } from './vector-store';
-import { IntelligenceTool } from './intelligence';
-import { McpBridgeTool } from './mcp';
-export const initRegistryTools = (oNode) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initRegistryTools = void 0;
+const ner_tool_1 = require("./nlp/ner.tool");
+const embeddings_1 = require("./embeddings");
+const vector_store_1 = require("./vector-store");
+const intelligence_1 = require("./intelligence");
+const mcp_1 = require("./mcp");
+const initRegistryTools = (oNode) => {
     const params = {
         parent: oNode.address,
         leader: oNode.address,
     };
     const tools = [
-        new NERTool({
+        new ner_tool_1.NERTool({
             name: 'ner',
             ...params,
         }),
-        new IntelligenceTool({
+        new intelligence_1.IntelligenceTool({
             name: 'intelligence',
             ...params,
         }),
-        new HuggingfaceTextEmbeddingsTool({
+        new embeddings_1.HuggingfaceTextEmbeddingsTool({
             name: 'embeddings-text',
             ...params,
         }),
-        new LangchainMemoryVectorStoreTool({
+        new vector_store_1.LangchainMemoryVectorStoreTool({
             name: 'vector-store',
             ...params,
         }),
-        new McpBridgeTool({
+        new mcp_1.McpBridgeTool({
             name: 'mcp',
             ...params,
         }),
@@ -34,4 +37,4 @@ export const initRegistryTools = (oNode) => {
         oNode.addChildNode(tool);
     });
 };
-//# sourceMappingURL=init.js.map
+exports.initRegistryTools = initRegistryTools;

package/dist/intelligence/anthropic-intelligence.tool.d.ts

@@ -6,13 +6,13 @@ declare const AnthropicIntelligenceTool_base: (new (...args: any[]) => {
     initialize(): Promise<void>;
     use(address: oAddress, data: {
         [key: string]: unknown;
-    }, config?: import("@olane/o-core").UseOptions): Promise<import("@olane/o-core").oResponse>;
-    handleStream(streamData: import("@olane/o-config/dist").IncomingStreamData): Promise<void>;
-    execute(req: oRequest, stream?: import("@olane/o-config/dist").Stream): Promise<import("@olane/o-tool").RunResult>;
-    run(request: oRequest, stream?: import("@olane/o-config/dist").Stream): Promise<import("@olane/o-tool").RunResult>;
+    }, config?: import("@olane/o-core").UseOptions | undefined): Promise<import("@olane/o-core").oResponse>;
+    handleStream(streamData: import("@libp2p/interface", { with: { "resolution-mode": "import" } }).IncomingStreamData): Promise<void>;
+    execute(req: oRequest, stream?: import("@libp2p/interface", { with: { "resolution-mode": "import" } }).Stream | undefined): Promise<import("@olane/o-tool").RunResult>;
+    run(request: oRequest, stream?: import("@libp2p/interface", { with: { "resolution-mode": "import" } }).Stream | undefined): Promise<import("@olane/o-tool").RunResult>;
     myTools(): string[];
     myToolParams(tool: string): Record<string, any>;
-    callMyTool(request: oRequest, stream?: import("@olane/o-config/dist").Stream): Promise<ToolResult>;
+    callMyTool(request: oRequest, stream?: import("@libp2p/interface", { with: { "resolution-mode": "import" } }).Stream | undefined): Promise<ToolResult>;
     index(): Promise<{
         provider: string;
         summary: string;
@@ -25,31 +25,31 @@ declare const AnthropicIntelligenceTool_base: (new (...args: any[]) => {
         tools: string[];
         description: string;
     }>;
-    findMissingParams(methodName: string, params: any): import("@olane/o-protocol/dist").oParameter[];
+    findMissingParams(methodName: string, params: any): import("@olane/o-protocol").oParameter[];
     readonly config: import("@olane/o-core").CoreConfig;
-    p2pNode: import("@olane/o-config/dist").Libp2p;
+    p2pNode: import("libp2p", { with: { "resolution-mode": "import" } }).Libp2p<import("@libp2p/interface", { with: { "resolution-mode": "import" } }).ServiceMap>;
     logger: import("@olane/o-core").Logger;
-    networkConfig: import("@olane/o-config/dist").Libp2pConfig;
+    networkConfig: import("@olane/o-config").Libp2pConfig;
     address: oAddress;
     readonly staticAddress: oAddress;
-    peerId: import("@olane/o-config/dist").PeerId;
+    peerId: import("@libp2p/interface-peer-id", { with: { "resolution-mode": "import" } }).PeerId;
     state: import("@olane/o-core").NodeState;
     errors: Error[];
     connectionManager: import("@olane/o-core").oConnectionManager;
-    leaders: import("@olane/o-config/dist").Multiaddr[];
+    leaders: import("@multiformats/multiaddr", { with: { "resolution-mode": "import" } }).Multiaddr[];
     addressResolution: import("@olane/o-core").oAddressResolution;
     readonly description: string;
     dependencies: import("@olane/o-core").oDependency[];
     methods: {
-        [key: string]: import("@olane/o-protocol/dist").oMethod;
+        [key: string]: import("@olane/o-protocol").oMethod;
     };
     successCount: number;
     errorCount: number;
-    get type(): import("@olane/o-core").NodeType;
-    get transports(): string[];
-    get parent(): oAddress | null;
-    get parentTransports(): import("@olane/o-config/dist").Multiaddr[];
-    getTransports(address: oAddress): import("@olane/o-config/dist").Multiaddr[];
+    readonly type: import("@olane/o-core").NodeType;
+    readonly transports: string[];
+    readonly parent: oAddress | null;
+    readonly parentTransports: import("@multiformats/multiaddr", { with: { "resolution-mode": "import" } }).Multiaddr[];
+    getTransports(address: oAddress): import("@multiformats/multiaddr", { with: { "resolution-mode": "import" } }).Multiaddr[];
     handleStaticAddressTranslation(addressInput: oAddress): Promise<oAddress>;
     translateAddress(addressWithLeaderTransports: oAddress): Promise<{
         nextHopAddress: oAddress;
@@ -66,11 +66,29 @@ declare const AnthropicIntelligenceTool_base: (new (...args: any[]) => {
 export declare class AnthropicIntelligenceTool extends AnthropicIntelligenceTool_base {
     private defaultModel;
     constructor(config: oToolConfig);
+    /**
+     * Chat completion with Anthropic
+     */
     _tool_completion(request: oRequest): Promise<ToolResult>;
+    /**
+     * Generate text with Anthropic (using messages endpoint)
+     */
     _tool_generate(request: oRequest): Promise<ToolResult>;
+    /**
+     * List available models
+     */
     _tool_list_models(request: oRequest): Promise<ToolResult>;
+    /**
+     * Get model information
+     */
     _tool_model_info(request: oRequest): Promise<ToolResult>;
+    /**
+     * Check API status
+     */
     _tool_status(request: oRequest): Promise<ToolResult>;
+    /**
+     * Parameter definitions for completion
+     */
     _params_completion(): {
         type: string;
         properties: {
@@ -177,6 +195,9 @@ export declare class AnthropicIntelligenceTool extends AnthropicIntelligenceTool
         };
         required: string[];
     };
+    /**
+     * Parameter definitions for generate
+     */
     _params_generate(): {
         type: string;
         properties: {
@@ -235,10 +256,16 @@ export declare class AnthropicIntelligenceTool extends AnthropicIntelligenceTool
         };
         required: string[];
     };
+    /**
+     * Parameter definitions for list_models
+     */
     _params_list_models(): {
         type: string;
         properties: {};
     };
+    /**
+     * Parameter definitions for model_info
+     */
     _params_model_info(): {
         type: string;
         properties: {
@@ -249,6 +276,9 @@ export declare class AnthropicIntelligenceTool extends AnthropicIntelligenceTool
             };
         };
     };
+    /**
+     * Parameter definitions for status
+     */
     _params_status(): {
         type: string;
         properties: {};

package/dist/intelligence/anthropic-intelligence.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"anthropic-intelligence.tool.d.ts","sourceRoot":"","sources":["../../src/intelligence/anthropic-intelligence.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,EAAS,WAAW,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;;;;;;aA2BtC,CAAC;;iCAUb,CAAC;iCAKV,CAAC;;;wCASI,CAAC;;;;;;gBASR,CAAF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,qBAAa,yBAA0B,SAAQ,8BAAmB;IAChE,OAAO,CAAC,YAAY,CAA4B;gBAEpC,MAAM,EAAE,WAAW;IAczB,gBAAgB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAuExD,cAAc,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAiFtD,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IA8CzD,gBAAgB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAsDxD,YAAY,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IA2C1D,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAkHlB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgEhB,mBAAmB;;;;IAUnB,kBAAkB;;;;;;;;;;IAgBlB,cAAc;;;;CAMf"}
+{"version":3,"file":"anthropic-intelligence.tool.d.ts","sourceRoot":"","sources":["../../src/intelligence/anthropic-intelligence.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,EAAS,WAAW,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmG/D,qBAAa,yBAA0B,SAAQ,8BAAmB;IAChE,OAAO,CAAC,YAAY,CAA4B;gBAEpC,MAAM,EAAE,WAAW;IAW/B;;OAEG;IACG,gBAAgB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAqE9D;;OAEG;IACG,cAAc,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IA+E5D;;OAEG;IACG,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IA4C/D;;OAEG;IACG,gBAAgB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAoD9D;;OAEG;IACG,YAAY,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAwC1D;;OAEG;IACH,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA+GlB;;OAEG;IACH,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA6DhB;;OAEG;IACH,mBAAmB;;;;IAOnB;;OAEG;IACH,kBAAkB;;;;;;;;;;IAalB;;OAEG;IACH,cAAc;;;;CAMf"}

package/dist/intelligence/anthropic-intelligence.tool.js

@@ -1,17 +1,24 @@
-import { oAddress, oVirtualNode } from '@olane/o-core';
-import { oTool } from '@olane/o-tool';
-import { INTELLIGENCE_PARAMS } from './methods/intelligence.methods';
-export class AnthropicIntelligenceTool extends oTool(oVirtualNode) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicIntelligenceTool = void 0;
+const o_core_1 = require("@olane/o-core");
+const o_tool_1 = require("@olane/o-tool");
+const intelligence_methods_1 = require("./methods/intelligence.methods");
+class AnthropicIntelligenceTool extends (0, o_tool_1.oTool)(o_core_1.oVirtualNode) {
     defaultModel = 'claude-opus-4-20250514';
     constructor(config) {
         super({
             ...config,
-            address: new oAddress('o://anthropic'),
+            address: new o_core_1.oAddress('o://anthropic'),
             description: 'Intelligence tool using Anthropic LLM suite of models',
-            methods: INTELLIGENCE_PARAMS,
+            // shared parameters for all tools
+            methods: intelligence_methods_1.INTELLIGENCE_PARAMS,
             dependencies: [],
         });
     }
+    /**
+     * Chat completion with Anthropic
+     */
     async _tool_completion(request) {
         try {
             const params = request.params;
@@ -51,7 +58,7 @@ export class AnthropicIntelligenceTool extends oTool(oVirtualNode) {
                     error: `Anthropic API error: ${response.status} - ${errorText}`,
                 };
             }
-            const result = await response.json();
+            const result = (await response.json());
             return {
                 message: result.content[0]?.text || '',
                 model: result.model,
@@ -67,6 +74,9 @@ export class AnthropicIntelligenceTool extends oTool(oVirtualNode) {
             };
         }
     }
+    /**
+     * Generate text with Anthropic (using messages endpoint)
+     */
     async _tool_generate(request) {
         try {
             const params = request.params;
@@ -113,7 +123,7 @@ export class AnthropicIntelligenceTool extends oTool(oVirtualNode) {
                     error: `Anthropic API error: ${response.status} - ${errorText}`,
                 };
             }
-            const result = await response.json();
+            const result = (await response.json());
             return {
                 success: true,
                 response: result.content[0]?.text || '',
@@ -130,6 +140,9 @@ export class AnthropicIntelligenceTool extends oTool(oVirtualNode) {
             };
         }
     }
+    /**
+     * List available models
+     */
     async _tool_list_models(request) {
         try {
             const params = request.params;
@@ -154,7 +167,7 @@ export class AnthropicIntelligenceTool extends oTool(oVirtualNode) {
                     error: `Anthropic API error: ${response.status} - ${errorText}`,
                 };
             }
-            const result = await response.json();
+            const result = (await response.json());
             return {
                 success: true,
                 response: result.data,
@@ -168,6 +181,9 @@ export class AnthropicIntelligenceTool extends oTool(oVirtualNode) {
             };
         }
     }
+    /**
+     * Get model information
+     */
     async _tool_model_info(request) {
         try {
             const params = request.params;
@@ -192,7 +208,7 @@ export class AnthropicIntelligenceTool extends oTool(oVirtualNode) {
                     error: `Anthropic API error: ${response.status} - ${errorText}`,
                 };
             }
-            const result = await response.json();
+            const result = (await response.json());
             const modelInfo = result.data.find((m) => m.id === model);
             if (!modelInfo) {
                 return {
@@ -213,6 +229,9 @@ export class AnthropicIntelligenceTool extends oTool(oVirtualNode) {
             };
         }
     }
+    /**
+     * Check API status
+     */
     async _tool_status(request) {
         try {
             const params = request.params;
@@ -249,6 +268,9 @@ export class AnthropicIntelligenceTool extends oTool(oVirtualNode) {
             };
         }
     }
+    /**
+     * Parameter definitions for completion
+     */
     _params_completion() {
         return {
             type: 'object',
@@ -359,6 +381,9 @@ export class AnthropicIntelligenceTool extends oTool(oVirtualNode) {
             required: ['messages'],
         };
     }
+    /**
+     * Parameter definitions for generate
+     */
     _params_generate() {
         return {
             type: 'object',
@@ -419,12 +444,18 @@ export class AnthropicIntelligenceTool extends oTool(oVirtualNode) {
             required: ['prompt'],
         };
     }
+    /**
+     * Parameter definitions for list_models
+     */
     _params_list_models() {
         return {
             type: 'object',
             properties: {},
         };
     }
+    /**
+     * Parameter definitions for model_info
+     */
     _params_model_info() {
         return {
             type: 'object',
@@ -437,6 +468,9 @@ export class AnthropicIntelligenceTool extends oTool(oVirtualNode) {
             },
         };
     }
+    /**
+     * Parameter definitions for status
+     */
     _params_status() {
         return {
             type: 'object',
@@ -444,4 +478,4 @@ export class AnthropicIntelligenceTool extends oTool(oVirtualNode) {
         };
     }
 }
-//# sourceMappingURL=anthropic-intelligence.tool.js.map
+exports.AnthropicIntelligenceTool = AnthropicIntelligenceTool;

package/dist/intelligence/gemini-intelligence.tool.d.ts

@@ -6,13 +6,13 @@ declare const GeminiIntelligenceTool_base: (new (...args: any[]) => {
     initialize(): Promise<void>;
     use(address: oAddress, data: {
         [key: string]: unknown;
-    }, config?: import("@olane/o-core").UseOptions): Promise<import("@olane/o-core").oResponse>;
-    handleStream(streamData: import("@olane/o-config/dist").IncomingStreamData): Promise<void>;
-    execute(req: oRequest, stream?: import("@olane/o-config/dist").Stream): Promise<import("@olane/o-tool").RunResult>;
-    run(request: oRequest, stream?: import("@olane/o-config/dist").Stream): Promise<import("@olane/o-tool").RunResult>;
+    }, config?: import("@olane/o-core").UseOptions | undefined): Promise<import("@olane/o-core").oResponse>;
+    handleStream(streamData: import("@libp2p/interface", { with: { "resolution-mode": "import" } }).IncomingStreamData): Promise<void>;
+    execute(req: oRequest, stream?: import("@libp2p/interface", { with: { "resolution-mode": "import" } }).Stream | undefined): Promise<import("@olane/o-tool").RunResult>;
+    run(request: oRequest, stream?: import("@libp2p/interface", { with: { "resolution-mode": "import" } }).Stream | undefined): Promise<import("@olane/o-tool").RunResult>;
     myTools(): string[];
     myToolParams(tool: string): Record<string, any>;
-    callMyTool(request: oRequest, stream?: import("@olane/o-config/dist").Stream): Promise<ToolResult>;
+    callMyTool(request: oRequest, stream?: import("@libp2p/interface", { with: { "resolution-mode": "import" } }).Stream | undefined): Promise<ToolResult>;
     index(): Promise<{
         provider: string;
         summary: string;
@@ -25,31 +25,31 @@ declare const GeminiIntelligenceTool_base: (new (...args: any[]) => {
         tools: string[];
         description: string;
     }>;
-    findMissingParams(methodName: string, params: any): import("@olane/o-protocol/dist").oParameter[];
+    findMissingParams(methodName: string, params: any): import("@olane/o-protocol").oParameter[];
     readonly config: import("@olane/o-core").CoreConfig;
-    p2pNode: import("@olane/o-config/dist").Libp2p;
+    p2pNode: import("libp2p", { with: { "resolution-mode": "import" } }).Libp2p<import("@libp2p/interface", { with: { "resolution-mode": "import" } }).ServiceMap>;
     logger: import("@olane/o-core").Logger;
-    networkConfig: import("@olane/o-config/dist").Libp2pConfig;
+    networkConfig: import("@olane/o-config").Libp2pConfig;
     address: oAddress;
     readonly staticAddress: oAddress;
-    peerId: import("@olane/o-config/dist").PeerId;
+    peerId: import("@libp2p/interface-peer-id", { with: { "resolution-mode": "import" } }).PeerId;
     state: import("@olane/o-core").NodeState;
     errors: Error[];
     connectionManager: import("@olane/o-core").oConnectionManager;
-    leaders: import("@olane/o-config/dist").Multiaddr[];
+    leaders: import("@multiformats/multiaddr", { with: { "resolution-mode": "import" } }).Multiaddr[];
     addressResolution: import("@olane/o-core").oAddressResolution;
     readonly description: string;
     dependencies: import("@olane/o-core").oDependency[];
     methods: {
-        [key: string]: import("@olane/o-protocol/dist").oMethod;
+        [key: string]: import("@olane/o-protocol").oMethod;
     };
     successCount: number;
     errorCount: number;
-    get type(): import("@olane/o-core").NodeType;
-    get transports(): string[];
-    get parent(): oAddress | null;
-    get parentTransports(): import("@olane/o-config/dist").Multiaddr[];
-    getTransports(address: oAddress): import("@olane/o-config/dist").Multiaddr[];
+    readonly type: import("@olane/o-core").NodeType;
+    readonly transports: string[];
+    readonly parent: oAddress | null;
+    readonly parentTransports: import("@multiformats/multiaddr", { with: { "resolution-mode": "import" } }).Multiaddr[];
+    getTransports(address: oAddress): import("@multiformats/multiaddr", { with: { "resolution-mode": "import" } }).Multiaddr[];
     handleStaticAddressTranslation(addressInput: oAddress): Promise<oAddress>;
     translateAddress(addressWithLeaderTransports: oAddress): Promise<{
         nextHopAddress: oAddress;
@@ -68,10 +68,25 @@ export declare class GeminiIntelligenceTool extends GeminiIntelligenceTool_base
     private baseUrl;
     private defaultModel;
     constructor(config: oToolConfig);
+    /**
+     * Chat completion with Gemini
+     */
     _tool_completion(request: oRequest): Promise<ToolResult>;
+    /**
+     * Generate text with Gemini
+     */
     _tool_generate(request: oRequest): Promise<ToolResult>;
+    /**
+     * List available models
+     */
     _tool_list_models(request: oRequest): Promise<ToolResult>;
+    /**
+     * Get model information
+     */
     _tool_model_info(request: oRequest): Promise<ToolResult>;
+    /**
+     * Check Gemini API status
+     */
     _tool_status(request: oRequest): Promise<ToolResult>;
 }
 export {};

package/dist/intelligence/gemini-intelligence.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gemini-intelligence.tool.d.ts","sourceRoot":"","sources":["../../src/intelligence/gemini-intelligence.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,EAAS,WAAW,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;;;;;;aA8BvD,CAAD;;iCAOK,CAAC;iCAIM,CAAC;;;wCAQd,CAAC;;;;;;gBAYH,CAAD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDH,qBAAa,sBAAuB,SAAQ,2BAAmB;IAC7D,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,YAAY,CAAS;gBAEjB,MAAM,EAAE,WAAW;IAazB,gBAAgB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAoFxD,cAAc,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAqFtD,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IA4CzD,gBAAgB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IA+CxD,YAAY,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;CAiC3D"}
+{"version":3,"file":"gemini-intelligence.tool.d.ts","sourceRoot":"","sources":["../../src/intelligence/gemini-intelligence.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,EAAS,WAAW,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiH/D,qBAAa,sBAAuB,SAAQ,2BAAmB;IAC7D,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,YAAY,CAAU;gBAElB,MAAM,EAAE,WAAW;IAU/B;;OAEG;IACG,gBAAgB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAkF9D;;OAEG;IACG,cAAc,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAmF5D;;OAEG;IACG,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IA0C/D;;OAEG;IACG,gBAAgB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IA4C9D;;OAEG;IACG,YAAY,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;CAiC3D"}