@smythos/sre 1.5.0

package/dist/types/subsystems/Security/Vault.service/VaultConnector.d.ts

@@ -0,0 +1,17 @@
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { SecureConnector } from '@sre/Security/SecureConnector.class';
+import { IAccessCandidate } from '@sre/types/ACL.types';
+export interface IVaultRequest {
+    get(keyId: string): Promise<string>;
+    exists(keyId: string): Promise<boolean>;
+    listKeys(): Promise<string[]>;
+}
+export declare abstract class VaultConnector extends SecureConnector {
+    requester(candidate: AccessCandidate): IVaultRequest;
+    abstract getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    protected abstract get(acRequest: AccessRequest, keyId: string): Promise<string>;
+    protected abstract exists(acRequest: AccessRequest, keyId: string): Promise<boolean>;
+    protected abstract listKeys(acRequest: AccessRequest): Promise<string[]>;
+}

package/dist/types/subsystems/Security/Vault.service/connectors/HashicorpVault.class.d.ts

@@ -0,0 +1,13 @@
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { IAccessCandidate } from '@sre/types/ACL.types';
+import { VaultConnector } from '../VaultConnector';
+export declare class HashicorpVault extends VaultConnector {
+    protected _settings: any;
+    name: string;
+    constructor(_settings: any);
+    protected get(acRequest: AccessRequest, keyId: string): Promise<any>;
+    protected exists(acRequest: AccessRequest, keyId: string): Promise<boolean>;
+    protected listKeys(acRequest: AccessRequest): Promise<any[]>;
+    getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+}

package/dist/types/subsystems/Security/Vault.service/connectors/JSONFileVault.class.d.ts

@@ -0,0 +1,23 @@
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { IAccessCandidate } from '@sre/types/ACL.types';
+import { VaultConnector } from '../VaultConnector';
+export type JSONFileVaultConfig = {
+    file?: string;
+    fileKey?: string;
+    shared?: boolean;
+};
+export declare class JSONFileVault extends VaultConnector {
+    protected _settings: JSONFileVaultConfig;
+    name: string;
+    private vaultData;
+    private index;
+    private sharedVault;
+    constructor(_settings: JSONFileVaultConfig);
+    private findVaultFile;
+    private getMasterKeyInteractive;
+    protected get(acRequest: AccessRequest, keyId: string): Promise<any>;
+    protected exists(acRequest: AccessRequest, keyId: string): Promise<boolean>;
+    protected listKeys(acRequest: AccessRequest): Promise<string[]>;
+    getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+}

package/dist/types/subsystems/Security/Vault.service/connectors/NullVault.class.d.ts

@@ -0,0 +1,16 @@
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { IAccessCandidate } from '@sre/types/ACL.types';
+import { VaultConnector } from '../VaultConnector';
+export declare class NullVault extends VaultConnector {
+    protected _settings: any;
+    name: string;
+    private vaultData;
+    private index;
+    private sharedVault;
+    constructor(_settings: any);
+    protected get(acRequest: AccessRequest, keyId: string): Promise<string>;
+    protected exists(acRequest: AccessRequest, keyId: string): Promise<boolean>;
+    protected listKeys(acRequest: AccessRequest): Promise<any[]>;
+    getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+}

package/dist/types/subsystems/Security/Vault.service/connectors/SecretsManager.class.d.ts

@@ -0,0 +1,20 @@
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { IAccessCandidate } from '@sre/types/ACL.types';
+import { VaultConnector } from '../VaultConnector';
+export type SecretsManagerConfig = {
+    region: string;
+    awsAccessKeyId?: string;
+    awsSecretAccessKey?: string;
+};
+export declare class SecretsManager extends VaultConnector {
+    protected _settings: SecretsManagerConfig;
+    name: string;
+    private secretsManager;
+    constructor(_settings: SecretsManagerConfig);
+    protected get(acRequest: AccessRequest, secretName: string): Promise<any>;
+    protected exists(acRequest: AccessRequest, keyId: string): Promise<boolean>;
+    protected listKeys(acRequest: AccessRequest): Promise<any[]>;
+    getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    private getSecretByName;
+}

package/dist/types/subsystems/Security/Vault.service/index.d.ts

@@ -0,0 +1,4 @@
+import { ConnectorServiceProvider } from '@sre/Core/ConnectorsService';
+export declare class VaultService extends ConnectorServiceProvider {
+    register(): void;
+}

package/dist/types/types/ACL.types.d.ts

