@olane/o-tool-registry 0.6.6 → 0.6.9

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

@@ -0,0 +1,224 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,477 @@
+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: {},
+        };
+    }
+}