@smythos/sre 1.6.14 → 1.7.5

package/src/subsystems/MemoryManager/RuntimeContext.ts

@@ -92,11 +92,11 @@ export class RuntimeContext extends EventEmitter {
     private initRuntimeContext() {
         if (this._runtimeFileReady) return;
 
-        const endpointDBGCall = this.runtime.xDebugId?.startsWith('dbg-'); //weak check for debug session, we need to improve this
+        //const endpointDBGCall = this.runtime.xDebugId?.startsWith('dbg-'); //weak check for debug session, we need to improve this
         console.debug('Init Agent Context', this.ctxFile, AccessCandidate.agent(this.runtime.agent.id));
         const agent = this.runtime.agent;
-        let method = (agent.agentRequest.method || 'POST').toUpperCase();
-        const endpoint = agent.endpoints?.[agent.agentRequest.path]?.[method];
+        //let method = (agent.agentRequest.method || 'POST').toUpperCase();
+        //const endpoint = agent.endpoints?.[agent.agentRequest.path]?.[method];
 
         let ctxData: any = {};
 
@@ -115,12 +115,13 @@ export class RuntimeContext extends EventEmitter {
                             ctx: { active: false, name: ctxData.components[cptId].name },
                         };
 
-                        const cpt = ctxData.components[cptId];
-                        //if this debug session was initiated from an endpoint, we mark the endpoint component as active
-                        if (endpoint && endpoint.id != undefined && cpt.id == endpoint.id && endpointDBGCall) {
-                            //cpt.dbg.active = true;
-                            cpt.ctx.active = true;
-                        }
+                        // //TODO : the endpoint initialization logic should be moved to the AgentRuntime class
+                        // const cpt = ctxData.components[cptId];
+                        // //if this debug session was initiated from an endpoint, we mark the endpoint component as active
+                        // if (endpoint && endpoint.id != undefined && cpt.id == endpoint.id && endpointDBGCall) {
+                        //     //cpt.dbg.active = true;
+                        //     cpt.ctx.active = true;
+                        // }
                     }
 
                     await this._cacheConnector

package/src/subsystems/Security/Credentials/Credentials.class.ts

@@ -0,0 +1 @@
+export class Credentials {}

package/src/subsystems/Security/Credentials/ManagedOAuth2Credentials.class.ts

@@ -0,0 +1,106 @@
+import { ConnectorService } from '@sre/Core/ConnectorsService';
+import { Credentials } from './Credentials.class';
+import { AccessCandidate } from '../AccessControl/AccessCandidate.class';
+
+export class ManagedOAuth2Credentials extends Credentials {
+    #accessToken: string;
+    #refreshToken: string;
+    #expiresIn: number;
+    #scope: string;
+    #tokenUrl: string;
+    #service: string;
+    #clientId: string;
+    #clientSecret: string;
+
+    public get accessToken(): string {
+        return this.#accessToken;
+    }
+    public get refreshToken(): string {
+        return this.#refreshToken;
+    }
+    public get expiresIn(): number {
+        return this.#expiresIn;
+    }
+    public get scope(): string {
+        return this.#scope;
+    }
+    public get tokenUrl(): string {
+        return this.#tokenUrl;
+    }
+    public get service(): string {
+        return this.#service;
+    }
+
+    private constructor(data: any) {
+        super();
+        this.parseData(data);
+    }
+
+    static async load(keyId: string, candidate: AccessCandidate): Promise<ManagedOAuth2Credentials> {
+        const managedVault = ConnectorService.getManagedVaultConnector();
+        const result = await managedVault.requester(candidate).get(keyId);
+        const data = typeof result === 'object' ? result : JSON.parse(result || '{}');
+
+        return new ManagedOAuth2Credentials(data);
+    }
+
+    private parseData(data: any) {
+        //SRE v1.0 format
+
+        //SRE v1.5.0+ format
+        if (!data.auth_data || !data.auth_settings) throw new Error('oAuth2Manager:Invalid data format');
+
+        this.#accessToken = data.auth_data.primary;
+        this.#refreshToken = data.auth_data.secondary;
+        this.#expiresIn = data.auth_data.expires_in;
+        this.#scope = data.auth_settings.scope;
+        this.#tokenUrl = data.auth_settings.tokenURL;
+        this.#service = data.auth_settings.service;
+        this.#clientId = data.auth_settings.clientID;
+        this.#clientSecret = data.auth_settings.clientSecret;
+    }
+
+    /**
+     * Get a fresh access token using the refresh token
+     */
+    public async refreshAccessToken() {
+        console.log('Refreshing access token...');
+
+        const tokenUrl = this.#tokenUrl;
+        const body = new URLSearchParams({
+            client_id: this.#clientId,
+            client_secret: this.#clientSecret,
+            refresh_token: this.#refreshToken,
+            grant_type: 'refresh_token',
+        });
+
+        try {
+            const res = await fetch(tokenUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                body: body.toString(),
+            });
+
+            const text = await res.text();
+            let json: any;
+            try {
+                json = JSON.parse(text);
+            } catch {
+                throw new Error(`Invalid JSON response: ${text}`);
+            }
+
+            if (!res.ok) {
+                const errorMsg = json.error_description || json.error?.message || json.error || text;
+                throw new Error(`HTTP ${res.status}: ${errorMsg}`);
+            }
+
+            this.#accessToken = json.access_token;
+            this.#expiresIn = Date.now() + json.expires_in * 1000;
+            return this.#accessToken;
+        } catch (error: any) {
+            throw new Error(`Failed to refresh access token: ${error.message}`);
+        }
+    }
+}

