@olane/o-intelligence 0.6.1

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

@@ -0,0 +1,267 @@
+import { oAddress } from '@olane/o-core';
+import { oVirtualTool } from '@olane/o-tool';
+import { INTELLIGENCE_PARAMS } from './methods/intelligence.methods.js';
+export class GeminiIntelligenceTool extends oVirtualTool {
+    constructor(config) {
+        super({
+            ...config,
+            address: new oAddress('o://gemini'),
+            description: 'Intelligence tool using Google Gemini suite of models',
+            methods: INTELLIGENCE_PARAMS,
+            dependencies: [],
+        });
+    }
+    /**
+     * Chat completion with Gemini
+     */
+    async _tool_completion(request) {
+        try {
+            const params = request.params;
+            const { model = this.defaultModel, messages, ...options } = params;
+            if (!this.apiKey) {
+                return {
+                    success: false,
+                    error: 'Gemini API key is required',
+                };
+            }
+            if (!messages || !Array.isArray(messages)) {
+                return {
+                    success: false,
+                    error: '"messages" array is required',
+                };
+            }
+            // Convert messages to Gemini format
+            const contents = messages.map((msg) => ({
+                role: msg.role === 'assistant' ? 'model' : 'user',
+                parts: [{ text: msg.content }],
+            }));
+            const chatRequest = {
+                contents,
+                generationConfig: {
+                    temperature: options.temperature,
+                    topK: options.topK,
+                    topP: options.topP,
+                    maxOutputTokens: options.maxOutputTokens,
+                    stopSequences: options.stopSequences,
+                },
+                safetySettings: options.safetySettings,
+            };
+            const response = await fetch(`${this.baseUrl}/models/${model}:generateContent?key=${this.apiKey}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(chatRequest),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                return {
+                    success: false,
+                    error: `Gemini API error: ${response.status} - ${errorText}`,
+                };
+            }
+            const result = (await response.json());
+            if (!result.candidates || result.candidates.length === 0) {
+                return {
+                    success: false,
+                    error: 'No response generated from Gemini',
+                };
+            }
+            return {
+                success: true,
+                response: result.candidates[0].content.parts[0]?.text || '',
+                model: model,
+                usage: result.usageMetadata,
+                finish_reason: result.candidates[0].finishReason,
+                safety_ratings: result.candidates[0].safetyRatings,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to complete chat: ${error.message}`,
+            };
+        }
+    }
+    /**
+     * Generate text with Gemini
+     */
+    async _tool_generate(request) {
+        try {
+            const params = request.params;
+            const { model = this.defaultModel, prompt, system, ...options } = params;
+            if (!this.apiKey) {
+                return {
+                    success: false,
+                    error: 'Gemini API key is required',
+                };
+            }
+            if (!prompt) {
+                return {
+                    success: false,
+                    error: 'Prompt is required',
+                };
+            }
+            // Combine system and user prompt
+            const fullPrompt = system ? `${system}\n\n${prompt}` : prompt;
+            const generateRequest = {
+                contents: [
+                    {
+                        parts: [{ text: fullPrompt }],
+                    },
+                ],
+                generationConfig: {
+                    temperature: options.temperature,
+                    topK: options.topK,
+                    topP: options.topP,
+                    maxOutputTokens: options.maxOutputTokens,
+                    stopSequences: options.stopSequences,
+                },
+                safetySettings: options.safetySettings,
+            };
+            const response = await fetch(`${this.baseUrl}/models/${model}:generateContent?key=${this.apiKey}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(generateRequest),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                return {
+                    success: false,
+                    error: `Gemini API error: ${response.status} - ${errorText}`,
+                };
+            }
+            const result = (await response.json());
+            if (!result.candidates || result.candidates.length === 0) {
+                return {
+                    success: false,
+                    error: 'No response generated from Gemini',
+                };
+            }
+            return {
+                success: true,
+                response: result.candidates[0].content.parts[0]?.text || '',
+                model: model,
+                usage: result.usageMetadata,
+                finish_reason: result.candidates[0].finishReason,
+                safety_ratings: result.candidates[0].safetyRatings,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to generate text: ${error.message}`,
+            };
+        }
+    }
+    /**
+     * List available models
+     */
+    async _tool_list_models(request) {
+        try {
+            if (!this.apiKey) {
+                return {
+                    success: false,
+                    error: 'Gemini API key is required',
+                };
+            }
+            const response = await fetch(`${this.baseUrl}/models?key=${this.apiKey}`, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                return {
+                    success: false,
+                    error: `Gemini 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}`,
+            };
+        }
+    }
+    /**
+     * Get model information
+     */
+    async _tool_model_info(request) {
+        try {
+            const params = request.params;
+            const { model = this.defaultModel } = params;
+            if (!this.apiKey) {
+                return {
+                    success: false,
+                    error: 'Gemini API key is required',
+                };
+            }
+            const response = await fetch(`${this.baseUrl}/models/${model}?key=${this.apiKey}`, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                return {
+                    success: false,
+                    error: `Gemini 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 Gemini API status
+     */
+    async _tool_status(request) {
+        try {
+            if (!this.apiKey) {
+                return {
+                    success: false,
+                    status: 'offline',
+                    error: 'Gemini API key is required',
+                };
+            }
+            const response = await fetch(`${this.baseUrl}/models?key=${this.apiKey}`, {
+                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}`,
+            };
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+import { oRequest } from '@olane/o-core';
+import { oToolConfig, oVirtualTool, ToolResult } from '@olane/o-tool';
+export declare class GrokIntelligenceTool extends oVirtualTool {
+    private baseUrl;
+    private defaultModel;
+    constructor(config: oToolConfig);
+    _tool_completion(request: oRequest): Promise<ToolResult>;
+    _tool_generate(request: oRequest): Promise<ToolResult>;
+    _tool_list_models(request: oRequest): Promise<ToolResult>;
+    _tool_model_info(request: oRequest): Promise<ToolResult>;
+    _tool_status(request: oRequest): Promise<ToolResult>;
+}
+//# sourceMappingURL=grok-intelligence.tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"grok-intelligence.tool.d.ts","sourceRoot":"","sources":["../../src/grok-intelligence.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AA8CtE,qBAAa,oBAAqB,SAAQ,YAAY;IACpD,OAAO,CAAC,OAAO,CAAiC;IAChD,OAAO,CAAC,YAAY,CAAyB;gBAEjC,MAAM,EAAE,WAAW;IAUzB,gBAAgB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAiExD,cAAc,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAqEtD,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAiCzD,gBAAgB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAgCxD,YAAY,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;CA+B3D"}

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

@@ -0,0 +1,214 @@
+import { oAddress } from '@olane/o-core';
+import { oVirtualTool } from '@olane/o-tool';
+import { INTELLIGENCE_PARAMS } from './methods/intelligence.methods.js';
+export class GrokIntelligenceTool extends oVirtualTool {
+    constructor(config) {
+        super({
+            ...config,
+            address: new oAddress('o://grok'),
+            description: 'Intelligence tool using xAI Grok suite of models',
+            methods: INTELLIGENCE_PARAMS,
+            dependencies: [],
+        });
+        this.baseUrl = 'https://api.x.ai/v1';
+        this.defaultModel = 'grok-3-mini';
+    }
+    async _tool_completion(request) {
+        try {
+            const params = request.params;
+            const { model = this.defaultModel, messages, apiKey, ...options } = params;
+            const key = apiKey || process.env.GROK_API_KEY;
+            if (!key) {
+                return { success: false, error: 'Grok API key is required' };
+            }
+            if (!messages || !Array.isArray(messages)) {
+                return { success: false, error: '"messages" array is required' };
+            }
+            const chatRequest = {
+                model: model,
+                messages: messages,
+                stream: false,
+            };
+            if (options.max_tokens !== undefined)
+                chatRequest.max_tokens = options.max_tokens;
+            if (options.temperature !== undefined)
+                chatRequest.temperature = options.temperature;
+            if (options.top_p !== undefined)
+                chatRequest.top_p = options.top_p;
+            const response = await fetch(`${this.baseUrl}/chat/completions`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${key}`,
+                },
+                body: JSON.stringify(chatRequest),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                return {
+                    success: false,
+                    error: `Grok API error: ${response.status} - ${errorText}`,
+                };
+            }
+            const result = (await response.json());
+            return {
+                success: true,
+                message: result.choices?.[0]?.message?.content || '',
+                model: result.model,
+                usage: result.usage,
+                finish_reason: result.choices?.[0]?.finish_reason,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to complete chat: ${error.message}`,
+            };
+        }
+    }
+    async _tool_generate(request) {
+        try {
+            const params = request.params;
+            const { model = this.defaultModel, prompt, system, apiKey, ...options } = params;
+            const key = apiKey || process.env.GROK_API_KEY;
+            if (!key) {
+                return { success: false, error: 'Grok API key is required' };
+            }
+            if (!prompt) {
+                return { success: false, error: 'Prompt is required' };
+            }
+            const messages = [];
+            if (system)
+                messages.push({ role: 'system', content: system });
+            messages.push({ role: 'user', content: prompt });
+            const chatRequest = {
+                model: model,
+                messages,
+                stream: false,
+            };
+            if (options.max_tokens !== undefined)
+                chatRequest.max_tokens = options.max_tokens;
+            if (options.temperature !== undefined)
+                chatRequest.temperature = options.temperature;
+            if (options.top_p !== undefined)
+                chatRequest.top_p = options.top_p;
+            const response = await fetch(`${this.baseUrl}/chat/completions`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${key}`,
+                },
+                body: JSON.stringify(chatRequest),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                return {
+                    success: false,
+                    error: `Grok API error: ${response.status} - ${errorText}`,
+                };
+            }
+            const result = (await response.json());
+            return {
+                success: true,
+                response: result.choices?.[0]?.message?.content || '',
+                model: result.model,
+                usage: result.usage,
+                finish_reason: result.choices?.[0]?.finish_reason,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to generate text: ${error.message}`,
+            };
+        }
+    }
+    async _tool_list_models(request) {
+        try {
+            const params = request.params;
+            const { apiKey } = params;
+            const key = apiKey || process.env.GROK_API_KEY;
+            if (!key) {
+                return { success: false, error: 'Grok API key is required' };
+            }
+            const response = await fetch(`${this.baseUrl}/models`, {
+                method: 'GET',
+                headers: { Authorization: `Bearer ${key}` },
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                return {
+                    success: false,
+                    error: `Grok API error: ${response.status} - ${errorText}`,
+                };
+            }
+            const result = (await response.json());
+            return { success: true, models: result.data };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to list models: ${error.message}`,
+            };
+        }
+    }
+    async _tool_model_info(request) {
+        try {
+            const params = request.params;
+            const { model = this.defaultModel, apiKey } = params;
+            const key = apiKey || process.env.GROK_API_KEY;
+            if (!key) {
+                return { success: false, error: 'Grok API key is required' };
+            }
+            const response = await fetch(`${this.baseUrl}/models/${model}`, {
+                method: 'GET',
+                headers: { Authorization: `Bearer ${key}` },
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                return {
+                    success: false,
+                    error: `Grok 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}`,
+            };
+        }
+    }
+    async _tool_status(request) {
+        try {
+            const params = request.params;
+            const { apiKey } = params;
+            const key = apiKey || process.env.GROK_API_KEY;
+            if (!key) {
+                return {
+                    success: false,
+                    status: 'no_api_key',
+                    error: 'Grok API key is required',
+                };
+            }
+            const response = await fetch(`${this.baseUrl}/models`, {
+                method: 'GET',
+                headers: { Authorization: `Bearer ${key}` },
+            });
+            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}`,
+            };
+        }
+    }
+}

package/dist/src/index.d.ts

@@ -0,0 +1,7 @@
+export * from './ollama-intelligence.tool.js';
+export * from './openai-intelligence.tool.js';
+export * from './anthropic-intelligence.tool.js';
+export * from './gemini-intelligence.tool.js';
+export * from './grok-intelligence.tool.js';
+export * from './intelligence.tool.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AACjD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wBAAwB,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,6 @@
+export * from './ollama-intelligence.tool.js';
+export * from './openai-intelligence.tool.js';
+export * from './anthropic-intelligence.tool.js';
+export * from './gemini-intelligence.tool.js';
+export * from './grok-intelligence.tool.js';
+export * from './intelligence.tool.js';

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

@@ -0,0 +1,21 @@
+import { oToolConfig, oVirtualTool } from '@olane/o-tool';
+import { oAddress } from '@olane/o-core';
+import { oRequest } from '@olane/o-core';
+import { ToolResult } from '@olane/o-tool';
+import { LLMProviders } from './enums/llm-providers.enum.js';
+export declare class IntelligenceTool extends oVirtualTool {
+    private roundRobinIndex;
+    constructor(config: oToolConfig);
+    getModelProvider(): Promise<{
+        provider: LLMProviders;
+    }>;
+    getProviderApiKey(provider: LLMProviders): Promise<{
+        apiKey: string;
+    }>;
+    chooseIntelligence(request: oRequest): Promise<{
+        choice: oAddress;
+        apiKey: string;
+    }>;
+    _tool_prompt(request: oRequest): Promise<ToolResult>;
+}
+//# sourceMappingURL=intelligence.tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"intelligence.tool.d.ts","sourceRoot":"","sources":["../../src/intelligence.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAQ3C,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAE7D,qBAAa,gBAAiB,SAAQ,YAAY;IAChD,OAAO,CAAC,eAAe,CAAK;gBAChB,MAAM,EAAE,WAAW;IA0DzB,gBAAgB,IAAI,OAAO,CAAC;QAAE,QAAQ,EAAE,YAAY,CAAA;KAAE,CAAC;IAsDvD,iBAAiB,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAuEtE,kBAAkB,CACtB,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC;QAAE,MAAM,EAAE,QAAQ,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAW1C,YAAY,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;CAkB3D"}