@olane/o-tool-registry 0.6.5 → 0.6.7

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

@@ -1,224 +0,0 @@
-import { oRequest } from '@olane/o-core';
-import { oToolConfig, oVirtualTool, ToolResult } from '@olane/o-tool';
-export declare class AnthropicIntelligenceTool extends oVirtualTool {
-    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: {
-            model: {
-                type: string;
-                description: string;
-                default: string;
-            };
-            messages: {
-                type: string;
-                description: string;
-                items: {
-                    type: string;
-                    properties: {
-                        role: {
-                            type: string;
-                            enum: string[];
-                            description: string;
-                        };
-                        content: {
-                            oneOf: ({
-                                type: string;
-                                description: string;
-                                items?: undefined;
-                            } | {
-                                type: string;
-                                description: string;
-                                items: {
-                                    type: string;
-                                    properties: {
-                                        type: {
-                                            type: string;
-                                            enum: string[];
-                                        };
-                                        text: {
-                                            type: string;
-                                        };
-                                        source: {
-                                            type: string;
-                                            properties: {
-                                                type: {
-                                                    type: string;
-                                                    enum: string[];
-                                                };
-                                                media_type: {
-                                                    type: string;
-                                                };
-                                                data: {
-                                                    type: string;
-                                                };
-                                            };
-                                        };
-                                    };
-                                };
-                            })[];
-                        };
-                    };
-                    required: string[];
-                };
-            };
-            system: {
-                type: string;
-                description: string;
-            };
-            max_tokens: {
-                type: string;
-                description: string;
-                default: number;
-            };
-            temperature: {
-                type: string;
-                description: string;
-                minimum: number;
-                maximum: number;
-            };
-            top_p: {
-                type: string;
-                description: string;
-                minimum: number;
-                maximum: number;
-            };
-            top_k: {
-                type: string;
-                description: string;
-                minimum: number;
-            };
-            stop_sequences: {
-                type: string;
-                description: string;
-                items: {
-                    type: string;
-                };
-            };
-            metadata: {
-                type: string;
-                description: string;
-                properties: {
-                    user_id: {
-                        type: string;
-                        description: string;
-                    };
-                };
-            };
-        };
-        required: string[];
-    };
-    /**
-     * Parameter definitions for generate
-     */
-    _params_generate(): {
-        type: string;
-        properties: {
-            model: {
-                type: string;
-                description: string;
-                default: string;
-            };
-            prompt: {
-                type: string;
-                description: string;
-            };
-            system: {
-                type: string;
-                description: string;
-            };
-            max_tokens: {
-                type: string;
-                description: string;
-                default: number;
-            };
-            temperature: {
-                type: string;
-                description: string;
-                minimum: number;
-                maximum: number;
-            };
-            top_p: {
-                type: string;
-                description: string;
-                minimum: number;
-                maximum: number;
-            };
-            top_k: {
-                type: string;
-                description: string;
-                minimum: number;
-            };
-            stop_sequences: {
-                type: string;
-                description: string;
-                items: {
-                    type: string;
-                };
-            };
-            metadata: {
-                type: string;
-                description: string;
-                properties: {
-                    user_id: {
-                        type: string;
-                        description: string;
-                    };
-                };
-            };
-        };
-        required: string[];
-    };
-    /**
-     * Parameter definitions for list_models
-     */
-    _params_list_models(): {
-        type: string;
-        properties: {};
-    };
-    /**
-     * Parameter definitions for model_info
-     */
-    _params_model_info(): {
-        type: string;
-        properties: {
-            model: {
-                type: string;
-                description: string;
-                default: string;
-            };
-        };
-    };
-    /**
-     * Parameter definitions for status
-     */
-    _params_status(): {
-        type: string;
-        properties: {};
-    };
-}
-//# sourceMappingURL=anthropic-intelligence.tool.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"anthropic-intelligence.tool.d.ts","sourceRoot":"","sources":["../../src/intelligence/anthropic-intelligence.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,QAAQ,EAAgB,MAAM,eAAe,CAAC;AACjE,OAAO,EAAS,WAAW,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAmG7E,qBAAa,yBAA0B,SAAQ,YAAY;IACzD,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,477 +0,0 @@
-import { oAddress } from '@olane/o-core';
-import { oVirtualTool } from '@olane/o-tool';
-import { INTELLIGENCE_PARAMS } from './methods/intelligence.methods.js';
-export class AnthropicIntelligenceTool extends oVirtualTool {
-    constructor(config) {
-        super({
-            ...config,
-            address: new oAddress('o://anthropic'),
-            description: 'Intelligence tool using Anthropic LLM suite of models',
-            // shared parameters for all tools
-            methods: INTELLIGENCE_PARAMS,
-            dependencies: [],
-        });
-        this.defaultModel = 'claude-opus-4-20250514';
-    }
-    /**
-     * Chat completion with Anthropic
-     */
-    async _tool_completion(request) {
-        try {
-            const params = request.params;
-            const { model = this.defaultModel, messages, system, max_tokens = 1000, apiKey, } = params;
-            if (!apiKey) {
-                return {
-                    success: false,
-                    error: 'Anthropic API key is required',
-                };
-            }
-            if (!messages || !Array.isArray(messages)) {
-                return {
-                    success: false,
-                    error: '"messages" array is required',
-                };
-            }
-            const chatRequest = {
-                model: model,
-                max_tokens: max_tokens,
-                messages: messages,
-                system: system,
-                stream: false,
-            };
-            const response = await fetch(`https://api.anthropic.com/v1/messages`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'x-api-key': apiKey,
-                    'anthropic-version': '2023-06-01',
-                },
-                body: JSON.stringify(chatRequest),
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                return {
-                    success: false,
-                    error: `Anthropic API error: ${response.status} - ${errorText}`,
-                };
-            }
-            const result = (await response.json());
-            return {
-                message: result.content[0]?.text || '',
-                model: result.model,
-                usage: result.usage,
-                stop_reason: result.stop_reason,
-                stop_sequence: result.stop_sequence,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: `Failed to complete chat: ${error.message}`,
-            };
-        }
-    }
-    /**
-     * Generate text with Anthropic (using messages endpoint)
-     */
-    async _tool_generate(request) {
-        try {
-            const params = request.params;
-            const { model = this.defaultModel, prompt, system, max_tokens = 1000, apiKey, ...options } = params;
-            if (!apiKey) {
-                return {
-                    success: false,
-                    error: 'Anthropic API key is required',
-                };
-            }
-            if (!prompt) {
-                return {
-                    success: false,
-                    error: 'Prompt is required',
-                };
-            }
-            const messages = [
-                {
-                    role: 'user',
-                    content: prompt,
-                },
-            ];
-            const generateRequest = {
-                model: model,
-                max_tokens: max_tokens,
-                messages,
-                system: system,
-                stream: false,
-                ...options,
-            };
-            const response = await fetch(`https://api.anthropic.com/v1/messages`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'x-api-key': apiKey,
-                    'anthropic-version': '2023-06-01',
-                },
-                body: JSON.stringify(generateRequest),
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                return {
-                    success: false,
-                    error: `Anthropic API error: ${response.status} - ${errorText}`,
-                };
-            }
-            const result = (await response.json());
-            return {
-                success: true,
-                response: result.content[0]?.text || '',
-                model: result.model,
-                usage: result.usage,
-                stop_reason: result.stop_reason,
-                stop_sequence: result.stop_sequence,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: `Failed to generate text: ${error.message}`,
-            };
-        }
-    }
-    /**
-     * List available models
-     */
-    async _tool_list_models(request) {
-        try {
-            const params = request.params;
-            const { apiKey } = params;
-            if (!apiKey) {
-                return {
-                    success: false,
-                    error: 'Anthropic API key is required',
-                };
-            }
-            const response = await fetch(`https://api.anthropic.com/v1/models`, {
-                method: 'GET',
-                headers: {
-                    'x-api-key': apiKey,
-                    'anthropic-version': '2023-06-01',
-                },
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                return {
-                    success: false,
-                    error: `Anthropic API error: ${response.status} - ${errorText}`,
-                };
-            }
-            const result = (await response.json());
-            return {
-                success: true,
-                response: result.data,
-                models: result.data,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: `Failed to list models: ${error.message}`,
-            };
-        }
-    }
-    /**
-     * Get model information
-     */
-    async _tool_model_info(request) {
-        try {
-            const params = request.params;
-            const { model = this.defaultModel, apiKey } = params;
-            if (!apiKey) {
-                return {
-                    success: false,
-                    error: 'Anthropic API key is required',
-                };
-            }
-            const response = await fetch(`https://api.anthropic.com/v1/models`, {
-                method: 'GET',
-                headers: {
-                    'x-api-key': apiKey,
-                    'anthropic-version': '2023-06-01',
-                },
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                return {
-                    success: false,
-                    error: `Anthropic API error: ${response.status} - ${errorText}`,
-                };
-            }
-            const result = (await response.json());
-            const modelInfo = result.data.find((m) => m.id === model);
-            if (!modelInfo) {
-                return {
-                    success: false,
-                    error: `Model ${model} not found`,
-                };
-            }
-            return {
-                success: true,
-                response: modelInfo,
-                model: modelInfo,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: `Failed to get model info: ${error.message}`,
-            };
-        }
-    }
-    /**
-     * Check API status
-     */
-    async _tool_status(request) {
-        try {
-            const params = request.params;
-            const { apiKey } = params;
-            if (!apiKey) {
-                return {
-                    success: false,
-                    error: 'Anthropic API key is required',
-                };
-            }
-            const response = await fetch(`https://api.anthropic.com/v1/models`, {
-                method: 'GET',
-                headers: {
-                    'x-api-key': apiKey,
-                    'anthropic-version': '2023-06-01',
-                },
-            });
-            if (!response.ok) {
-                return {
-                    success: false,
-                    error: `Anthropic API is not accessible: ${response.status}`,
-                };
-            }
-            return {
-                success: true,
-                response: 'Anthropic API is accessible',
-                status: 'ok',
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: `Failed to check status: ${error.message}`,
-            };
-        }
-    }
-    /**
-     * Parameter definitions for completion
-     */
-    _params_completion() {
-        return {
-            type: 'object',
-            properties: {
-                model: {
-                    type: 'string',
-                    description: 'The model to use for completion',
-                    default: this.defaultModel,
-                },
-                messages: {
-                    type: 'array',
-                    description: 'Array of messages in the conversation',
-                    items: {
-                        type: 'object',
-                        properties: {
-                            role: {
-                                type: 'string',
-                                enum: ['user', 'assistant'],
-                                description: 'The role of the message sender',
-                            },
-                            content: {
-                                oneOf: [
-                                    {
-                                        type: 'string',
-                                        description: 'Text content',
-                                    },
-                                    {
-                                        type: 'array',
-                                        description: 'Array of content blocks',
-                                        items: {
-                                            type: 'object',
-                                            properties: {
-                                                type: {
-                                                    type: 'string',
-                                                    enum: ['text', 'image'],
-                                                },
-                                                text: {
-                                                    type: 'string',
-                                                },
-                                                source: {
-                                                    type: 'object',
-                                                    properties: {
-                                                        type: {
-                                                            type: 'string',
-                                                            enum: ['base64'],
-                                                        },
-                                                        media_type: {
-                                                            type: 'string',
-                                                        },
-                                                        data: {
-                                                            type: 'string',
-                                                        },
-                                                    },
-                                                },
-                                            },
-                                        },
-                                    },
-                                ],
-                            },
-                        },
-                        required: ['role', 'content'],
-                    },
-                },
-                system: {
-                    type: 'string',
-                    description: 'System message to set the behavior of the assistant',
-                },
-                max_tokens: {
-                    type: 'number',
-                    description: 'Maximum number of tokens to generate',
-                    default: 1000,
-                },
-                temperature: {
-                    type: 'number',
-                    description: 'Controls randomness in the response',
-                    minimum: 0,
-                    maximum: 1,
-                },
-                top_p: {
-                    type: 'number',
-                    description: 'Controls diversity via nucleus sampling',
-                    minimum: 0,
-                    maximum: 1,
-                },
-                top_k: {
-                    type: 'number',
-                    description: 'Controls diversity via top-k sampling',
-                    minimum: 0,
-                },
-                stop_sequences: {
-                    type: 'array',
-                    description: 'Sequences that will stop generation',
-                    items: {
-                        type: 'string',
-                    },
-                },
-                metadata: {
-                    type: 'object',
-                    description: 'Optional metadata',
-                    properties: {
-                        user_id: {
-                            type: 'string',
-                            description: 'User ID for tracking',
-                        },
-                    },
-                },
-            },
-            required: ['messages'],
-        };
-    }
-    /**
-     * Parameter definitions for generate
-     */
-    _params_generate() {
-        return {
-            type: 'object',
-            properties: {
-                model: {
-                    type: 'string',
-                    description: 'The model to use for generation',
-                    default: this.defaultModel,
-                },
-                prompt: {
-                    type: 'string',
-                    description: 'The prompt to generate text from',
-                },
-                system: {
-                    type: 'string',
-                    description: 'System message to set the behavior of the assistant',
-                },
-                max_tokens: {
-                    type: 'number',
-                    description: 'Maximum number of tokens to generate',
-                    default: 1000,
-                },
-                temperature: {
-                    type: 'number',
-                    description: 'Controls randomness in the response',
-                    minimum: 0,
-                    maximum: 1,
-                },
-                top_p: {
-                    type: 'number',
-                    description: 'Controls diversity via nucleus sampling',
-                    minimum: 0,
-                    maximum: 1,
-                },
-                top_k: {
-                    type: 'number',
-                    description: 'Controls diversity via top-k sampling',
-                    minimum: 0,
-                },
-                stop_sequences: {
-                    type: 'array',
-                    description: 'Sequences that will stop generation',
-                    items: {
-                        type: 'string',
-                    },
-                },
-                metadata: {
-                    type: 'object',
-                    description: 'Optional metadata',
-                    properties: {
-                        user_id: {
-                            type: 'string',
-                            description: 'User ID for tracking',
-                        },
-                    },
-                },
-            },
-            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',
-            properties: {
-                model: {
-                    type: 'string',
-                    description: 'The model to get information about',
-                    default: this.defaultModel,
-                },
-            },
-        };
-    }
-    /**
-     * Parameter definitions for status
-     */
-    _params_status() {
-        return {
-            type: 'object',
-            properties: {},
-        };
-    }
-}