@smythos/sre 1.5.32 → 1.5.34

package/dist/types/Components/ImageGenerator.class.d.ts

@@ -1,11 +1,11 @@
-import { IAgent as Agent } from '@sre/types/Agent.types';
+import { IAgent } from '@sre/types/Agent.types';
 import Joi from 'joi';
 import { Component } from './Component.class';
 export declare class ImageGenerator extends Component {
     protected configSchema: Joi.ObjectSchema<any>;
     constructor();
     init(): void;
-    process(input: any, config: any, agent: Agent): Promise<{
+    process(input: any, config: any, agent: IAgent): Promise<{
         _error: string;
         _debug: string;
         Output?: undefined;

package/dist/types/constants.d.ts

@@ -48,6 +48,7 @@ export declare const SUPPORTED_MIME_TYPES_MAP: {
     };
     GoogleAI: {
         image: string[];
+        imageGen: string[];
         video: string[];
         audio: string[];
         document: string[];

package/dist/types/index.d.ts

@@ -165,7 +165,7 @@ export * from './subsystems/LLMManager/LLM.service/connectors/Groq.class';
 export * from './subsystems/LLMManager/LLM.service/connectors/OpenAI.class';
 export * from './subsystems/LLMManager/LLM.service/connectors/Perplexity.class';
 export * from './subsystems/LLMManager/LLM.service/connectors/VertexAI.class';
-export * from './subsystems/LLMManager/LLM.service/connectors/xAI';
+export * from './subsystems/LLMManager/LLM.service/connectors/xAI.class';
 export * from './subsystems/LLMManager/ModelsProvider.service/connectors/JSONModelsProvider.class';
 export * from './subsystems/MemoryManager/Cache.service/connectors/LocalStorageCache.class';
 export * from './subsystems/MemoryManager/Cache.service/connectors/RAMCache.class';

package/dist/types/subsystems/LLMManager/LLM.service/connectors/GoogleAI.class.d.ts

@@ -12,6 +12,8 @@ export declare class GoogleAIConnector extends LLMConnector {
     protected request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
     protected streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
     protected webSearchRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<any>;
+    protected imageGenRequest({ body, context }: ILLMRequestFuncParams): Promise<any>;
+    protected imageEditRequest({ body, context }: ILLMRequestFuncParams): Promise<any>;
     protected reqBodyAdapter(params: TLLMParams): Promise<TGoogleAIRequestBody>;
     protected reportUsage(usage: UsageMetadataWithThoughtsToken, metadata: {
         modelEntryName: string;
@@ -49,6 +51,7 @@ export declare class GoogleAIConnector extends LLMConnector {
     private prepareMessagesWithFiles;
     private prepareMessagesWithTools;
     private prepareMessagesWithTextQuery;
+    private prepareBodyForImageGenRequest;
     private sanitizeFunctionName;
     private uploadFile;
     private getValidFiles;

package/dist/types/subsystems/LLMManager/LLM.service/connectors/xAI.class.d.ts

@@ -0,0 +1,121 @@
+import EventEmitter from 'events';
+import { TLLMParams, ToolData, TLLMMessageBlock, TLLMToolResultMessageBlock, TLLMMessageRole, APIKeySource, ILLMRequestFuncParams, TLLMChatResponse } from '@sre/types/LLM.types';
+import { LLMConnector } from '../LLMConnector';
+type ChatCompletionParams = {
+    model: string;
+    messages: any[];
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    frequency_penalty?: number;
+    presence_penalty?: number;
+    stop?: string | string[];
+    response_format?: {
+        type: string;
+    };
+    stream?: boolean;
+    stream_options?: {
+        include_usage: boolean;
+    };
+    tools?: any[];
+    tool_choice?: any;
+    search_parameters?: {
+        mode?: 'auto' | 'on' | 'off';
+        return_citations?: boolean;
+        max_search_results?: number;
+        sources?: Array<{
+            type: 'web' | 'x' | 'news' | 'rss';
+            country?: string;
+            excluded_websites?: string[];
+            allowed_websites?: string[];
+            safe_search?: boolean;
+            included_x_handles?: string[];
+            excluded_x_handles?: string[];
+            post_favorite_count?: number;
+            post_view_count?: number;
+            links?: string[];
+        }>;
+        from_date?: string;
+        to_date?: string;
+    };
+};
+type TUsage = {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+    prompt_tokens_details?: {
+        text_tokens?: number;
+        audio_tokens?: number;
+        image_tokens?: number;
+        cached_tokens?: number;
+    };
+    completion_tokens_details?: {
+        reasoning_tokens?: number;
+        audio_tokens?: number;
+        accepted_prediction_tokens?: number;
+        rejected_prediction_tokens?: number;
+    };
+    reasoning_tokens?: number;
+    num_sources_used?: number;
+};
+export declare class xAIConnector extends LLMConnector {
+    name: string;
+    private getClient;
+    protected request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
+    protected streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
+    protected webSearchRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
+    protected reqBodyAdapter(params: TLLMParams): Promise<ChatCompletionParams>;
+    protected reportUsage(usage: TUsage, metadata: {
+        modelEntryName: string;
+        keySource: APIKeySource;
+        agentId: string;
+        teamId: string;
+    }): {
+        sourceId: string;
+        input_tokens: number;
+        output_tokens: number;
+        input_tokens_cache_write: number;
+        input_tokens_cache_read: number;
+        reasoning_tokens: number;
+        keySource: APIKeySource;
+        agentId: string;
+        teamId: string;
+    };
+    formatToolsConfig({ type, toolDefinitions, toolChoice }: {
+        type?: string;
+        toolDefinitions: any;
+        toolChoice?: string;
+    }): {
+        tools: any[];
+        tool_choice: string;
+    } | {
+        tools?: undefined;
+        tool_choice?: undefined;
+    };
+    transformToolMessageBlocks({ messageBlock, toolsData, }: {
+        messageBlock: TLLMMessageBlock;
+        toolsData: ToolData[];
+    }): TLLMToolResultMessageBlock[];
+    getConsistentMessages(messages: any): {
+        role: TLLMMessageRole;
+        content?: string | {
+            text: string;
+        }[] | Array<import("@anthropic-ai/sdk/resources").TextBlockParam | import("@anthropic-ai/sdk/resources").ImageBlockParam | import("@anthropic-ai/sdk/resources").ToolUseBlockParam | import("@anthropic-ai/sdk/resources").ToolResultBlockParam>;
+        parts?: {
+            text?: string;
+            functionCall?: {
+                name: string;
+                args: string;
+            };
+            functionResponse?: {
+                name: string;
+                response: {
+                    name: string;
+                    content: string;
+                };
+            };
+        }[];
+        tool_calls?: ToolData[];
+    }[];
+}
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smythos/sre",
-  "version": "1.5.32",
+  "version": "1.5.34",
   "description": "Smyth Runtime Environment",
   "author": "Alaa-eddine KADDOURI",
   "license": "MIT",
@@ -51,6 +51,7 @@
     "@faker-js/faker": "^9.8.0",
     "@google-cloud/vertexai": "^1.7.0",
     "@google/generative-ai": "^0.14.1",
+    "@google/genai": "^1.10.0",
     "@huggingface/inference": "^2.8.0",
     "@modelcontextprotocol/sdk": "^1.10.1",
     "@pinecone-database/pinecone": "^3.0.0",

package/src/Components/DataSourceLookup.class.ts

@@ -17,7 +17,8 @@ class LLMInference {
 
 export class DataSourceLookup extends Component {
     protected configSchema = Joi.object({
-        topK: Joi.string()
+        topK: Joi.alternatives([Joi.string(), Joi.number()]) // Value is now a number; keep string fallback for backward compatibility.
+
             .custom(validateInteger({ min: 0 }), 'custom range validation')
             .label('Result Count'),
         model: Joi.string().valid('gpt-4o-mini', 'gpt-4', 'gpt-3.5-turbo', 'gpt-4', 'gpt-3.5-turbo-16k').optional(),

package/src/Components/ImageGenerator.class.ts

@@ -5,7 +5,7 @@ import { OpenAI } from 'openai';
 
 import { TemplateString } from '@sre/helpers/TemplateString.helper';
 import { LLMInference } from '@sre/LLMManager/LLM.inference';
-import { IAgent as Agent } from '@sre/types/Agent.types';
+import { IAgent } from '@sre/types/Agent.types';
 import { APIKeySource, GenerateImageConfig } from '@sre/types/LLM.types';
 import Joi from 'joi';
 import { Component } from './Component.class';
@@ -13,7 +13,6 @@ import { Component } from './Component.class';
 import { SystemEvents } from '@sre/Core/SystemEvents';
 import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
 
-import appConfig from '@sre/config';
 import { BUILT_IN_MODEL_PREFIX, SUPPORTED_MIME_TYPES_MAP } from '@sre/constants';
 import { BinaryInput } from '@sre/helpers/BinaryInput.helper';
 import { normalizeImageInput } from '@sre/utils/data.utils';
@@ -45,6 +44,12 @@ const IMAGE_GEN_COST_MAP = {
     },
 };
 
+// Imagen 4 cost map - fixed cost per image
+const IMAGEN_4_COST_MAP = {
+    'imagen-4': 0.04, // Standard Imagen 4
+    'imagen-4-ultra': 0.06, // Imagen 4 Ultra
+};
+
 export class ImageGenerator extends Component {
     protected configSchema = Joi.object({
         model: Joi.string().max(100).required(),
@@ -73,12 +78,17 @@ export class ImageGenerator extends Component {
         // #region GPT model
         size: Joi.string().optional().allow('').max(100).label('Size'),
         // #endregion
+
+        // #region Google AI model
+        aspectRatio: Joi.string().valid('1:1', '3:4', '4:3', '9:16', '16:9').optional().allow('').label('Aspect Ratio'),
+        personGeneration: Joi.string().valid('dont_allow', 'allow_adult', 'allow_all').optional().allow('').label('Person Generation'),
+        // #endregion
     });
     constructor() {
         super();
     }
     init() {}
-    async process(input, config, agent: Agent) {
+    async process(input, config, agent: IAgent) {
         await super.process(input, config, agent);
 
         const logger = this.createComponentLogger(agent, config);
@@ -134,6 +144,7 @@ enum MODEL_FAMILY {
     GPT = 'gpt',
     RUNWARE = 'runware',
     DALL_E = 'dall-e',
+    IMAGEN = 'imagen',
 }
 
 const imageGenerator = {
@@ -319,6 +330,75 @@ const imageGenerator = {
             await runware.disconnect();
         }
     },
+    [MODEL_FAMILY.IMAGEN]: async ({ model, prompt, config, logger, agent, input }) => {
+        try {
+            const llmInference: LLMInference = await LLMInference.getInstance(model, AccessCandidate.agent(agent.id));
+
+            // if the llm is undefined, then it means we removed the model from our system
+            if (!llmInference.connector) {
+                return {
+                    _error: `The model '${model}' is not available. Please try a different one.`,
+                    _debug: logger.output,
+                };
+            }
+
+            const files: any[] = parseFiles(input, config);
+
+            // Imagen models only support image generation, not image editing
+            if (files.length > 0) {
+                throw new Error('Google AI Image Generation Error: Image editing is not supported. Imagen models only support image generation.');
+            }
+
+            let args: GenerateImageConfig & {
+                aspectRatio?: string;
+                numberOfImages?: number;
+                personGeneration?: string;
+            } = {
+                model,
+                aspectRatio: config?.data?.aspectRatio || config?.data?.size || '1:1',
+                numberOfImages: config?.data?.numberOfImages || 1,
+                personGeneration: config?.data?.personGeneration || 'allow_adult',
+            };
+
+            const response = await llmInference.imageGenRequest({ query: prompt, params: { ...args, agentId: agent.id } });
+
+            // Calculate fixed cost for Imagen 4
+            const modelName = model.replace(BUILT_IN_MODEL_PREFIX, '');
+            const cost = IMAGEN_4_COST_MAP[modelName];
+
+            if (cost && cost > 0) {
+                // Multiply by number of images generated
+                const numberOfImages = args.numberOfImages || 1;
+                const totalCost = cost * numberOfImages;
+
+                // Report fixed cost usage
+                imageGenerator.reportUsage(
+                    { cost: totalCost },
+                    {
+                        modelEntryName: model,
+                        keySource: model.startsWith(BUILT_IN_MODEL_PREFIX) ? APIKeySource.Smyth : APIKeySource.User,
+                        agentId: agent.id,
+                        teamId: agent.teamId,
+                    }
+                );
+            }
+
+            let output = response?.data?.[0]?.b64_json;
+
+            if (output) {
+                const binaryInput = BinaryInput.from(output);
+                const agentId = typeof agent == 'object' && agent.id ? agent.id : agent;
+                const smythFile = await binaryInput.getJsonData(AccessCandidate.agent(agentId));
+                return { output: smythFile };
+            } else {
+                // Handle URL response format
+                output = response?.data?.[0]?.url;
+                return { output };
+            }
+        } catch (error: any) {
+            throw new Error(`Google AI Image Generation Error: ${error?.message || JSON.stringify(error)}`);
+        }
+    },
     reportTokenUsage(usage: TokenUsage, metadata: { modelEntryName: string; keySource: APIKeySource; agentId: string; teamId: string }) {
         // SmythOS (built-in) models have a prefix, so we need to remove it to get the model name
         const modelName = metadata.modelEntryName.replace(BUILT_IN_MODEL_PREFIX, '');
@@ -361,6 +441,7 @@ const imageGenerator = {
 enum PROVIDERS {
     OPENAI = 'OpenAI',
     RUNWARE = 'Runware',
+    GOOGLEAI = 'GoogleAI',
 }
 
 /**
@@ -368,10 +449,11 @@ enum PROVIDERS {
  * @param model The model identifier
  * @returns The model family or null if not recognized
  */
-async function getModelFamily(model: string, agent: Agent): Promise<string | null> {
+async function getModelFamily(model: string, agent: IAgent): Promise<string | null> {
     if (await isGPTModel(model)) return MODEL_FAMILY.GPT;
     if (await isRunwareModel(model, agent)) return MODEL_FAMILY.RUNWARE;
     if (await isDallEModel(model)) return MODEL_FAMILY.DALL_E;
+    if (await isGoogleAIModel(model, agent)) return MODEL_FAMILY.IMAGEN;
 
     return null;
 }
@@ -380,15 +462,24 @@ function isGPTModel(model: string) {
     return model?.replace(BUILT_IN_MODEL_PREFIX, '')?.startsWith(MODEL_FAMILY.GPT);
 }
 
-async function isRunwareModel(model: string, agent: Agent): Promise<boolean> {
+async function isRunwareModel(model: string, agent: IAgent): Promise<boolean> {
     const provider = await agent.modelsProvider.getProvider(model);
-    return provider === PROVIDERS.RUNWARE || provider.toLowerCase() === PROVIDERS.RUNWARE.toLowerCase();
+    return provider === PROVIDERS.RUNWARE || provider?.toLowerCase() === PROVIDERS.RUNWARE.toLowerCase();
 }
 
 function isDallEModel(model: string) {
     return model?.replace(BUILT_IN_MODEL_PREFIX, '')?.startsWith(MODEL_FAMILY.DALL_E);
 }
 
+async function isGoogleAIModel(model: string, agent: IAgent): Promise<boolean> {
+    const provider = await agent.modelsProvider.getProvider(model);
+    return (
+        provider === PROVIDERS.GOOGLEAI ||
+        provider?.toLowerCase() === PROVIDERS.GOOGLEAI.toLowerCase() ||
+        model?.replace(BUILT_IN_MODEL_PREFIX, '')?.includes('imagen')
+    );
+}
+
 function parseFiles(input: any, config: any) {
     const mediaTypes = ['Image', 'Audio', 'Video', 'Binary'];
 

package/src/Components/LogicAtLeast.class.ts

@@ -6,7 +6,7 @@ import { Component } from './Component.class';
 export class LogicAtLeast extends Component {
     protected configSchema = Joi.object({
         // TODO (Forhad): Need to check if min and max work instead of the custom validateInteger
-        minSetInputs: Joi.string()
+        minSetInputs: Joi.alternatives([Joi.string(), Joi.number()]) // Value is now a number; keep string fallback for backward compatibility.
             .custom(validateInteger({ min: 0, max: 9 }), 'custom range validation')
             .label('Minimum Inputs'),
     });
@@ -21,7 +21,7 @@ export class LogicAtLeast extends Component {
         const logger = this.createComponentLogger(agent, config);
         const result: any = { Output: undefined };
 
-        if (typeof config.data.minSetInputs !== 'string' || config.data.minSetInputs.trim() === '' || isNaN(Number(config.data.minSetInputs))) {
+        if (config.data.minSetInputs === '' || isNaN(Number(config.data.minSetInputs))) {
             return result;
         }
 

package/src/Components/LogicAtMost.class.ts

@@ -6,7 +6,7 @@ import { Component } from './Component.class';
 export class LogicAtMost extends Component {
     protected configSchema = Joi.object({
         // TODO (Forhad): Need to check if min and max work instead of the custom validateInteger
-        maxSetInputs: Joi.string()
+        maxSetInputs: Joi.alternatives([Joi.string(), Joi.number()]) // Value is now a number; keep string fallback for backward compatibility.
             .custom(validateInteger({ min: 0, max: 9 }), 'custom range validation')
             .label('Maximum Inputs'),
     });
@@ -20,7 +20,7 @@ export class LogicAtMost extends Component {
         await super.process(input, config, agent);
         const result: any = { Output: undefined };
 
-        if (typeof config.data.maxSetInputs !== 'string' || config.data.maxSetInputs.trim() === '' || isNaN(Number(config.data.maxSetInputs))) {
+        if (config.data.maxSetInputs === '' || isNaN(Number(config.data.maxSetInputs))) {
             return result;
         }
 

package/src/constants.ts

@@ -76,6 +76,7 @@ export const SUPPORTED_MIME_TYPES_MAP = {
     },
     GoogleAI: {
         image: ['image/png', 'image/jpeg', 'image/jpg', 'image/webp', 'image/heic', 'image/heif'],
+        imageGen: ['image/png', 'image/jpeg', 'image/jpg', 'image/webp'],
         video: [
             'video/mp4',
             'video/mpeg',