@@ -0,0 +1,83 @@
+export declare const DEFAULT_TEAM_ID = "default";
+export declare enum TAccessLevel {
+    None = "none",
+    Owner = "owner",
+    Read = "read",
+    Write = "write"
+}
+export declare enum TAccessRole {
+    Agent = "agent",
+    User = "user",
+    Team = "team",
+    Public = "public"
+}
+export declare const RoleMap: {
+    user: string;
+    agent: string;
+    team: string;
+    public: string;
+};
+export declare const LevelMap: {
+    none: string;
+    owner: string;
+    read: string;
+    write: string;
+};
+export declare const ReverseRoleMap: {
+    [k: string]: string;
+};
+export declare const ReverseLevelMap: {
+    [k: string]: string;
+};
+/**
+ * an ACLEntry is a list of access levels for a given owner.
+ * an owner can be an agent, a user, a team or the public.
+ */
+export type TACLEntry = {
+    [hashedOwnerKey: string]: TAccessLevel[] | undefined;
+};
+/**
+ * The Access Control List (ACL) is a list of access rights for a given resource.
+ * Each entry in this ACL represents a role
+ * Role entries define a list of owners of the resource and the access levels they have.
+ * e.g.
+ *  The following ACL defines that agentA and teamA has read and write access, while agentB and teamC has read access.
+ *   {
+ *      agent: {
+ *         'agentA': ['read', 'write'],
+ *         'agentB': ['read'],
+ *     },
+ *    team: {
+ *       'teamA': ['read', 'write'],
+ *       'teamC': ['read'],
+ *     }
+ * }
+ */
+export interface IACL {
+    hashAlgorithm?: string | undefined;
+    entries?: {
+        [key in TAccessRole]?: TACLEntry | undefined;
+    };
+    migrated?: boolean | undefined;
+}
+export interface IAccessCandidate {
+    role: TAccessRole;
+    id: string;
+}
+export interface IAccessRequest {
+    id: string;
+    resourceId: string;
+    candidate: IAccessCandidate;
+    level: TAccessLevel | TAccessLevel[];
+}
+export declare enum TAccessResult {
+    Granted = "granted",
+    Denied = "denied"
+}
+export type TAccessTicket = {
+    request: IAccessRequest;
+    access: TAccessResult;
+};
+export declare class ACLAccessDeniedError extends Error {
+    constructor(message?: string);
+}

package/dist/types/types/AWS.types.d.ts

@@ -0,0 +1,7 @@
+export type AWSCredentials = {
+    accessKeyId: string;
+    secretAccessKey: string;
+};
+export type AWSRegionConfig = {
+    region: string;
+};

package/dist/types/types/Agent.types.d.ts

@@ -0,0 +1,52 @@
+import { AgentRequest } from '@sre/AgentManager/AgentRequest.class';
+import { AgentRuntime } from '@sre/AgentManager/AgentRuntime.class';
+import { AgentSSE } from '@sre/AgentManager/AgentSSE.class';
+import { IModelsProviderRequest } from '@sre/LLMManager/ModelsProvider.service/ModelsProviderConnector';
+export type TAgentProcessParams = {
+    method: string;
+    path: string;
+    body?: Record<string, any>;
+    query?: Record<string, any>;
+    headers?: Record<string, string>;
+    params?: any;
+};
+export interface IAgent {
+    id: any;
+    jobID: any;
+    async: boolean;
+    agentSettings: any;
+    name: any;
+    data: any;
+    teamId: any;
+    components: any;
+    connections: any;
+    endpoints: any;
+    sessionId: any;
+    sessionTag: any;
+    callerSessionId: any;
+    apiBasePath: any;
+    agentRuntime: AgentRuntime | any;
+    usingTestDomain: any;
+    domain: any;
+    debugSessionEnabled: any;
+    circularLimit: any;
+    version: any;
+    agentVariables: any;
+    kill: any;
+    sse: AgentSSE;
+    modelsProvider: IModelsProviderRequest;
+    agentRequest: AgentRequest | any;
+    callback: (data: any) => void;
+    setRequest: (agentRequest: AgentRequest | any) => void;
+    setCallback: (callback: (data: any) => void) => void;
+    isKilled: () => boolean;
+    process: (endpointPath: string, input: any) => Promise<any>;
+    postProcess: (result: any) => Promise<any>;
+    addSSE: (sseSource: Response | AgentSSE, monitorId?: string) => void;
+    getConnectionSource: (connection: any) => any;
+    getConnectionTarget: (connection: any) => any;
+    findReadablePredecessors: (componentId: string) => any[];
+    callComponent: (sourceId: string, componentId: string, input?: any) => Promise<any>;
+    JSONExpression: (obj: any, propertyString: string) => any;
+    callNextComponents: (componentId: string, output: any) => Promise<any>;
+}

