@smythos/sre 1.5.64 → 1.5.66

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/package.json

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

package/src/Components/Component.class.ts

@@ -116,7 +116,8 @@ export class Component {
     }
     async postProcess(output, config, agent: Agent): Promise<any> {
         if (output?.result) {
-            delete output?.result?._debug;
+            if (!agent.agentRuntime?.debug) delete output?.result?._debug;
+
             if (!output?.result?._error) delete output?.result?._error;
         }
         return output;

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/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(''),
@@ -70,7 +70,7 @@ export class MCPClient extends Component {
                     ],
                     paths: {},
                 },
-                { agentId: agent?.id },
+                { agentId: agent?.id }
             );
 
             for (const tool of toolsData.tools) {
@@ -107,32 +107,31 @@ export class MCPClient extends Component {
     }
     private async connectMCP(mcpUrl: string) {
         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);
+            console.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 };
+            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 };
         }
-      }
+    }
 }