@juspay/neurolink 9.1.1 → 9.2.0

package/dist/lib/image-gen/imageGenTools.js

@@ -0,0 +1,305 @@
+/**
+ * Image Generation Tools
+ *
+ * Tool definitions for AI model use - enables AI models to generate
+ * images as part of their response workflow.
+ *
+ * @packageDocumentation
+ * @module @juspay/neurolink/image-gen
+ * @category ImageGeneration
+ *
+ * @example
+ * ```typescript
+ * import { getImageGenTools } from '@juspay/neurolink';
+ *
+ * // Get tools for AI model registration
+ * const tools = getImageGenTools();
+ *
+ * // Use with NeuroLink
+ * const neurolink = new NeuroLink();
+ * neurolink.registerCustomTools(tools);
+ * ```
+ */
+import { ImageGenService } from "./ImageGenService.js";
+/**
+ * Create an image generation tool for use with AI models
+ *
+ * This tool allows AI models to generate images based on text prompts.
+ * It integrates with the ImageGenService for actual generation.
+ *
+ * @param service - ImageGenService instance to use
+ * @returns Tool definition compatible with MCP/AI SDK
+ *
+ * @example
+ * ```typescript
+ * const service = new ImageGenService();
+ * const tool = createImageGenTool(service);
+ *
+ * // Tool can now be registered with NeuroLink
+ * neurolink.registerTool(tool.name, {
+ *   description: tool.description,
+ *   parameters: tool.inputSchema,
+ *   execute: tool.execute
+ * });
+ * ```
+ */
+export function createImageGenTool(service) {
+    return {
+        name: "generate_image",
+        description: `Generate an image from a text prompt using AI. Use this tool to create images, illustrations, diagrams, or visual content based on detailed descriptions.
+
+Tips for better prompts:
+- Be specific and detailed about what you want
+- Include style preferences (photorealistic, cartoon, watercolor, etc.)
+- Mention colors, lighting, and composition if important
+- Describe the mood or atmosphere desired
+
+The tool returns the generated image as a data URI that can be displayed or saved.`,
+        inputSchema: {
+            type: "object",
+            properties: {
+                prompt: {
+                    type: "string",
+                    description: "Detailed description of the image to generate. Be specific about content, style, colors, and composition for best results.",
+                },
+                negativePrompt: {
+                    type: "string",
+                    description: "What to avoid in the generated image (optional). E.g., 'blurry, low quality, text, watermarks'",
+                },
+                aspectRatio: {
+                    type: "string",
+                    description: "Aspect ratio for the image (optional). Common values: '1:1' (square), '16:9' (widescreen), '9:16' (portrait), '4:3', '3:2'",
+                    enum: ["1:1", "16:9", "9:16", "4:3", "3:4", "3:2", "2:3"],
+                },
+                style: {
+                    type: "string",
+                    description: "Style preset for the image (optional). E.g., 'realistic', 'photorealistic', 'artistic', 'cartoon', 'anime', 'watercolor', 'oil-painting', 'sketch', 'digital-art', '3d-render'",
+                    enum: [
+                        "realistic",
+                        "photorealistic",
+                        "artistic",
+                        "cartoon",
+                        "anime",
+                        "watercolor",
+                        "oil-painting",
+                        "sketch",
+                        "digital-art",
+                        "3d-render",
+                    ],
+                },
+            },
+            required: ["prompt"],
+        },
+        execute: async (params, context) => {
+            // Check if service is enabled
+            if (!service.isEnabled()) {
+                return {
+                    success: false,
+                    message: "Image generation is disabled on this server",
+                    error: "IMAGE_GEN_DISABLED",
+                };
+            }
+            try {
+                // Build generation options
+                const result = await service.generate({
+                    prompt: params.prompt,
+                    negativePrompt: params.negativePrompt,
+                    aspectRatio: params.aspectRatio,
+                    style: params.style,
+                    images: context?.referenceImages,
+                    pdfFiles: context?.referencePdfs,
+                });
+                if (result.success && result.base64) {
+                    const mimeType = result.mimeType ?? "image/png";
+                    return {
+                        success: true,
+                        image: `data:${mimeType};base64,${result.base64}`,
+                        message: `Image generated successfully using ${result.model ?? "default model"}`,
+                    };
+                }
+                return {
+                    success: false,
+                    message: result.error ?? "Failed to generate image",
+                    error: result.error ?? "GENERATION_FAILED",
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                return {
+                    success: false,
+                    message: `Image generation failed: ${errorMessage}`,
+                    error: errorMessage,
+                };
+            }
+        },
+    };
+}
+/**
+ * Create an image editing/variation tool for use with AI models
+ *
+ * This tool allows AI models to create variations of existing images
+ * or edit images based on reference images and prompts.
+ *
+ * @param service - ImageGenService instance to use
+ * @returns Tool definition compatible with MCP/AI SDK
+ */
+export function createImageVariationTool(service) {
+    return {
+        name: "create_image_variation",
+        description: `Create a variation or modification of an existing image. Use this when you need to:
+- Create variations of a reference image
+- Modify an existing image based on a description
+- Generate images in a similar style to a reference
+
+Note: Requires reference images to be provided in the context.`,
+        inputSchema: {
+            type: "object",
+            properties: {
+                prompt: {
+                    type: "string",
+                    description: "Description of the desired variation or modification. Describe what changes you want from the reference.",
+                },
+                style: {
+                    type: "string",
+                    description: "Style to apply to the variation (optional)",
+                    enum: [
+                        "realistic",
+                        "photorealistic",
+                        "artistic",
+                        "cartoon",
+                        "anime",
+                        "watercolor",
+                        "oil-painting",
+                        "sketch",
+                        "digital-art",
+                        "3d-render",
+                    ],
+                },
+                aspectRatio: {
+                    type: "string",
+                    description: "Aspect ratio for the output (optional)",
+                    enum: ["1:1", "16:9", "9:16", "4:3", "3:4", "3:2", "2:3"],
+                },
+            },
+            required: ["prompt"],
+        },
+        execute: async (params, context) => {
+            // Check if service is enabled
+            if (!service.isEnabled()) {
+                return {
+                    success: false,
+                    message: "Image generation is disabled on this server",
+                    error: "IMAGE_GEN_DISABLED",
+                };
+            }
+            // Require reference images for variations
+            if (!context?.referenceImages?.length) {
+                return {
+                    success: false,
+                    message: "No reference images provided. This tool requires reference images to create variations.",
+                    error: "NO_REFERENCE_IMAGES",
+                };
+            }
+            try {
+                const result = await service.generate({
+                    prompt: `Create a variation based on the reference image(s): ${params.prompt}`,
+                    style: params.style,
+                    aspectRatio: params.aspectRatio,
+                    images: context.referenceImages,
+                    pdfFiles: context.referencePdfs,
+                });
+                if (result.success && result.base64) {
+                    const mimeType = result.mimeType ?? "image/png";
+                    return {
+                        success: true,
+                        image: `data:${mimeType};base64,${result.base64}`,
+                        message: "Image variation created successfully",
+                    };
+                }
+                return {
+                    success: false,
+                    message: result.error ?? "Failed to create image variation",
+                    error: result.error ?? "VARIATION_FAILED",
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                return {
+                    success: false,
+                    message: `Image variation failed: ${errorMessage}`,
+                    error: errorMessage,
+                };
+            }
+        },
+    };
+}
+/**
+ * Get all image generation tools as an array
+ *
+ * Creates a shared ImageGenService instance and returns all
+ * image generation tools configured to use it.
+ *
+ * @param config - Optional configuration for the ImageGenService
+ * @returns Array of tool definitions
+ *
+ * @example
+ * ```typescript
+ * import { getImageGenTools, NeuroLink } from '@juspay/neurolink';
+ *
+ * const tools = getImageGenTools({
+ *   defaultProvider: 'openai',
+ *   defaultModel: 'dall-e-3'
+ * });
+ *
+ * const neurolink = new NeuroLink();
+ * for (const tool of tools) {
+ *   neurolink.registerTool(tool.name, {
+ *     description: tool.description,
+ *     parameters: tool.inputSchema,
+ *     execute: tool.execute
+ *   });
+ * }
+ * ```
+ */
+export function getImageGenTools(configOrService) {
+    const service = configOrService instanceof ImageGenService
+        ? configOrService
+        : new ImageGenService(configOrService);
+    return [createImageGenTool(service), createImageVariationTool(service)];
+}
+/**
+ * Get only the basic image generation tool
+ *
+ * @param config - Optional configuration for the ImageGenService
+ * @returns Single tool definition for basic image generation
+ */
+export function getBasicImageGenTool(configOrService) {
+    const service = configOrService instanceof ImageGenService
+        ? configOrService
+        : new ImageGenService(configOrService);
+    return createImageGenTool(service);
+}
+/**
+ * Create a custom image generation tool with specific service configuration
+ *
+ * @param serviceConfig - Configuration for the ImageGenService
+ * @param toolConfig - Optional customizations for the tool definition
+ * @returns Customized tool definition
+ *
+ * @example
+ * ```typescript
+ * const customTool = createCustomImageGenTool(
+ *   { defaultProvider: 'vertex', defaultModel: 'imagen-3.0-generate-001' },
+ *   { name: 'vertex_generate_image', description: 'Generate images using Vertex AI Imagen' }
+ * );
+ * ```
+ */
+export function createCustomImageGenTool(serviceConfig, toolConfig) {
+    const service = new ImageGenService(serviceConfig);
+    const baseTool = createImageGenTool(service);
+    return {
+        ...baseTool,
+        ...toolConfig,
+    };
+}
+//# sourceMappingURL=imageGenTools.js.map

package/dist/lib/image-gen/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Image Generation Module
+ *
+ * AI-powered image generation with support for multiple providers,
+ * reference images, and configurable styles.
+ *
+ * @packageDocumentation
+ * @module @juspay/neurolink/image-gen
+ * @category ImageGeneration
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { ImageGenService } from '@juspay/neurolink';
+ *
+ * const service = new ImageGenService();
+ * const result = await service.generate({
+ *   prompt: 'A beautiful sunset over mountains',
+ *   style: 'photorealistic'
+ * });
+ *
+ * if (result.success) {
+ *   console.log('Generated image:', result.base64?.substring(0, 50) + '...');
+ * }
+ * ```
+ *
+ * @example With AI tools
+ * ```typescript
+ * import { getImageGenTools, NeuroLink } from '@juspay/neurolink';
+ *
+ * const tools = getImageGenTools();
+ * const neurolink = new NeuroLink();
+ *
+ * // Register tools for AI model use
+ * for (const tool of tools) {
+ *   neurolink.registerTool(tool.name, {
+ *     description: tool.description,
+ *     parameters: tool.inputSchema,
+ *     execute: tool.execute
+ *   });
+ * }
+ * ```
+ */
+export { ImageGenService } from "./ImageGenService.js";
+export type { ImageGenToolDefinition } from "./imageGenTools.js";
+export { createCustomImageGenTool, createImageGenTool, createImageVariationTool, getBasicImageGenTool, getImageGenTools, } from "./imageGenTools.js";
+export * from "./types.js";

package/dist/lib/image-gen/index.js

@@ -0,0 +1,49 @@
+/**
+ * Image Generation Module
+ *
+ * AI-powered image generation with support for multiple providers,
+ * reference images, and configurable styles.
+ *
+ * @packageDocumentation
+ * @module @juspay/neurolink/image-gen
+ * @category ImageGeneration
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { ImageGenService } from '@juspay/neurolink';
+ *
+ * const service = new ImageGenService();
+ * const result = await service.generate({
+ *   prompt: 'A beautiful sunset over mountains',
+ *   style: 'photorealistic'
+ * });
+ *
+ * if (result.success) {
+ *   console.log('Generated image:', result.base64?.substring(0, 50) + '...');
+ * }
+ * ```
+ *
+ * @example With AI tools
+ * ```typescript
+ * import { getImageGenTools, NeuroLink } from '@juspay/neurolink';
+ *
+ * const tools = getImageGenTools();
+ * const neurolink = new NeuroLink();
+ *
+ * // Register tools for AI model use
+ * for (const tool of tools) {
+ *   neurolink.registerTool(tool.name, {
+ *     description: tool.description,
+ *     parameters: tool.inputSchema,
+ *     execute: tool.execute
+ *   });
+ * }
+ * ```
+ */
+// Export service
+export { ImageGenService } from "./ImageGenService.js";
+// Export tools
+export { createCustomImageGenTool, createImageGenTool, createImageVariationTool, getBasicImageGenTool, getImageGenTools, } from "./imageGenTools.js";
+// Export types
+export * from "./types.js";
+//# sourceMappingURL=index.js.map

package/dist/lib/image-gen/types.d.ts

@@ -0,0 +1,237 @@
+/**
+ * Image Generation Service Types
+ *
+ * Type definitions for AI-powered image generation with support for
+ * reference images, PDFs, and configurable providers/models.
+ *
+ * @packageDocumentation
+ * @module @juspay/neurolink/image-gen
+ * @category ImageGeneration
+ */
+/**
+ * Supported image generation providers
+ */
+export type ImageGenProvider = "vertex" | "openai" | "anthropic" | "bedrock";
+/**
+ * Supported aspect ratios
+ */
+export type AspectRatio = "1:1" | "16:9" | "9:16" | "4:3" | "3:4" | "3:2" | "2:3";
+/**
+ * Supported style presets
+ */
+export type StylePreset = "realistic" | "photorealistic" | "artistic" | "cartoon" | "anime" | "watercolor" | "oil-painting" | "sketch" | "digital-art" | "3d-render";
+/**
+ * Options for image generation requests
+ */
+export interface ImageGenOptions {
+    /**
+     * Text prompt describing the image to generate
+     * Should be detailed and specific for best results
+     */
+    prompt: string;
+    /**
+     * Reference images for style/content guidance (optional)
+     * Can be Buffer (raw data) or string (base64 encoded)
+     * Max 5 images recommended
+     */
+    images?: (Buffer | string)[];
+    /**
+     * Reference PDF files for context (optional)
+     * Used for generating images based on document content
+     * Max 1 PDF recommended
+     */
+    pdfFiles?: Buffer[];
+    /**
+     * Override default model
+     * e.g., "imagen-3.0-generate-001", "dall-e-3"
+     */
+    model?: string;
+    /**
+     * Override default provider
+     * e.g., "vertex", "openai"
+     */
+    provider?: ImageGenProvider | string;
+    /**
+     * Region for provider (e.g., for Vertex AI)
+     */
+    region?: string;
+    /**
+     * What to avoid in the generated image (optional)
+     * e.g., "blurry, low quality, text overlays"
+     */
+    negativePrompt?: string;
+    /**
+     * Aspect ratio for the generated image
+     * e.g., "16:9", "1:1", "4:3", "9:16"
+     */
+    aspectRatio?: AspectRatio | string;
+    /**
+     * Style preset for the image
+     * e.g., "realistic", "artistic", "cartoon", "watercolor", "photorealistic"
+     */
+    style?: StylePreset | string;
+    /**
+     * Number of images to generate (default: 1)
+     */
+    numberOfImages?: number;
+    /**
+     * Sampling temperature for generation (0-1)
+     * Higher values = more creative/random
+     */
+    temperature?: number;
+}
+/**
+ * Result of an image generation request
+ */
+export interface ImageGenResult {
+    /**
+     * Whether generation was successful
+     */
+    success: boolean;
+    /**
+     * Generated image as Buffer (if successful)
+     */
+    imageBuffer?: Buffer;
+    /**
+     * Generated image as base64 string (if successful)
+     */
+    base64?: string;
+    /**
+     * MIME type of the generated image
+     * e.g., "image/png", "image/jpeg"
+     */
+    mimeType?: string;
+    /**
+     * Model used for generation
+     */
+    model?: string;
+    /**
+     * Provider used for generation
+     */
+    provider?: string;
+    /**
+     * Error message if generation failed
+     */
+    error?: string;
+    /**
+     * Time taken for generation in milliseconds
+     */
+    generationTimeMs?: number;
+    /**
+     * Additional metadata from the provider
+     */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Configuration for the ImageGenService
+ */
+export interface ImageGenConfig {
+    /**
+     * Whether image generation is enabled
+     */
+    enabled: boolean;
+    /**
+     * Default model to use for generation
+     */
+    defaultModel: string;
+    /**
+     * Default provider for image generation
+     */
+    defaultProvider: ImageGenProvider | string;
+    /**
+     * Default region for the provider (if applicable)
+     */
+    defaultRegion?: string;
+    /**
+     * Timeout for generation requests in milliseconds
+     */
+    timeout: number;
+    /**
+     * Default temperature for generation
+     */
+    defaultTemperature?: number;
+    /**
+     * Maximum number of images per request
+     */
+    maxImages?: number;
+    /**
+     * Maximum number of reference images allowed
+     */
+    maxReferenceImages?: number;
+    /**
+     * Maximum number of reference PDFs allowed
+     */
+    maxReferencePdfs?: number;
+}
+/**
+ * Default configuration for image generation
+ */
+export declare const DEFAULT_IMAGE_GEN_CONFIG: ImageGenConfig;
+/**
+ * Tool parameters for AI model use
+ */
+export interface ImageGenToolParams {
+    /**
+     * Detailed description of the image to generate
+     */
+    prompt: string;
+    /**
+     * What to avoid in the generated image (optional)
+     */
+    negativePrompt?: string;
+    /**
+     * Aspect ratio like "16:9", "1:1", "4:3" (optional)
+     */
+    aspectRatio?: AspectRatio | string;
+    /**
+     * Style like "realistic", "artistic", "cartoon" (optional)
+     */
+    style?: StylePreset | string;
+}
+/**
+ * Response from the image generation tool
+ */
+export interface ImageGenToolResponse {
+    /**
+     * Whether the tool execution was successful
+     */
+    success: boolean;
+    /**
+     * Data URI of the generated image (if successful)
+     * Format: data:image/png;base64,...
+     */
+    image?: string;
+    /**
+     * Human-readable message about the result
+     */
+    message?: string;
+    /**
+     * Error message if execution failed
+     */
+    error?: string;
+}
+/**
+ * Context for tool execution (optional)
+ */
+export interface ImageGenToolContext {
+    /**
+     * Reference images to use for generation
+     */
+    referenceImages?: (Buffer | string)[];
+    /**
+     * Reference PDFs to use for generation
+     */
+    referencePdfs?: Buffer[];
+    /**
+     * User ID for tracking/logging
+     */
+    userId?: string;
+    /**
+     * Session ID for tracking/logging
+     */
+    sessionId?: string;
+    /**
+     * Additional metadata
+     */
+    metadata?: Record<string, unknown>;
+}

package/dist/lib/image-gen/types.js

@@ -0,0 +1,25 @@
+/**
+ * Image Generation Service Types
+ *
+ * Type definitions for AI-powered image generation with support for
+ * reference images, PDFs, and configurable providers/models.
+ *
+ * @packageDocumentation
+ * @module @juspay/neurolink/image-gen
+ * @category ImageGeneration
+ */
+/**
+ * Default configuration for image generation
+ */
+export const DEFAULT_IMAGE_GEN_CONFIG = {
+    enabled: true,
+    defaultModel: "imagen-3.0-generate-001",
+    defaultProvider: "vertex",
+    defaultRegion: "global",
+    timeout: 120000,
+    defaultTemperature: 0.75,
+    maxImages: 4,
+    maxReferenceImages: 5,
+    maxReferencePdfs: 1,
+};
+//# sourceMappingURL=types.js.map