package/src/types/Agent.types.ts

@@ -29,6 +29,7 @@ export interface IAgent {
     sessionTag: any;
     callerSessionId: any;
     apiBasePath: any;
+    triggerBasePath: any;
     agentRuntime: AgentRuntime | any;
     usingTestDomain: any;
     domain: any;

package/src/types/LLM.types.ts

@@ -87,52 +87,65 @@ export type TToolsInfo = {
 
 export type TSearchContextSize = 'low' | 'medium' | 'high';
 
-export type TLLMParams = {
-    model: TLLMModel | string;
-
-    prompt?: string;
-    messages?: any[]; // TODO [Forhad]: apply proper typing
-    temperature?: number;
-    maxTokens?: number;
-    stopSequences?: string[];
-    topP?: number;
-    topK?: number;
-    frequencyPenalty?: number;
-    presencePenalty?: number;
-    responseFormat?: any; // TODO [Forhad]: apply proper typing
-    modelInfo?: TCustomLLMModel;
-    files?: BinaryInput[];
+type TLLMToolConfig = {
     toolsConfig?: {
         tools?: OpenAI.ChatCompletionTool[] | OpenAI.Responses.Tool[] | OpenAI.Responses.WebSearchTool[];
         tool_choice?: TLLMToolChoice;
     };
-    baseURL?: string;
-
-    size?: OpenAI.Images.ImageGenerateParams['size'] | OpenAI.Images.ImageEditParams['size']; // for image generation and image editing
-    quality?: 'standard' | 'hd'; // for image generation
-    n?: number; // for image generation
-    style?: 'vivid' | 'natural'; // for image generation
+};
 
-    cache?: boolean;
-    agentId?: string;
-    teamId?: string;
+type TLLMThinkingConfig = {
     thinking?: {
         // for Anthropic
         type: 'enabled' | 'disabled';
         budget_tokens: number;
     };
     maxThinkingTokens?: number;
+};
+
+type TLLMReasoningConfig = {
+    useReasoning?: boolean;
+
+    /**
+     * Controls the level of effort the model will put into reasoning
+     * For GPT-OSS models (20B, 120B): "low" | "medium" | "high"
+     * For Qwen 3 32B: "none" | "default"
+     */
+    reasoningEffort?: 'none' | 'default' | OpenAIReasoningEffort;
+
+    max_output_tokens?: number;
+    verbosity?: OpenAI.Responses.ResponseCreateParams['text']['verbosity'];
+    abortSignal?: AbortSignal;
+};
 
-    // #region Search
-    // Web search parameters (will be organized into toolsInfo.webSearch internally)
+type TLLMTextGenConfig = {
+    model: TLLMModel | string;
+    prompt?: string;
+    messages?: any[]; // TODO [Forhad]: apply proper typing
+    temperature?: number;
+    maxTokens?: number;
+    stopSequences?: string[];
+    topP?: number;
+    topK?: number;
+    frequencyPenalty?: number;
+    presencePenalty?: number;
+    responseFormat?: any; // TODO [Forhad]: apply proper typing
+} & TLLMToolConfig &
+    TLLMThinkingConfig &
+    TLLMReasoningConfig;
+
+// OpenAI specific web search parameters
+type TLLMWebSearchConfig = {
     useWebSearch?: boolean;
     webSearchContextSize?: TSearchContextSize;
     webSearchCity?: string;
     webSearchCountry?: string;
     webSearchRegion?: string;
     webSearchTimezone?: string;
+};
 
-    // xAI specific search parameters (consider moving to toolsInfo.xaiSearch)
+// xAI specific search parameters
+type TLLMSearchConfig = {
     useSearch?: boolean;
     searchMode?: 'auto' | 'on' | 'off';
     returnCitations?: boolean;
@@ -149,20 +162,33 @@ export type TLLMParams = {
     safeSearch?: boolean;
     fromDate?: string;
     toDate?: string;
-    // #endregion
+} & TLLMWebSearchConfig;
 
-    useReasoning?: boolean;
-    /**
-     * Controls the level of effort the model will put into reasoning
-     * For GPT-OSS models (20B, 120B): "low" | "medium" | "high"
-     * For Qwen 3 32B: "none" | "default"
-     */
-    reasoningEffort?: 'none' | 'default' | OpenAIReasoningEffort;
-    max_output_tokens?: number;
-    verbosity?: OpenAI.Responses.ResponseCreateParams['text']['verbosity'];
-    abortSignal?: AbortSignal;
+type TLLMMiscConfig = {
+    maxContextWindowLength?: number;
+    useContextWindow?: boolean;
+    passthrough?: boolean;
 };
 
+type TLLMRuntimeContext = {
+    modelInfo?: TCustomLLMModel;
+    files?: BinaryInput[];
+    baseURL?: string;
+
+    cache?: boolean;
+    agentId?: string;
+    teamId?: string;
+};
+
+type TLLMImageGenConfig = {
+    size?: OpenAI.Images.ImageGenerateParams['size'] | OpenAI.Images.ImageEditParams['size']; // for image generation and image editing
+    quality?: 'standard' | 'hd'; // for image generation
+    n?: number; // for image generation
+    style?: 'vivid' | 'natural'; // for image generation
+};
+
+export type TLLMParams = TLLMTextGenConfig & TLLMSearchConfig & TLLMImageGenConfig & TLLMMiscConfig & TLLMRuntimeContext;
+
 export type TLLMPreparedParams = TLLMParams & {
     body: any;
     modelEntryName?: string; // for usage reporting
@@ -387,8 +413,8 @@ export type TLLMMessageBlock = {
         | Array<Anthropic.TextBlockParam | Anthropic.ImageBlockParam | Anthropic.ToolUseBlockParam | Anthropic.ToolResultBlockParam>;
     parts?: {
         text?: string;
-        functionCall?: { name: string; args: string };
-        functionResponse?: { name: string; response: { name: string; content: string } };
+        functionCall?: { name: string; args: string | Record<string, any> };
+        functionResponse?: { name: string; response: any };
     }[]; // for Google Vertex AI
     tool_calls?: ToolData[];
 };
@@ -471,6 +497,8 @@ export enum TLLMEvent {
     Usage = 'usage',
     /** Interrupted : emitted when the response is interrupted before completion */
     Interrupted = 'interrupted',
+    /** Fallback : emitted when the response is using a fallback model */
+    Fallback = 'fallback',
 }
 
 export interface ILLMRequestContext {

package/src/types/SRE.types.ts

@@ -13,6 +13,7 @@ import { LogService } from '@sre/IO/Log.service';
 import { ComponentService } from '@sre/AgentManager/Component.service';
 import { ModelsProviderService } from '@sre/LLMManager/ModelsProvider.service';
 import { CodeService } from '@sre/ComputeManager/Code.service';
+import { SchedulerService } from '@sre/AgentManager/Scheduler.service';
 
 export type TServiceRegistry = {
     Storage?: StorageService;
@@ -30,6 +31,7 @@ export type TServiceRegistry = {
     Component?: ComponentService;
     ModelsProvider?: ModelsProviderService;
     Code?: CodeService;
+    Scheduler?: SchedulerService;
 };
 
 export enum TConnectorService {
@@ -48,6 +50,7 @@ export enum TConnectorService {
     Component = 'Component',
     ModelsProvider = 'ModelsProvider',
     Code = 'Code',
+    Scheduler = 'Scheduler',
 }
 
 export type SREConnectorConfig = {

package/src/types/VectorDB.types.ts

@@ -3,17 +3,19 @@ export type VectorDBMetadata = {
     datasourceId: string;
     datasourceLabel: string;
     acl: string;
-    user_metadata?: string;
+    user_metadata?: string | Record<string, any>;
     text?: string;
 };
 
-export type VectorsResultData = {
+export type VectorDBResult = {
     id: string;
     score?: number;
     values: number[];
     text: string;
     metadata?: Record<string, any>;
-}[];
+};
+
+export type VectorsResultData = VectorDBResult[];
 
 export interface NsKnownMetadata {
     isOnCustomStorage?: boolean;
@@ -58,6 +60,7 @@ export interface IStorageVectorDataSource {
     metadata: string;
     text?: string;
     vectorIds: string[];
+    vectorInfo?: VectorDBResult[];
     id: string;
     candidateId: string;
     candidateRole: string;
@@ -83,4 +86,5 @@ export interface DatasourceDto {
     chunkOverlap?: number;
     label?: string;
     id?: string;
+    returnFullVectorInfo?: boolean;
 }