@olane/o-intelligence 0.7.59 → 0.7.60

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

@@ -0,0 +1,153 @@
+/**
+ * BaseIntelligenceTool - Abstract base class for LLM provider tools
+ *
+ * This base class extracts common patterns from all provider intelligence tools:
+ * - Validation (API keys, messages, prompts)
+ * - Error handling (throw errors, no error returns)
+ * - Streaming vs non-streaming patterns
+ * - Tool method templates (_tool_completion, _tool_generate, etc.)
+ *
+ * Provider-specific implementations extend this class and implement:
+ * - getApiKeyEnvVar(): Returns the environment variable name for the API key
+ * - callCompletion(params): Makes the actual API call for completion
+ * - streamCompletion(params): Handles streaming completion
+ * - callGenerate(params): Makes the actual API call for generation
+ * - streamGenerate(params): Handles streaming generation
+ *
+ * Subclasses can use either HTTP fetch() or official SDKs with Braintrust instrumentation.
+ */
+import { oLaneTool } from '@olane/o-lane';
+import { StreamUtils } from '@olane/o-node';
+/**
+ * Abstract base class for intelligence provider tools
+ *
+ * Usage (subclass example):
+ * ```typescript
+ * export class AnthropicIntelligenceTool extends BaseIntelligenceTool {
+ *   constructor(config: oNodeToolConfig) {
+ *     super({
+ *       ...config,
+ *       address: new oAddress('o://anthropic'),
+ *       description: 'Anthropic LLM provider',
+ *       defaultModel: 'claude-sonnet-4-5-20250929',
+ *     });
+ *   }
+ *
+ *   protected getApiKeyEnvVar(): string {
+ *     return 'ANTHROPIC_API_KEY';
+ *   }
+ *
+ *   protected async callCompletion(params: any): Promise<ToolResult> {
+ *     // Anthropic-specific HTTP implementation or SDK call
+ *   }
+ *
+ *   protected async *streamCompletion(params: any): AsyncGenerator<ToolResult> {
+ *     // Anthropic-specific streaming implementation
+ *   }
+ * }
+ * ```
+ */
+export class BaseIntelligenceTool extends oLaneTool {
+    constructor(config) {
+        super({
+            ...config,
+            dependencies: config.dependencies || [],
+        });
+        this.defaultModel = config.defaultModel || '';
+        this.apiKey = config.apiKey || process.env[this.getApiKeyEnvVar()] || '';
+    }
+    /**
+     * Shared validation: API key
+     * ✅ Throws error for validation failure
+     */
+    validateApiKey(apiKey) {
+        if (!apiKey) {
+            throw new Error(`${this.getApiKeyEnvVar()} is required`);
+        }
+    }
+    /**
+     * Shared validation: Messages array
+     * ✅ Throws error for validation failure
+     */
+    validateMessages(messages) {
+        if (!messages || !Array.isArray(messages)) {
+            throw new Error('"messages" array is required');
+        }
+        if (messages.length === 0) {
+            throw new Error('"messages" array cannot be empty');
+        }
+    }
+    /**
+     * Shared validation: Prompt string
+     * ✅ Throws error for validation failure
+     */
+    validatePrompt(prompt) {
+        if (!prompt) {
+            throw new Error('Prompt is required');
+        }
+        if (typeof prompt !== 'string') {
+            throw new Error('Prompt must be a string');
+        }
+    }
+    /**
+     * Tool method: Chat completion
+     * ✅ Template method pattern - delegates to subclass
+     * ✅ Handles streaming vs non-streaming
+     * ✅ Throws errors (base class wraps them)
+     */
+    async _tool_completion(request) {
+        const params = request.params;
+        const { _isStreaming = false } = params;
+        if (_isStreaming) {
+            this.logger.debug('Streaming completion...');
+            const gen = this.streamCompletion(params);
+            return StreamUtils.processGenerator(request, gen, request.stream);
+        }
+        try {
+            return await this.callCompletion(params);
+        }
+        catch (error) {
+            throw new Error(`Failed to complete chat: ${error.message}`);
+        }
+    }
+    /**
+     * Tool method: Text generation
+     * ✅ Template method pattern - delegates to subclass
+     * ✅ Handles streaming vs non-streaming
+     * ✅ Throws errors (base class wraps them)
+     */
+    async _tool_generate(request) {
+        const params = request.params;
+        const { _isStreaming = false } = params;
+        if (_isStreaming) {
+            return StreamUtils.processGenerator(request, this.streamGenerate(params), request.stream);
+        }
+        try {
+            return await this.callGenerate(params);
+        }
+        catch (error) {
+            throw new Error(`Failed to generate text: ${error.message}`);
+        }
+    }
+    /**
+     * Tool method: List models
+     * Default implementation - subclasses can override
+     */
+    async _tool_list_models(request) {
+        throw new Error('list_models not implemented for this provider');
+    }
+    /**
+     * Tool method: Get model info
+     * Default implementation - subclasses can override
+     */
+    async _tool_model_info(request) {
+        throw new Error('model_info not implemented for this provider');
+    }
+    /**
+     * Tool method: Check API status
+     * Default implementation - subclasses can override
+     */
+    async _tool_status(request) {
+        throw new Error('status check not implemented for this provider');
+    }
+}

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

