@olane/o-intelligence 0.6.1

package/dist/src/intelligence.tool.js

@@ -0,0 +1,201 @@
+import { oVirtualTool } from '@olane/o-tool';
+import { oAddress } from '@olane/o-core';
+import { AnthropicIntelligenceTool } from './anthropic-intelligence.tool.js';
+import { OpenAIIntelligenceTool } from './openai-intelligence.tool.js';
+import { OllamaIntelligenceTool } from './ollama-intelligence.tool.js';
+import { PerplexityIntelligenceTool } from './perplexity-intelligence.tool.js';
+import { GrokIntelligenceTool } from './grok-intelligence.tool.js';
+import { INTELLIGENCE_PARAMS } from './methods/intelligence.methods.js';
+import { IntelligenceStorageKeys } from './enums/intelligence-storage-keys.enum.js';
+import { LLMProviders } from './enums/llm-providers.enum.js';
+export class IntelligenceTool extends oVirtualTool {
+    constructor(config) {
+        super({
+            ...config,
+            address: new oAddress('o://intelligence'),
+            methods: INTELLIGENCE_PARAMS,
+            description: config.description ||
+                'Tool to help route LLM requests to the best intelligence tool',
+            dependencies: [
+                {
+                    address: 'o://setup',
+                    parameters: [
+                        {
+                            name: 'intelligence',
+                            type: 'string',
+                            description: 'The intelligence tool to use',
+                        },
+                    ],
+                },
+            ],
+        });
+        this.roundRobinIndex = 0;
+        this.addChildNode(new AnthropicIntelligenceTool({
+            ...config,
+            parent: null,
+            leader: null,
+        }));
+        this.addChildNode(new OpenAIIntelligenceTool({
+            ...config,
+            parent: null,
+            leader: null,
+        }));
+        this.addChildNode(new OllamaIntelligenceTool({
+            ...config,
+            parent: null,
+            leader: null,
+        }));
+        this.addChildNode(new PerplexityIntelligenceTool({
+            ...config,
+            parent: null,
+            leader: null,
+        }));
+        this.addChildNode(new GrokIntelligenceTool({
+            ...config,
+            parent: null,
+            leader: null,
+        }));
+    }
+    async getModelProvider() {
+        // check ENV vars for override
+        if (process.env.MODEL_PROVIDER_CHOICE) {
+            if (Object.values(LLMProviders).includes(process.env.MODEL_PROVIDER_CHOICE)) {
+                return {
+                    provider: process.env.MODEL_PROVIDER_CHOICE,
+                };
+            }
+            throw new Error('Invalid model provider choice, please set the MODEL_PROVIDER_CHOICE environment variable to a valid model provider');
+        }
+        // check secure storage for preference
+        const config = await this.use(new oAddress('o://secure-storage'), {
+            method: 'get',
+            params: {
+                key: IntelligenceStorageKeys.MODEL_PROVIDER_PREFERENCE,
+            },
+        });
+        const payload = config.result.data;
+        if (payload && payload.value) {
+            const modelProvider = payload.value;
+            return {
+                provider: modelProvider,
+            };
+        }
+        // we need to ask the human for the model provider
+        this.logger.info('Asking human for model selection');
+        const modelResponse = await this.use(new oAddress('o://human'), {
+            method: 'question',
+            params: {
+                question: 'Which AI model do you want to use? (anthropic, openai, ollama, perplexity, grok)',
+            },
+        });
+        // process the human response
+        const { answer: model } = modelResponse.result.data;
+        await this.use(new oAddress('o://secure-storage'), {
+            method: 'put',
+            params: {
+                key: IntelligenceStorageKeys.MODEL_PROVIDER_PREFERENCE,
+                value: model,
+            },
+        });
+        return {
+            provider: model,
+        };
+    }
+    async getProviderApiKey(provider) {
+        // leverage the ENV vars first
+        const ENV_KEYS = [
+            {
+                key: process.env.ANTHROPIC_API_KEY,
+                address: 'o://anthropic',
+                name: 'anthropic',
+            },
+            {
+                key: process.env.OPENAI_API_KEY,
+                address: 'o://openai',
+                name: 'openai',
+            },
+            {
+                key: process.env.SONAR_API_KEY,
+                address: 'o://sonar',
+                name: 'sonar',
+            },
+            {
+                key: process.env.GEMINI_API_KEY,
+                address: 'o://gemini',
+                name: 'gemini',
+            },
+            {
+                key: process.env.GROK_API_KEY,
+                address: 'o://grok',
+                name: 'grok',
+            },
+        ];
+        const modelEnvConfig = ENV_KEYS.find((key) => key.name === provider);
+        if (modelEnvConfig && !!modelEnvConfig.key) {
+            return {
+                apiKey: modelEnvConfig.key,
+            };
+        }
+        // check secure storage 2nd
+        const config = await this.use(new oAddress('o://secure-storage'), {
+            method: 'get',
+            params: {
+                key: `${provider}-${IntelligenceStorageKeys.API_KEY_SUFFIX}`,
+            },
+        });
+        const payload = config.result.data;
+        if (payload && payload.value) {
+            const apiKey = payload.value;
+            return {
+                apiKey,
+            };
+        }
+        // we need to ask the human for the api key
+        const keyResponse = await this.use(new oAddress('o://human'), {
+            method: 'question',
+            params: {
+                question: `What is the API key for the ${provider} model?`,
+            },
+        });
+        // process the human response
+        const { answer: key } = keyResponse.result.data;
+        await this.use(new oAddress('o://secure-storage'), {
+            method: 'put',
+            params: {
+                key: `${provider}-${IntelligenceStorageKeys.API_KEY_SUFFIX}`,
+                value: key,
+            },
+        });
+        return {
+            apiKey: key,
+        };
+    }
+    async chooseIntelligence(request) {
+        // check to see if anthropic key is in vault
+        const { provider } = await this.getModelProvider();
+        const { apiKey } = await this.getProviderApiKey(provider);
+        return {
+            choice: new oAddress(`o://${provider}`),
+            apiKey,
+        };
+    }
+    // we cannot wrap this tool use in a plan because it is a core dependency in all planning
+    async _tool_prompt(request) {
+        const { prompt } = request.params;
+        const intelligence = await this.chooseIntelligence(request);
+        this.logger.debug('Using AI provider: ', intelligence.choice);
+        const response = await this.use(intelligence.choice, {
+            method: 'completion',
+            params: {
+                apiKey: intelligence.apiKey,
+                messages: [
+                    {
+                        role: 'user',
+                        content: prompt,
+                    },
+                ],
+            },
+        });
+        return response.result.data;
+    }
+}

