@smythos/sre 1.5.65 → 1.5.67

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

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

package/dist/types/Components/Triggers/GmailTrigger.class.d.ts

@@ -0,0 +1,13 @@
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Trigger } from './Trigger.class';
+export declare class GmailTrigger extends Trigger {
+    init(): void;
+    process(input: any, config: any, agent: Agent): Promise<{
+        Payload: {};
+        Result: any;
+        _temp_result: any;
+        _error: any;
+        _in_progress: boolean;
+        _debug: string;
+    }>;
+}

package/dist/types/Components/Triggers/Trigger.class.d.ts

@@ -0,0 +1,3 @@
+import { Component } from '../Component.class';
+export declare class Trigger extends Component {
+}

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

@@ -1,9 +1,10 @@
 import EventEmitter from 'events';
 import { UsageMetadata } from '@google/generative-ai';
-import { TLLMMessageBlock, ToolData, TLLMToolResultMessageBlock, APIKeySource, ILLMRequestFuncParams, TLLMChatResponse, TGoogleAIRequestBody, TLLMPreparedParams } from '@sre/types/LLM.types';
+import { TLLMMessageBlock, ToolData, TLLMToolResultMessageBlock, APIKeySource, ILLMRequestFuncParams, TLLMChatResponse, TGoogleAIRequestBody, ILLMRequestContext, TLLMPreparedParams } from '@sre/types/LLM.types';
 import { LLMConnector } from '../LLMConnector';
 type UsageMetadataWithThoughtsToken = UsageMetadata & {
-    thoughtsTokenCount: number;
+    thoughtsTokenCount?: number;
+    cost?: number;
 };
 export declare class GoogleAIConnector extends LLMConnector {
     name: string;
@@ -32,6 +33,18 @@ export declare class GoogleAIConnector extends LLMConnector {
         teamId: string;
         tier: string;
     };
+    /**
+     * Extract text and image tokens from Google AI usage metadata
+     */
+    private extractTokenCounts;
+    protected reportImageUsage({ usage, context, numberOfImages, }: {
+        usage: {
+            cost?: number;
+            usageMetadata?: UsageMetadataWithThoughtsToken;
+        };
+        context: ILLMRequestContext;
+        numberOfImages?: number;
+    }): void;
     formatToolsConfig({ toolDefinitions, toolChoice }: {
         toolDefinitions: any;
         toolChoice?: string;
@@ -51,6 +64,7 @@ export declare class GoogleAIConnector extends LLMConnector {
     private prepareMessagesWithTools;
     private prepareMessagesWithTextQuery;
     private prepareBodyForImageGenRequest;
+    private prepareImageEditBody;
     private sanitizeFunctionName;
     private uploadFile;
     private getValidFiles;

package/dist/types/types/LLM.types.d.ts

@@ -193,11 +193,29 @@ export type TLLMModel = {
     params?: TLLMParams;
     /**
      * Specifies the API interface type to use for this model
-     * Examples: 'chat.completions', 'responses'
-     * This determines which OpenAI API endpoint and interface implementation to use
+     * This determines which API endpoint and interface implementation to use
      */
-    interface?: 'chat.completions' | 'responses';
+    interface?: LLMInterface;
+    /**
+     * Indicates whether this model supports image editing functionality
+     * Only applicable for image generation models
+     */
+    supportsEditing?: boolean;
 };
+/**
+ * Enum for different LLM API interfaces
+ * Each interface represents a different API endpoint or interaction pattern
+ */
+export declare enum LLMInterface {
+    /** OpenAI-style chat completions API */
+    ChatCompletions = "chat.completions",
+    /** OpenAI-style responses API */
+    Responses = "responses",
+    /** Google AI generateContent API (for text and multimodal) */
+    GenerateContent = "generateContent",
+    /** Google AI generateImages API (for traditional Imagen models) */
+    GenerateImages = "generateImages"
+}
 export declare const BuiltinLLMProviders: {
     readonly Echo: "Echo";
     readonly OpenAI: "OpenAI";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smythos/sre",
-  "version": "1.5.65",
+  "version": "1.5.67",
   "description": "Smyth Runtime Environment",
   "author": "Alaa-eddine KADDOURI",
   "license": "MIT",

package/src/Components/FTimestamp.class.ts

@@ -1,25 +1,66 @@
 import { Component } from './Component.class';
 import { IAgent as Agent } from '@sre/types/Agent.types';
+import Joi from 'joi';
+import dayjs from 'dayjs';
 
 export class FTimestamp extends Component {
+    protected configSchema = Joi.object({
+        format: Joi.alternatives()
+            .try(Joi.string().valid('unix', 'iso', 'timestamp'), Joi.string().pattern(/^[YMDHhmsSSZzAa\s\-\/:,\.]*$/, 'custom dayjs format'))
+            .default('unix')
+            .allow(null)
+            .label('Timestamp Format')
+            .messages({
+                'string.pattern.name': 'Invalid format string: {#value}',
+            }),
+    });
+
     constructor() {
         super();
     }
     init() {}
     async process(input, config, agent: Agent) {
         await super.process(input, config, agent);
+
         const logger = this.createComponentLogger(agent, config);
+
+        const validationResult = await this.validateConfig(config);
+        if (validationResult._error) {
+            return {
+                Timestamp: undefined,
+                _error: validationResult._error,
+                _debug: logger.output,
+                _debug_time: logger.elapsedTime,
+            };
+        }
         try {
             const _error = undefined;
-            const format = config.data.format; //TODO set timestamp format
-            const Timestamp = Date.now();
-            logger.debug(`Timestamp : ${Timestamp}`);
+            const format = config.data.format || 'unix';
+            const now = dayjs();
+
+            let Timestamp: number | string;
+
+            switch (format) {
+                case 'unix':
+                case 'timestamp':
+                    Timestamp = Date.now();
+                    logger.debug(`Unix timestamp: ${Timestamp}`);
+                    break;
+                case 'iso':
+                    Timestamp = now.toISOString();
+                    logger.debug(`ISO timestamp: ${Timestamp}`);
+                    break;
+                default:
+                    Timestamp = now.format(format);
+                    logger.debug(`Custom formatted timestamp (${format}): ${Timestamp}`);
+                    break;
+            }
 
             return { Timestamp, _error, _debug: logger.output, _debug_time: logger.elapsedTime };
         } catch (err: any) {
             const _error = err?.response?.data || err?.message || err.toString();
-            logger.error(` Error processing data \n${_error}\n`);
-            return { hash: undefined, _error, _debug: logger.output, _debug_time: logger.elapsedTime };
+            logger.error(` Error processing timestamp \n${_error}\n`);
+            return { Timestamp: undefined, _error, _debug: logger.output, _debug_time: logger.elapsedTime };
         }
     }
 }

package/src/Components/ImageGenerator.class.ts

@@ -44,12 +44,6 @@ 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(),
@@ -344,11 +338,6 @@ const imageGenerator = {
 
             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;
@@ -360,29 +349,21 @@ const imageGenerator = {
                 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 response;
+
+            // Check if files are provided for image editing
+            if (files.length > 0) {
+                const validFiles = files.filter((file) => imageGenerator.isValidImageFile('GoogleAI', file.mimetype));
+                if (validFiles.length === 0) {
+                    throw new Error('Supported image file types are: ' + SUPPORTED_MIME_TYPES_MAP.GoogleAI?.image?.join(', '));
+                }
+                response = await llmInference.imageEditRequest({ query: prompt, files: validFiles, params: { ...args, agentId: agent.id } });
+            } else {
+                response = await llmInference.imageGenRequest({ query: prompt, params: { ...args, agentId: agent.id } });
             }
 
+            // Usage reporting is now handled in the GoogleAI connector
+
             let output = response?.data?.[0]?.b64_json;
 
             if (output) {

package/src/Components/MCPClient.class.ts

@@ -14,9 +14,9 @@ export class MCPClient extends Component {
         model: Joi.string().optional(),
         openAiModel: Joi.string().optional(), // for backward compatibility
         mcpUrl: Joi.string().max(2048).uri().required().description('URL of the MCP'),
-        descForModel: Joi.string().max(5000).required().allow('').label('Description for Model'),
+        descForModel: Joi.string().max(5000).allow('').label('Description for Model'),
         name: Joi.string().max(500).required().allow(''),
-        desc: Joi.string().max(5000).required().allow('').label('Description'),
+        desc: Joi.string().max(5000).allow('').label('Description'),
         logoUrl: Joi.string().max(8192).allow(''),
         id: Joi.string().max(200),
         version: Joi.string().max(100).allow(''),
@@ -51,7 +51,7 @@ export class MCPClient extends Component {
             }
 
             // TODO [Forhad]: Need to check and validate input prompt token
-            const { client } = await this.connectMCP(mcpUrl);
+            const { client } = await this.connectMCP(mcpUrl, logger);
 
             const toolsData = await client.listTools();
             const conv = new Conversation(
@@ -70,7 +70,7 @@ export class MCPClient extends Component {
                     ],
                     paths: {},
                 },
-                { agentId: agent?.id },
+                { agentId: agent?.id }
             );
 
             for (const tool of toolsData.tools) {
@@ -105,34 +105,33 @@ export class MCPClient extends Component {
             return { _error: `Error on running MCP Client!\n${error?.message || JSON.stringify(error)}`, _debug: logger.output };
         }
     }
-    private async connectMCP(mcpUrl: string) {
+    private async connectMCP(mcpUrl: string, logger: any) {
         const client = new Client({ name: 'auto-client', version: '1.0.0' });
-      
+
         // 1) Try Streamable HTTP first
         try {
-          const st = new StreamableHTTPClientTransport(new URL(mcpUrl));
-          await client.connect(st);
-          console.debug('Connected to MCP using Streamable HTTP');
-          return { client, transport: 'streamable' as const };
+            const st = new StreamableHTTPClientTransport(new URL(mcpUrl));
+            await client.connect(st);
+            logger.debug('Connected to MCP using Streamable HTTP');
+            return { client, transport: 'streamable' as const };
         } catch (e: any) {
-          console.debug('Failed to connect to MCP using Streamable HTTP, falling back to SSE');
-          // 2) If clearly unsupported, fall back to SSE
-          const msg = String(e?.message || e);
-          const isUnsupported =
-            /404|405|ENOTFOUND|ECONNREFUSED|CORS/i.test(msg);
-      
-          // 406 means wrong/missing Accept for Streamable → retry Streamable with proper header
-          const isAcceptProblem = /406|Not Acceptable|text\/event-stream/i.test(msg);
-          if (isAcceptProblem) {
-            throw new Error('Server is Streamable; include Accept: application/json, text/event-stream');
-          }
-      
-          if (!isUnsupported) throw e;
-      
-          // SSE fallback
-          const sse = new SSEClientTransport(new URL(mcpUrl));
-          await client.connect(sse);
-          return { client, transport: 'sse' as const };
+            logger.debug('Failed to connect to MCP using Streamable HTTP, falling back to SSE');
+            // 2) If clearly unsupported, fall back to SSE
+            const msg = String(e?.message || e);
+            const isUnsupported = /404|405|ENOTFOUND|ECONNREFUSED|CORS/i.test(msg);
+
+            // 406 means wrong/missing Accept for Streamable → retry Streamable with proper header
+            const isAcceptProblem = /406|Not Acceptable|text\/event-stream/i.test(msg);
+            if (isAcceptProblem) {
+                throw new Error('Server is Streamable; include Accept: application/json, text/event-stream');
+            }
+
+            if (!isUnsupported) throw e;
+
+            // SSE fallback
+            const sse = new SSEClientTransport(new URL(mcpUrl));
+            await client.connect(sse);
+            return { client, transport: 'sse' as const };
         }
-      }
+    }
 }

package/src/helpers/Conversation.helper.ts

@@ -281,6 +281,8 @@ export class Conversation extends EventEmitter {
         let _content = '';
         const reqMethods = this._reqMethods;
         const toolsConfig = this._toolsConfig;
+        //deduplicate tools
+        toolsConfig.tools = toolsConfig.tools.filter((tool, index, self) => self.findIndex((t) => t.name === tool.name) === index);
         const endpoints = this._endpoints;
         const baseUrl = this._baseUrl;
         const message_id = 'msg_' + randomUUID();