@@ -35,5 +35,17 @@ export declare class GeminiIntelligenceTool extends oLaneTool {
      * Check Gemini API status
      */
     _tool_status(request: oRequest): Promise<ToolResult>;
+    /**
+     * Generate image from text prompt using Gemini nano-banana models
+     */
+    _tool_generate_image(request: oRequest): Promise<ToolResult>;
+    /**
+     * Edit or transform an existing image using Gemini nano-banana models
+     */
+    _tool_edit_image(request: oRequest): Promise<ToolResult>;
+    /**
+     * Helper method to encode image file to base64
+     */
+    private encodeImageToBase64;
 }
 //# sourceMappingURL=gemini-intelligence.tool.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"gemini-intelligence.tool.d.ts","sourceRoot":"","sources":["../../src/gemini-intelligence.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAEL,eAAe,EACf,cAAc,EAEf,MAAM,eAAe,CAAC;AAgHvB,qBAAa,sBAAuB,SAAQ,SAAS;IACnD,OAAO,CAAC,MAAM,CAA4C;IAC1D,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,YAAY,CAAU;gBAElB,MAAM,EAAE,eAAe;IAUnC;;OAEG;IACG,gBAAgB,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,CAAC;IA6FpE;;OAEG;YACY,iBAAiB;IA8HhC;;OAEG;IACG,cAAc,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,CAAC;IA8FlE;;OAEG;YACY,eAAe;IA+H9B;;OAEG;IACG,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IA0C/D;;OAEG;IACG,gBAAgB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IA4C9D;;OAEG;IACG,YAAY,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;CAiC3D"}