package/dist/src/methods/intelligence.methods.d.ts

@@ -0,0 +1,5 @@
+import { oMethod } from '@olane/o-protocol';
+export declare const INTELLIGENCE_PARAMS: {
+    [key: string]: oMethod;
+};
+//# sourceMappingURL=intelligence.methods.d.ts.map

package/dist/src/methods/intelligence.methods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intelligence.methods.d.ts","sourceRoot":"","sources":["../../../src/methods/intelligence.methods.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAE5C,eAAO,MAAM,mBAAmB,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAmIzD,CAAC"}

package/dist/src/methods/intelligence.methods.js

@@ -0,0 +1,132 @@
+export const INTELLIGENCE_PARAMS = {
+    completion: {
+        name: 'completion',
+        description: 'Completion',
+        dependencies: [],
+        parameters: [
+            {
+                name: 'model',
+                type: 'string',
+                value: 'string',
+                description: 'The model to use for generation',
+                required: false,
+            },
+            {
+                name: 'messages',
+                type: 'array',
+                value: 'string[]',
+                description: 'The messages to use for generation',
+            },
+            {
+                name: 'options',
+                type: 'object',
+                value: 'object',
+                description: 'The options to use for generation',
+                required: false,
+            },
+        ],
+    },
+    generate: {
+        name: 'generate',
+        description: 'Generate',
+        dependencies: [],
+        parameters: [
+            {
+                name: 'model',
+                type: 'string',
+                value: 'string',
+                description: 'The model to use for generation',
+            },
+        ],
+    },
+    list_models: {
+        name: 'list_models',
+        description: 'List models',
+        dependencies: [],
+        parameters: [],
+    },
+    pull_model: {
+        name: 'pull_model',
+        description: 'Pull model',
+        dependencies: [],
+        parameters: [
+            {
+                name: 'model',
+                type: 'string',
+                value: 'string',
+                description: 'The model to pull',
+            },
+            {
+                name: 'insecure',
+                type: 'boolean',
+                value: 'boolean',
+                description: 'Whether to allow insecure connections',
+            },
+        ],
+    },
+    delete_model: {
+        name: 'delete_model',
+        description: 'Delete model',
+        dependencies: [],
+        parameters: [
+            {
+                name: 'model',
+                type: 'string',
+                value: 'string',
+                description: 'The model to delete',
+            },
+        ],
+    },
+    model_info: {
+        name: 'model_info',
+        description: 'Model info',
+        dependencies: [],
+        parameters: [
+            {
+                name: 'model',
+                type: 'string',
+                value: 'string',
+                description: 'The model to get info for',
+            },
+        ],
+    },
+    status: {
+        name: 'status',
+        description: 'Status',
+        dependencies: [],
+        parameters: [],
+    },
+    prompt: {
+        name: 'prompt',
+        description: 'Generate a response using AI based on a prompt',
+        dependencies: [],
+        parameters: [
+            {
+                name: 'prompt',
+                type: 'string',
+                value: 'string',
+                description: 'The prompt to send to the AI model',
+            },
+        ],
+    },
+    search: {
+        name: 'search',
+        description: 'Search for information using AI search capabilities',
+        dependencies: [],
+        parameters: [
+            {
+                name: 'query',
+                type: 'string',
+                value: 'string',
+                description: 'The search query to execute',
+            },
+            {
+                name: 'focus',
+                type: 'string',
+                value: 'string',
+                description: 'The focus area for the search',
+                required: false,
+            },
+        ],
+    },
+};