package/dist/types/types/AgentLogger.types.d.ts

@@ -0,0 +1,16 @@
+export type AgentCallLog = {
+    sourceId?: any;
+    componentId?: any;
+    domain?: any;
+    input?: any;
+    output?: any;
+    inputTimestamp?: any;
+    outputTimestamp?: any;
+    result?: any;
+    error?: any;
+    sessionID?: any;
+    tags?: string;
+    step?: number;
+    workflowID?: string;
+    processID?: string;
+};

package/dist/types/types/Cache.types.d.ts

@@ -0,0 +1 @@
+export type CacheMetadata = Record<string, any> | undefined;

package/dist/types/types/Common.types.d.ts

@@ -0,0 +1,3 @@
+export type KeyValueObject = {
+    [key: string]: any;
+};

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

@@ -0,0 +1,365 @@
+import OpenAI from 'openai';
+import Anthropic from '@anthropic-ai/sdk';
+import { FunctionCallingMode, ModelParams, GenerateContentRequest } from '@google/generative-ai';
+import { BinaryInput } from '@sre/helpers/BinaryInput.helper';
+import { type models } from '@sre/LLMManager/models';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { ConverseCommandInput } from '@aws-sdk/client-bedrock-runtime';
+export type LLMProvider = Extract<(typeof models)[keyof typeof models], {
+    llm: string;
+}>['llm'] | 'VertexAI' | 'Bedrock';
+export type LLMModel = keyof typeof models;
+export type LLMModelInfo = (typeof models)[LLMModel];
+export interface VertexAICredentials {
+    type: 'service_account';
+    project_id: string;
+    private_key_id: string;
+    private_key: string;
+    client_email: string;
+    client_id: string;
+    auth_uri: string;
+    token_uri: string;
+    auth_provider_x509_cert_url: string;
+    client_x509_cert_url: string;
+    universe_domain?: string;
+}
+export interface BasicCredentials {
+    apiKey: string;
+    isUserKey: boolean;
+}
+export interface BedrockCredentials {
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+}
+export type ILLMConnectorCredentials = BasicCredentials | BedrockCredentials | VertexAICredentials;
+export type TOpenAIResponseToolChoice = OpenAI.Responses.ToolChoiceOptions | OpenAI.Responses.ToolChoiceTypes | OpenAI.Responses.ToolChoiceFunction;
+export type TLLMToolChoice = OpenAI.ChatCompletionToolChoiceOption;
+export type TLLMParams = {
+    model: TLLMModel | string;
+    modelEntryName?: string;
+    credentials?: ILLMConnectorCredentials;
+    prompt?: string;
+    messages?: any[];
+    temperature?: number;
+    maxTokens?: number;
+    stopSequences?: string[];
+    topP?: number;
+    topK?: number;
+    frequencyPenalty?: number;
+    presencePenalty?: number;
+    responseFormat?: any;
+    modelInfo?: TCustomLLMModel;
+    files?: BinaryInput[];
+    toolsConfig?: {
+        tools?: OpenAI.ChatCompletionTool[] | OpenAI.Responses.Tool[] | OpenAI.Responses.WebSearchTool[];
+        tool_choice?: TLLMToolChoice;
+    };
+    baseURL?: string;
+    size?: OpenAI.Images.ImageGenerateParams['size'] | OpenAI.Images.ImageEditParams['size'];
+    quality?: 'standard' | 'hd';
+    n?: number;
+    style?: 'vivid' | 'natural';
+    cache?: boolean;
+    agentId?: string;
+    teamId?: string;
+    thinking?: {
+        type: 'enabled' | 'disabled';
+        budget_tokens: number;
+    };
+    maxThinkingTokens?: number;
+    useWebSearch?: boolean;
+    webSearchContextSize?: 'high' | 'medium' | 'low';
+    webSearchCity?: string;
+    webSearchCountry?: string;
+    webSearchRegion?: string;
+    webSearchTimezone?: string;
+    useReasoning?: boolean;
+    isUserKey?: boolean;
+    capabilities?: {
+        search?: boolean;
+        reasoning?: boolean;
+        imageGeneration?: boolean;
+        imageEditing?: boolean;
+    };
+    max_output_tokens?: number;
+    abortSignal?: AbortSignal;
+};
+export type TLLMParamsV2 = {
+    model: string;
+    modelEntryName: string;
+    messages: any[];
+    toolsConfig?: {
+        tools?: OpenAI.Responses.Tool[];
+        tool_choice?: OpenAI.Responses.ToolChoiceOptions | OpenAI.Responses.ToolChoiceTypes | OpenAI.Responses.ToolChoiceFunction;
+    };
+    baseURL?: string;
+    stream?: boolean;
+    responseFormat?: any;
+    credentials?: {
+        apiKey?: string;
+        isUserKey?: boolean;
+    };
+    max_output_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    top_k?: number;
+    frequency_penalty?: number;
+    presence_penalty?: number;
+    teamId?: string;
+    files?: BinaryInput[];
+    useWebSearch?: boolean;
+    webSearchContextSize?: 'high' | 'medium' | 'low';
+    webSearchCity?: string;
+    webSearchCountry?: string;
+    webSearchRegion?: string;
+    webSearchTimezone?: string;
+};
+export type TLLMConnectorParams = Omit<TLLMParams, 'model'> & {
+    model: string | TLLMModel | TCustomLLMModel;
+};
+export type TLLMModelEntry = {
+    llm: string;
+    tokens?: number;
+    completionTokens?: number;
+    enabled?: boolean;
+    components?: string[];
+    alias?: string;
+    tags?: string[];
+    keyOptions?: {
+        tokens: number;
+        completionTokens: number;
+    };
+};
+export declare enum TLLMCredentials {
+    Vault = "vault",
+    Internal = "internal",
+    BedrockVault = "bedrock_vault",
+    VertexAIVault = "vertexai_vault",
+    None = "none"
+}
+export type TLLMModel = {
+    llm?: string;
+    isCustomLLM?: boolean;
+    modelId?: string;
+    tokens?: number;
+    completionTokens?: number;
+    components?: string[];
+    tags?: string[];
+    label?: string;
+    provider?: LLMProvider;
+    features?: string[];
+    enabled?: boolean;
+    alias?: string;
+    baseURL?: string;
+    keyOptions?: {
+        tokens: number;
+        completionTokens: number;
+    };
+    credentials?: TLLMCredentials;
+    params?: TLLMParams;
+};
+export declare const BuiltinLLMProviders: {
+    readonly Echo: "Echo";
+    readonly OpenAI: "OpenAI";
+    readonly DeepSeek: "DeepSeek";
+    readonly GoogleAI: "GoogleAI";
+    readonly Anthropic: "Anthropic";
+    readonly Groq: "Groq";
+    readonly TogetherAI: "TogetherAI";
+    readonly Bedrock: "Bedrock";
+    readonly VertexAI: "VertexAI";
+    readonly xAI: "xAI";
+    readonly Perplexity: "Perplexity";
+};
+export type TBuiltinLLMProvider = (typeof BuiltinLLMProviders)[keyof typeof BuiltinLLMProviders];
+export interface ILLMProviders {
+}
+export type TLLMProvider = TBuiltinLLMProvider | keyof ILLMProviders;
+export declare const TLLMProvider: {
+    readonly Echo: "Echo";
+    readonly OpenAI: "OpenAI";
+    readonly DeepSeek: "DeepSeek";
+    readonly GoogleAI: "GoogleAI";
+    readonly Anthropic: "Anthropic";
+    readonly Groq: "Groq";
+    readonly TogetherAI: "TogetherAI";
+    readonly Bedrock: "Bedrock";
+    readonly VertexAI: "VertexAI";
+    readonly xAI: "xAI";
+    readonly Perplexity: "Perplexity";
+};
+export type TBedrockSettings = {
+    keyIDName: string;
+    secretKeyName: string;
+    sessionKeyName: string;
+};
+export type TVertexAISettings = {
+    projectId: string;
+    credentialsName: string;
+    jsonCredentialsName: string;
+};
+export type TCustomLLMModel = TLLMModel & {
+    name: string;
+    settings: {
+        foundationModel: string;
+        customModel: string;
+        region: string;
+    } & (TBedrockSettings | TVertexAISettings);
+};
+export type ToolData = {
+    index: number;
+    id: string;
+    type: string;
+    name: string;
+    arguments: string | Record<string, any>;
+    role: 'user' | 'tool' | 'assistant';
+    result?: string;
+    function?: any;
+    error?: string;
+};
+export interface AnthropicToolDefinition {
+    name: string;
+    description: string;
+    input_schema: {
+        type: 'object';
+        properties: Record<string, unknown>;
+        required: string[];
+    };
+}
+export type ToolDefinition = OpenAI.ChatCompletionTool | AnthropicToolDefinition;
+export type ToolChoice = OpenAI.ChatCompletionToolChoiceOption | FunctionCallingMode;
+export interface ToolsConfig {
+    tools?: ToolDefinition[];
+    tool_choice?: ToolChoice;
+}
+export declare enum TLLMMessageRole {
+    User = "user",
+    Assistant = "assistant",
+    System = "system",
+    Model = "model",
+    Tool = "tool",
+    Function = "function"
+}
+export type TLLMMessageBlock = {
+    role: TLLMMessageRole;
+    content?: string | {
+        text: string;
+    }[] | 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;
+            };
+        };
+    }[];
+    tool_calls?: ToolData[];
+};
+export type TLLMToolResultMessageBlock = TLLMMessageBlock & {
+    tool_call_id?: string;
+    name?: string;
+};
+export type GenerateImageConfig = {
+    size?: '256x256' | '512x512' | '1024x1024' | '1792x1024' | '1024x1792';
+    quality?: 'standard' | 'hd';
+    model: string;
+    style?: 'vivid' | 'natural';
+    n?: number;
+    response_format?: 'url' | 'b64_json';
+    prompt?: string;
+};
+export type TLLMInputMessage = {
+    role: string;
+    content?: string | {
+        text: string;
+    }[];
+    parts?: {
+        text: string;
+    }[];
+};
+export interface ILLMContextStore {
+    save(messages: any[]): Promise<void>;
+    load(count?: number): Promise<any[]>;
+    getMessage(message_id: string): Promise<any[]>;
+}
+export declare enum APIKeySource {
+    Smyth = "smyth-managed",
+    User = "user-managed",
+    Custom = "custom"
+}
+export interface SmythLLMUsage {
+    sourceId: string;
+    input_tokens: number;
+    input_tokens_cache_write: number;
+    input_tokens_cache_read: number;
+    output_tokens: number;
+    keySource?: APIKeySource;
+    agentId: string;
+    teamId: string;
+    tier?: string;
+}
+export interface SmythTaskUsage {
+    sourceId: string;
+    number: number;
+    agentId: string;
+    teamId: string;
+}
+export type TLLMModelsList = {
+    [key: string]: TLLMModel | TCustomLLMModel;
+};
+export declare enum TLLMEvent {
+    /** Generated response chunks */
+    Content = "content",
+    /** Thinking blocks/chunks */
+    Thinking = "thinking",
+    /** End of the response */
+    End = "end",
+    /** Error */
+    Error = "error",
+    /** Tool information : emitted by the LLM determines the next tool call */
+    ToolInfo = "toolInfo",
+    /** Tool call : emitted before the tool call */
+    ToolCall = "toolCall",
+    /** Tool result : emitted after the tool call */
+    ToolResult = "toolResult",
+    /** Tokens usage information */
+    Usage = "usage",
+    /** Interrupted : emitted when the response is interrupted before completion */
+    Interrupted = "interrupted"
+}
+export interface ILLMRequestContext {
+    modelEntryName: string;
+    agentId: string;
+    teamId: string;
+    isUserKey: boolean;
+    hasFiles?: boolean;
+    modelInfo: TCustomLLMModel | TLLMModel;
+    credentials: ILLMConnectorCredentials;
+}
+export interface ILLMRequestFuncParams<TBody = any> {
+    acRequest: AccessRequest;
+    body: TBody;
+    context: ILLMRequestContext;
+}
+export type TLLMChatResponse = {
+    content: string;
+    finishReason: string;
+    thinkingContent?: string;
+    usage?: any;
+    useTool?: boolean;
+    toolsData?: ToolData[];
+    message?: OpenAI.ChatCompletionMessageParam | Anthropic.MessageParam;
+};
+export type TOpenAIRequestBody = OpenAI.ChatCompletionCreateParamsNonStreaming | OpenAI.ChatCompletionCreateParamsStreaming | OpenAI.ChatCompletionCreateParams | OpenAI.Responses.ResponseCreateParams | OpenAI.Responses.ResponseCreateParamsNonStreaming | OpenAI.Responses.ResponseCreateParamsStreaming | OpenAI.Images.ImageGenerateParams | OpenAI.Images.ImageEditParams;
+export type TAnthropicRequestBody = Anthropic.MessageCreateParamsNonStreaming;
+export type TGoogleAIRequestBody = ModelParams & {
+    messages: string | TLLMMessageBlock[] | GenerateContentRequest;
+};
+export type TLLMRequestBody = TOpenAIRequestBody | TAnthropicRequestBody | TGoogleAIRequestBody | ConverseCommandInput;

package/dist/types/types/Redis.types.d.ts

@@ -0,0 +1,6 @@
+export type RedisConfig = {
+    name: string;
+    password: string;
+    hosts: string | string[] | any[];
+    prefix?: string;
+};