+{"version":3,"file":"gemini-intelligence.tool.d.ts","sourceRoot":"","sources":["../../src/gemini-intelligence.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAEL,eAAe,EACf,cAAc,EAEf,MAAM,eAAe,CAAC;AAiJvB,qBAAa,sBAAuB,SAAQ,SAAS;IACnD,OAAO,CAAC,MAAM,CAA4C;IAC1D,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,YAAY,CAAU;gBAElB,MAAM,EAAE,eAAe;IAUnC;;OAEG;IACG,gBAAgB,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,CAAC;IA6FpE;;OAEG;YACY,iBAAiB;IA8HhC;;OAEG;IACG,cAAc,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,CAAC;IA8FlE;;OAEG;YACY,eAAe;IA+H9B;;OAEG;IACG,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IA0C/D;;OAEG;IACG,gBAAgB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IA4C9D;;OAEG;IACG,YAAY,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAkC1D;;OAEG;IACG,oBAAoB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IA+GlE;;OAEG;IACG,gBAAgB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAyJ9D;;OAEG;YACW,mBAAmB;CA4BlC"}

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

@@ -2,6 +2,7 @@ import { oAddress } from '@olane/o-core';
 import { LLM_PARAMS } from './methods/llm.methods.js';
 import { oLaneTool } from '@olane/o-lane';
 import { StreamUtils, } from '@olane/o-node';
+import { readFile } from 'fs/promises';
 export class GeminiIntelligenceTool extends oLaneTool {
     constructor(config) {
         super({
@@ -497,4 +498,262 @@ export class GeminiIntelligenceTool extends oLaneTool {
             };
         }
     }
+    /**
+     * Generate image from text prompt using Gemini nano-banana models
+     */
+    async _tool_generate_image(request) {
+        try {
+            const params = request.params;
+            const { model = 'gemini-2.5-flash-image', prompt, aspectRatio = '1:1', imageSize = '2K', negativePrompt, } = params;
+            if (!this.apiKey) {
+                return {
+                    success: false,
+                    error: 'Gemini API key is required',
+                };
+            }
+            if (!prompt) {
+                return {
+                    success: false,
+                    error: 'Prompt is required',
+                };
+            }
+            // Build the full prompt with negative prompt if provided
+            const fullPrompt = negativePrompt
+                ? `${prompt}\n\nAvoid: ${negativePrompt}`
+                : prompt;
+            const imageRequest = {
+                contents: [
+                    {
+                        parts: [{ text: fullPrompt }],
+                    },
+                ],
+                generationConfig: {
+                    responseModalities: ['TEXT', 'IMAGE'],
+                    imageConfig: {
+                        aspectRatio: aspectRatio,
+                        imageSize: imageSize,
+                    },
+                },
+            };
+            const response = await fetch(`${this.baseUrl}/models/${model}:generateContent?key=${this.apiKey}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(imageRequest),
+            });
+            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',
+                };
+            }
+            // Extract image and text from response parts
+            const parts = result.candidates[0].content.parts;
+            let imageData;
+            let description;
+            for (const part of parts) {
+                if (part.inline_data) {
+                    imageData = part.inline_data.data;
+                }
+                else if (part.text) {
+                    description = part.text;
+                }
+            }
+            if (!imageData) {
+                return {
+                    success: false,
+                    error: 'No image data in response',
+                };
+            }
+            return {
+                success: true,
+                imageData,
+                description,
+                model,
+                aspectRatio,
+                imageSize,
+                usage: result.usageMetadata,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to generate image: ${error.message}`,
+            };
+        }
+    }
+    /**
+     * Edit or transform an existing image using Gemini nano-banana models
+     */
+    async _tool_edit_image(request) {
+        try {
+            const params = request.params;
+            const { model = 'gemini-2.5-flash-image', prompt, image, aspectRatio, imageSize = '2K', } = params;
+            if (!this.apiKey) {
+                return {
+                    success: false,
+                    error: 'Gemini API key is required',
+                };
+            }
+            if (!prompt) {
+                return {
+                    success: false,
+                    error: 'Prompt is required',
+                };
+            }
+            if (!image) {
+                return {
+                    success: false,
+                    error: 'Image is required',
+                };
+            }
+            // Process image input (base64 or file path)
+            let imageBase64;
+            let mimeType = 'image/jpeg';
+            if (image.startsWith('data:')) {
+                // Extract base64 from data URL
+                const matches = image.match(/^data:([^;]+);base64,(.+)$/);
+                if (matches) {
+                    mimeType = matches[1];
+                    imageBase64 = matches[2];
+                }
+                else {
+                    return {
+                        success: false,
+                        error: 'Invalid data URL format',
+                    };
+                }
+            }
+            else if (image.startsWith('/') || image.includes(':\\')) {
+                // File path - convert to base64
+                const result = await this.encodeImageToBase64(image);
+                imageBase64 = result.data;
+                mimeType = result.mimeType;
+            }
+            else {
+                // Assume it's raw base64
+                imageBase64 = image;
+                // Try to detect mime type from base64 header
+                if (image.startsWith('/9j/')) {
+                    mimeType = 'image/jpeg';
+                }
+                else if (image.startsWith('iVBORw0KGgo')) {
+                    mimeType = 'image/png';
+                }
+            }
+            const imageRequest = {
+                contents: [
+                    {
+                        parts: [
+                            { text: prompt },
+                            {
+                                inline_data: {
+                                    mime_type: mimeType,
+                                    data: imageBase64,
+                                },
+                            },
+                        ],
+                    },
+                ],
+                generationConfig: {
+                    responseModalities: ['TEXT', 'IMAGE'],
+                    imageConfig: {
+                        aspectRatio: aspectRatio,
+                        imageSize: imageSize,
+                    },
+                },
+            };
+            const response = await fetch(`${this.baseUrl}/models/${model}:generateContent?key=${this.apiKey}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(imageRequest),
+            });
+            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',
+                };
+            }
+            // Extract image and text from response parts
+            const parts = result.candidates[0].content.parts;
+            let outputImageData;
+            let description;
+            for (const part of parts) {
+                if (part.inline_data) {
+                    outputImageData = part.inline_data.data;
+                }
+                else if (part.text) {
+                    description = part.text;
+                }
+            }
+            if (!outputImageData) {
+                return {
+                    success: false,
+                    error: 'No image data in response',
+                };
+            }
+            return {
+                success: true,
+                imageData: outputImageData,
+                description,
+                model,
+                aspectRatio,
+                imageSize,
+                usage: result.usageMetadata,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to edit image: ${error.message}`,
+            };
+        }
+    }
+    /**
+     * Helper method to encode image file to base64
+     */
+    async encodeImageToBase64(filePath) {
+        try {
+            const buffer = await readFile(filePath);
+            const base64 = buffer.toString('base64');
+            // Detect MIME type from file extension
+            let mimeType = 'image/jpeg';
+            const lowerPath = filePath.toLowerCase();
+            if (lowerPath.endsWith('.png')) {
+                mimeType = 'image/png';
+            }
+            else if (lowerPath.endsWith('.jpg') || lowerPath.endsWith('.jpeg')) {
+                mimeType = 'image/jpeg';
+            }
+            else if (lowerPath.endsWith('.gif')) {
+                mimeType = 'image/gif';
+            }
+            else if (lowerPath.endsWith('.webp')) {
+                mimeType = 'image/webp';
+            }
+            return { data: base64, mimeType };
+        }
+        catch (error) {
+            throw new Error(`Failed to read image file: ${error.message}`);
+        }
+    }
 }

package/dist/src/index.d.ts

@@ -5,4 +5,5 @@ export * from './gemini-intelligence.tool.js';
 export * from './grok-intelligence.tool.js';
 export * from './o-intelligence.tool.js';
 export * from './methods/intelligence.methods.js';
+export * from './perplexity-intelligence.tool.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +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,0BAA0B,CAAC;AACzC,cAAc,mCAAmC,CAAC"}
+{"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,0BAA0B,CAAC;AACzC,cAAc,mCAAmC,CAAC;AAClD,cAAc,mCAAmC,CAAC"}

package/dist/src/index.js

@@ -5,3 +5,4 @@ export * from './gemini-intelligence.tool.js';
 export * from './grok-intelligence.tool.js';
 export * from './o-intelligence.tool.js';
 export * from './methods/intelligence.methods.js';
+export * from './perplexity-intelligence.tool.js';