package/dist/src/ollama-intelligence.tool.d.ts

@@ -0,0 +1,36 @@
+import { oRequest } from '@olane/o-core';
+import { oToolConfig, oVirtualTool, ToolResult } from '@olane/o-tool';
+export declare class OllamaIntelligenceTool extends oVirtualTool {
+    static defaultModel: string;
+    static defaultUrl: string;
+    constructor(config: oToolConfig);
+    /**
+     * Chat completion with Ollama
+     */
+    _tool_completion(request: oRequest): Promise<ToolResult>;
+    /**
+     * Generate text with Ollama
+     */
+    _tool_generate(request: oRequest): Promise<ToolResult>;
+    /**
+     * List available models
+     */
+    _tool_list_models(request: oRequest): Promise<ToolResult>;
+    /**
+     * Pull a model from Ollama library
+     */
+    _tool_pull_model(request: oRequest): Promise<ToolResult>;
+    /**
+     * Delete a model
+     */
+    _tool_delete_model(request: oRequest): Promise<ToolResult>;
+    /**
+     * Get model information
+     */
+    _tool_model_info(request: oRequest): Promise<ToolResult>;
+    /**
+     * Check Ollama server status
+     */
+    _tool_status(request: oRequest): Promise<ToolResult>;
+}
+//# sourceMappingURL=ollama-intelligence.tool.d.ts.map

package/dist/src/ollama-intelligence.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ollama-intelligence.tool.d.ts","sourceRoot":"","sources":["../../src/ollama-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;AA+G7E,qBAAa,sBAAuB,SAAQ,YAAY;IACtD,MAAM,CAAC,YAAY,SAAqB;IACxC,MAAM,CAAC,UAAU,SAA4B;gBAEjC,MAAM,EAAE,WAAW;IAY/B;;OAEG;IACG,gBAAgB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IA4D9D;;OAEG;IACG,cAAc,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAgE5D;;OAEG;IACG,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAmC/D;;OAEG;IACG,gBAAgB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAiE9D;;OAEG;IACG,kBAAkB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IA6ChE;;OAEG;IACG,gBAAgB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAwC9D;;OAEG;IACG,YAAY,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;CAyB3D"}

package/dist/src/ollama-intelligence.tool.js

@@ -0,0 +1,312 @@
+import { oAddress } from '@olane/o-core';
+import { oVirtualTool } from '@olane/o-tool';
+import { INTELLIGENCE_PARAMS } from './methods/intelligence.methods.js';
+export class OllamaIntelligenceTool extends oVirtualTool {
+    constructor(config) {
+        super({
+            ...config,
+            address: new oAddress('o://ollama'),
+            description: 'Intelligence tool using Ollama LLM suite of models',
+            methods: INTELLIGENCE_PARAMS,
+            dependencies: [],
+        });
+        // this.baseUrl = config.ollamaUrl || 'http://localhost:11434';
+        // this.defaultModel = config.defaultModel || 'llama2';
+    }
+    /**
+     * Chat completion with Ollama
+     */
+    async _tool_completion(request) {
+        try {
+            const params = request.params;
+            const { model = OllamaIntelligenceTool.defaultModel, messages, options = {}, } = params;
+            // let's validate the params and ask for ones that are missing
+            if (!messages || !Array.isArray(messages)) {
+                return {
+                    success: false,
+                    error: '"messages" array is required',
+                };
+            }
+            const chatRequest = {
+                model: model,
+                messages: messages,
+                stream: false,
+                options: options,
+            };
+            const response = await fetch(`${OllamaIntelligenceTool.defaultUrl}/api/chat`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(chatRequest),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                return {
+                    success: false,
+                    error: `Ollama API error: ${response.status} - ${errorText}`,
+                };
+            }
+            const result = (await response.json());
+            return {
+                message: result.message.content,
+                model: result.model,
+                total_duration: result.total_duration,
+                eval_count: result.eval_count,
+                eval_duration: result.eval_duration,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to complete chat: ${error.message}`,
+            };
+        }
+    }
+    /**
+     * Generate text with Ollama
+     */
+    async _tool_generate(request) {
+        try {
+            const params = request.params;
+            const { model = OllamaIntelligenceTool.defaultModel, prompt, system, options = {}, } = params;
+            if (!prompt) {
+                return {
+                    success: false,
+                    error: 'Prompt is required',
+                };
+            }
+            const generateRequest = {
+                model: model,
+                prompt: prompt,
+                system: system,
+                stream: false,
+                options: options,
+            };
+            const response = await fetch(`${OllamaIntelligenceTool.defaultUrl}/api/generate`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(generateRequest),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                return {
+                    success: false,
+                    error: `Ollama API error: ${response.status} - ${errorText}`,
+                };
+            }
+            const result = (await response.json());
+            return {
+                success: true,
+                response: result.response,
+                model: result.model,
+                done: result.done,
+                total_duration: result.total_duration,
+                eval_count: result.eval_count,
+                eval_duration: result.eval_duration,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to generate text: ${error.message}`,
+            };
+        }
+    }
+    /**
+     * List available models
+     */
+    async _tool_list_models(request) {
+        try {
+            const response = await fetch(`${OllamaIntelligenceTool.defaultUrl}/api/tags`, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                return {
+                    success: false,
+                    error: `Ollama API error: ${response.status} - ${errorText}`,
+                };
+            }
+            const result = (await response.json());
+            return {
+                success: true,
+                models: result.models,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to list models: ${error.message}`,
+            };
+        }
+    }
+    /**
+     * Pull a model from Ollama library
+     */
+    async _tool_pull_model(request) {
+        try {
+            const params = request.params;
+            const { model, insecure = false } = params;
+            if (!model) {
+                return {
+                    success: false,
+                    error: 'Model name is required',
+                };
+            }
+            const response = await fetch(`${OllamaIntelligenceTool.defaultUrl}/api/pull`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    name: model,
+                    insecure: insecure,
+                }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                return {
+                    success: false,
+                    error: `Ollama API error: ${response.status} - ${errorText}`,
+                };
+            }
+            // For pull operations, we need to handle streaming response
+            const reader = response.body?.getReader();
+            if (!reader) {
+                return {
+                    success: false,
+                    error: 'Failed to read response stream',
+                };
+            }
+            let result = '';
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                const chunk = new TextDecoder().decode(value);
+                result += chunk;
+            }
+            return {
+                success: true,
+                message: `Model ${model} pulled successfully`,
+                details: result,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to pull model: ${error.message}`,
+            };
+        }
+    }
+    /**
+     * Delete a model
+     */
+    async _tool_delete_model(request) {
+        try {
+            const params = request.params;
+            const { model } = params;
+            if (!model) {
+                return {
+                    success: false,
+                    error: 'Model name is required',
+                };
+            }
+            const response = await fetch(`${OllamaIntelligenceTool.defaultUrl}/api/delete`, {
+                method: 'DELETE',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    name: model,
+                }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                return {
+                    success: false,
+                    error: `Ollama API error: ${response.status} - ${errorText}`,
+                };
+            }
+            return {
+                success: true,
+                message: `Model ${model} deleted successfully`,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to delete model: ${error.message}`,
+            };
+        }
+    }
+    /**
+     * Get model information
+     */
+    async _tool_model_info(request) {
+        try {
+            const params = request.params;
+            const { model = OllamaIntelligenceTool.defaultModel } = params;
+            const response = await fetch(`${OllamaIntelligenceTool.defaultUrl}/api/show`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    name: model,
+                }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                return {
+                    success: false,
+                    error: `Ollama API error: ${response.status} - ${errorText}`,
+                };
+            }
+            const result = (await response.json());
+            return {
+                success: true,
+                model_info: result,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to get model info: ${error.message}`,
+            };
+        }
+    }
+    /**
+     * Check Ollama server status
+     */
+    async _tool_status(request) {
+        try {
+            const response = await fetch(`${OllamaIntelligenceTool.defaultUrl}/api/tags`, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            return {
+                success: response.ok,
+                status: response.ok ? 'online' : 'offline',
+                status_code: response.status,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                status: 'offline',
+                error: `Connection failed: ${error.message}`,
+            };
+        }
+    }
+}
+OllamaIntelligenceTool.defaultModel = 'llama3.2:latest';
+OllamaIntelligenceTool.defaultUrl = 'http://localhost:11434';