@smythos/sre 1.7.42 → 1.8.1

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

@@ -1,17 +1,23 @@
 import { IAgent as Agent } from '@sre/types/Agent.types';
 import { Component } from './Component.class';
+interface AsyncResult {
+    JobID: string;
+    _debug?: string;
+    [key: string]: any;
+}
+interface AsyncErrorResult {
+    _error: string;
+    _debug: string;
+}
 export declare class Async extends Component {
     static JOBS: {};
     protected configSchema: any;
     static ForkedAgent: any;
     constructor();
     init(): void;
-    process(input: any, config: any, agent: Agent): Promise<{
-        JobID: any;
-    } | {
-        JobID?: undefined;
-    }>;
+    process(input: any, config: any, agent: Agent): Promise<AsyncResult | AsyncErrorResult>;
     private cleanJobIDBranch;
     private removeOrphanedBranches;
     private removeComponent;
 }
+export {};

package/dist/types/index.d.ts

@@ -161,6 +161,7 @@ export * from './subsystems/Security/Vault.service/VaultConnector';
 export * from './subsystems/AgentManager/AgentData.service/connectors/CLIAgentDataConnector.class';
 export * from './subsystems/AgentManager/AgentData.service/connectors/LocalAgentDataConnector.class';
 export * from './subsystems/AgentManager/AgentData.service/connectors/NullAgentData.class';
+export * from './subsystems/AgentManager/AgentData.service/connectors/SQLiteAgentDataConnector.class';
 export * from './subsystems/AgentManager/Component.service/connectors/LocalComponentConnector.class';
 export * from './subsystems/AgentManager/Scheduler.service/connectors/LocalScheduler.class';
 export * from './subsystems/ComputeManager/Code.service/connectors/AWSLambdaCode.class';
@@ -205,6 +206,7 @@ export * from './subsystems/Security/Vault.service/connectors/SecretsManager.cla
 export * from './subsystems/LLMManager/LLM.service/connectors/openai/OpenAIConnector.class';
 export * from './subsystems/LLMManager/LLM.service/connectors/openai/types';
 export * from './subsystems/ObservabilityManager/Telemetry.service/connectors/OTel/OTel.class';
+export * from './subsystems/ObservabilityManager/Telemetry.service/connectors/OTel/OTel.redaction.helper';
 export * from './subsystems/ObservabilityManager/Telemetry.service/connectors/OTel/OTelContextRegistry';
 export * from './subsystems/LLMManager/LLM.service/connectors/openai/apiInterfaces/constants';
 export * from './subsystems/LLMManager/LLM.service/connectors/openai/apiInterfaces/utils';

package/dist/types/subsystems/AgentManager/AgentData.service/connectors/SQLiteAgentDataConnector.class.d.ts

@@ -0,0 +1,45 @@
+import { AgentDataConnector } from '../AgentDataConnector';
+export type SQLiteAgentDataSettings = {
+    databasePath: string;
+    tableName?: string;
+};
+type SQLiteRunResult = {
+    changes?: number;
+    lastInsertRowid?: number | bigint;
+};
+export interface SQLiteStatementAdapter<T = any> {
+    all(...params: any[]): T[];
+    get(...params: any[]): T | undefined;
+    run(...params: any[]): SQLiteRunResult;
+}
+export interface SQLiteDatabaseAdapter {
+    prepare<T = any>(sql: string): SQLiteStatementAdapter<T>;
+    exec(sql: string): void;
+    close(): void;
+}
+export type SQLiteAdapterFactory = (databasePath: string) => SQLiteDatabaseAdapter;
+export declare class SQLiteAgentDataConnector extends AgentDataConnector {
+    protected _settings: SQLiteAgentDataSettings;
+    name: string;
+    private adapter;
+    private readonly tableName;
+    constructor(_settings: SQLiteAgentDataSettings);
+    getAgentConfig(agentId: string): Partial<SQLiteAgentDataSettings>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getAgentData(agentId: string, version?: string): Promise<{
+        data: any;
+        version: any;
+    }>;
+    getAgentIdByDomain(domain: string): Promise<string>;
+    getAgentSettings(agentId: string, version?: string): Promise<any>;
+    getAgentEmbodiments(agentId: string): Promise<any>;
+    listTeamAgents(teamId: string, deployedOnly?: boolean, includeData?: boolean): Promise<any[]>;
+    isDeployed(agentId: string): Promise<boolean>;
+    private ensureDatabaseDirectory;
+    private ensureSchema;
+    private validateTableName;
+    private prepareStatement;
+    private parseData;
+}
+export {};

package/dist/types/subsystems/LLMManager/LLM.helper.d.ts

@@ -1,4 +1,4 @@
-import { type TLLMMessageBlock } from '@sre/types/LLM.types';
+import { type TLLMMessageBlock, TLLMFinishReason } from '@sre/types/LLM.types';
 export declare class LLMHelper {
     /**
      * Checks if the given array of messages contains a system message.
@@ -152,4 +152,35 @@ export declare class LLMHelper {
      * console.log(isClaude4); // false
      */
     static isClaude4Family(modelId: string): boolean;
+    /**
+     * Normalizes provider-specific finish reason values to TLLMFinishReason enum.
+     * Handles provider-specific values from OpenAI, Anthropic, Google AI, and other providers.
+     *
+     * @param finishReason - The finish reason from the provider (can be string, null, or undefined)
+     * @returns Normalized TLLMFinishReason enum value
+     *
+     * @example
+     * const normalized = LLMHelper.normalizeFinishReason('end_turn');
+     * console.log(normalized); // TLLMFinishReason.Stop
+     *
+     * @example
+     * const normalized = LLMHelper.normalizeFinishReason('tool_use');
+     * console.log(normalized); // TLLMFinishReason.ToolCalls
+     *
+     * @example
+     * const normalized = LLMHelper.normalizeFinishReason('SAFETY');
+     * console.log(normalized); // TLLMFinishReason.ContentFilter
+     */
+    static normalizeFinishReason(finishReason: string | null | undefined): TLLMFinishReason;
+    /**
+     * Gets a user-friendly error message based on the finish reason.
+     *
+     * @param finishReason - The normalized finish reason enum value
+     * @returns User-friendly error message explaining why the response was interrupted
+     *
+     * @example
+     * const message = LLMHelper.getFinishReasonErrorMessage(TLLMFinishReason.Length);
+     * console.log(message); // "Empty response. This is usually due to output token limit reached..."
+     */
+    static getFinishReasonErrorMessage(finishReason: TLLMFinishReason): string;
 }

package/dist/types/subsystems/LLMManager/LLM.inference.d.ts

@@ -61,14 +61,37 @@ export declare class LLMInference {
     private getSafeFallbackParams;
     /**
      * Executes fallback logic for custom models when the primary model fails.
-     * This method checks if a fallback model is configured and invokes the appropriate LLM method.
+     * Checks if a fallback model is configured and switches to it.
      * Prevents infinite loops by passing a flag to indicate we're in a fallback attempt.
      *
+     * **Important**: This method should only be called for custom models (already verified by caller).
+     *
      * @param methodName - The name of the method being called ('prompt' or 'promptStream')
      * @param args - The original arguments passed to the method
-     * @returns The result from the fallback execution, or null if fallback should not be attempted
+     * @returns The result from the fallback execution, or null if no fallback is configured
      */
     private executeFallback;
+    /**
+     * Wraps an emitter with fallback capability using a proxy pattern.
+     * This creates a transparent proxy that forwards all events from the source emitter.
+     * On error, it attempts to switch to a fallback model and seamlessly redirects events.
+     *
+     * **Important**: This method is only called for custom models that have fallback configured.
+     * Regular models return their emitters directly without wrapping, so errors flow naturally.
+     *
+     * **Design Pattern**: Proxy/Decorator with listener-based event forwarding
+     * **Coupling**: Minimal - reads event types from TLLMEvent enum (single source of truth)
+     * **Reliability**: Uses listeners (not emit interception) to avoid timing issues with async emits
+     *
+     * Note: We use the TLLMEvent enum as the source of truth for all event types.
+     * This provides a good balance between decoupling and reliability. The enum already
+     * defines all possible LLM events, and connectors emit these standard events.
+     *
+     * @param sourceEmitter - The custom model's event emitter
+     * @param args - The original prompt arguments for fallback execution
+     * @returns A proxy emitter that transparently handles primary/fallback switching
+     */
+    private wrapWithFallback;
     imageGenRequest({ query, files, params }: TPromptParams): Promise<any>;
     imageEditRequest({ query, files, params }: TPromptParams): Promise<any>;
     streamRequest(params: any, agent: string | IAgent): Promise<any>;

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

@@ -6,8 +6,28 @@ export declare class AnthropicConnector extends LLMConnector {
     name: string;
     private validImageMimeTypes;
     private getClient;
-    protected request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
-    protected streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
+    protected request({ acRequest, body, context, abortSignal }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
+    /**
+     * Stream request implementation.
+     *
+     * **Error Handling Pattern:**
+     * - Always returns emitters, never throws errors - ensures consistent error handling
+     * - Uses setImmediate for event emission - prevents race conditions where events fire before listeners attach
+     * - Emits End after terminal events (Error, Abort) - ensures cleanup code always runs
+     *
+     * **Why setImmediate?**
+     * Since streamRequest is async, callers must await to get the emitter, creating a timing gap.
+     * setImmediate defers event emission to the next event loop tick, ensuring events fire AFTER
+     * listeners are attached. This prevents race conditions where synchronous event emission
+     * would occur before listeners can be registered.
+     *
+     * @param acRequest - Access request for authorization
+     * @param body - Request body parameters
+     * @param context - LLM request context
+     * @param abortSignal - AbortSignal for cancellation
+     * @returns EventEmitter that emits TLLMEvent events (Data, Content, Error, Abort, End, etc.)
+     */
+    protected streamRequest({ acRequest, body, context, abortSignal }: ILLMRequestFuncParams): Promise<EventEmitter>;
     protected reqBodyAdapter(params: TLLMPreparedParams): Promise<TAnthropicRequestBody>;
     protected reportUsage(usage: Anthropic.Messages.Usage & {
         cache_creation_input_tokens?: number;

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

@@ -5,8 +5,8 @@ import { LLMConnector } from '../LLMConnector';
 export declare class BedrockConnector extends LLMConnector {
     name: string;
     private getClient;
-    protected request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
-    protected streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
+    protected request({ acRequest, body, context, abortSignal }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
+    protected streamRequest({ acRequest, body, context, abortSignal }: ILLMRequestFuncParams): Promise<EventEmitter>;
     protected reqBodyAdapter(params: TLLMPreparedParams): Promise<ConverseCommandInput>;
     protected reportUsage(usage: TokenUsage & {
         cacheReadInputTokenCount: number;

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

@@ -10,8 +10,28 @@ export declare class GoogleAIConnector extends LLMConnector {
     name: string;
     private validMimeTypes;
     private getClient;
-    protected request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
-    protected streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
+    protected request({ acRequest, body, context, abortSignal }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
+    /**
+     * Stream request implementation.
+     *
+     * **Error Handling Pattern:**
+     * - Always returns emitters, never throws errors - ensures consistent error handling
+     * - Uses setImmediate for event emission - prevents race conditions where events fire before listeners attach
+     * - Emits End after terminal events (Error, Abort) - ensures cleanup code always runs
+     *
+     * **Why setImmediate?**
+     * Since streamRequest is async, callers must await to get the emitter, creating a timing gap.
+     * setImmediate defers event emission to the next event loop tick, ensuring events fire AFTER
+     * listeners are attached. This prevents race conditions where synchronous event emission
+     * would occur before listeners can be registered.
+     *
+     * @param acRequest - Access request for authorization
+     * @param body - Request body parameters
+     * @param context - LLM request context
+     * @param abortSignal - AbortSignal for cancellation
+     * @returns EventEmitter that emits TLLMEvent events (Data, Content, Error, Abort, End, etc.)
+     */
+    protected streamRequest({ acRequest, body, context, abortSignal }: ILLMRequestFuncParams): Promise<EventEmitter>;
     protected imageGenRequest({ body, context }: ILLMRequestFuncParams): Promise<any>;
     protected imageEditRequest({ body, context }: ILLMRequestFuncParams): Promise<any>;
     protected reqBodyAdapter(params: TLLMPreparedParams): Promise<TGoogleAIRequestBody>;
@@ -68,6 +88,11 @@ export declare class GoogleAIConnector extends LLMConnector {
         toolsData: ToolData[];
     }): TLLMToolResultMessageBlock[];
     getConsistentMessages(messages: TLLMMessageBlock[]): TLLMMessageBlock[];
+    /**
+     * Extracts text content from a message block, handling multiple formats (.parts, .content as string/array)
+     * This ensures compatibility with messages that have been normalized by getConsistentMessages or come in various formats
+     */
+    private extractMessageContent;
     private prepareMessages;
     private prepareMessagesWithFiles;
     private prepareMessagesWithTools;

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

@@ -18,8 +18,28 @@ type ChatCompletionCreateParams = {
 export declare class GroqConnector extends LLMConnector {
     name: string;
     private getClient;
-    protected request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
-    protected streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
+    protected request({ acRequest, body, context, abortSignal }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
+    /**
+     * Stream request implementation.
+     *
+     * **Error Handling Pattern:**
+     * - Always returns emitters, never throws errors - ensures consistent error handling
+     * - Uses setImmediate for event emission - prevents race conditions where events fire before listeners attach
+     * - Emits End after terminal events (Error, Abort) - ensures cleanup code always runs
+     *
+     * **Why setImmediate?**
+     * Since streamRequest is async, callers must await to get the emitter, creating a timing gap.
+     * setImmediate defers event emission to the next event loop tick, ensuring events fire AFTER
+     * listeners are attached. This prevents race conditions where synchronous event emission
+     * would occur before listeners can be registered.
+     *
+     * @param acRequest - Access request for authorization
+     * @param body - Request body parameters
+     * @param context - LLM request context
+     * @param abortSignal - AbortSignal for cancellation
+     * @returns EventEmitter that emits TLLMEvent events (Data, Content, Error, Abort, End, etc.)
+     */
+    protected streamRequest({ acRequest, body, context, abortSignal }: ILLMRequestFuncParams): Promise<EventEmitter>;
     protected reqBodyAdapter(params: TLLMPreparedParams): Promise<ChatCompletionCreateParams>;
     protected reportUsage(usage: Groq.Completions.CompletionUsage & {
         prompt_tokens_details?: {

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

@@ -4,8 +4,28 @@ import { LLMConnector } from '../LLMConnector';
 export declare class OllamaConnector extends LLMConnector {
     name: string;
     private getClient;
-    protected request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
-    protected streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
+    protected request({ acRequest, body, context, abortSignal }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
+    /**
+     * Stream request implementation.
+     *
+     * **Error Handling Pattern:**
+     * - Always returns emitters, never throws errors - ensures consistent error handling
+     * - Uses setImmediate for event emission - prevents race conditions where events fire before listeners attach
+     * - Emits End after terminal events (Error, Abort) - ensures cleanup code always runs
+     *
+     * **Why setImmediate?**
+     * Since streamRequest is async, callers must await to get the emitter, creating a timing gap.
+     * setImmediate defers event emission to the next event loop tick, ensuring events fire AFTER
+     * listeners are attached. This prevents race conditions where synchronous event emission
+     * would occur before listeners can be registered.
+     *
+     * @param acRequest - Access request for authorization
+     * @param body - Request body parameters
+     * @param context - LLM request context
+     * @param abortSignal - AbortSignal for cancellation
+     * @returns EventEmitter that emits TLLMEvent events (Data, Content, Error, Abort, End, etc.)
+     */
+    protected streamRequest({ acRequest, body, context, abortSignal }: ILLMRequestFuncParams): Promise<EventEmitter>;
     protected reqBodyAdapter(params: TLLMPreparedParams): Promise<TLLMRequestBody>;
     protected reportUsage(usage: {
         prompt_tokens: number;

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

@@ -26,8 +26,8 @@ type TUsage = {
 export declare class PerplexityConnector extends LLMConnector {
     name: string;
     private getClient;
-    protected request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
-    protected streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
+    protected request({ acRequest, body, context, abortSignal }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
+    protected streamRequest({ acRequest, body, context, abortSignal }: ILLMRequestFuncParams): Promise<EventEmitter>;
     protected reqBodyAdapter(params: TLLMPreparedParams): Promise<ChatCompletionParams>;
     protected reportUsage(usage: TUsage, metadata: {
         modelEntryName: string;
@@ -64,7 +64,7 @@ export declare class PerplexityConnector extends LLMConnector {
         role: TLLMMessageRole;
         content?: string | {
             text: string;
-        }[] | Array<import("@anthropic-ai/sdk/resources/messages").TextBlockParam | import("@anthropic-ai/sdk/resources/messages").ImageBlockParam | import("@anthropic-ai/sdk/resources/messages").ToolUseBlockParam | import("@anthropic-ai/sdk/resources/messages").ToolResultBlockParam>;
+        }[] | 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?: {

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

@@ -15,8 +15,28 @@ export declare class OpenAIConnector extends LLMConnector {
      */
     private getInterfaceType;
     protected getClient(context: ILLMRequestContext): Promise<OpenAI>;
-    protected request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
-    protected streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
+    protected request({ acRequest, body, context, abortSignal }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
+    /**
+     * Stream request implementation.
+     *
+     * **Error Handling Pattern:**
+     * - Always returns emitters, never throws errors - ensures consistent error handling
+     * - Uses setImmediate for event emission - prevents race conditions where events fire before listeners attach
+     * - Emits End after terminal events (Error, Abort) - ensures cleanup code always runs
+     *
+     * **Why setImmediate?**
+     * Since streamRequest is async, callers must await to get the emitter, creating a timing gap.
+     * setImmediate defers event emission to the next event loop tick, ensuring events fire AFTER
+     * listeners are attached. This prevents race conditions where synchronous event emission
+     * would occur before listeners can be registered.
+     *
+     * @param acRequest - Access request for authorization
+     * @param body - Request body parameters
+     * @param context - LLM request context
+     * @param abortSignal - AbortSignal for cancellation
+     * @returns EventEmitter that emits TLLMEvent events (Data, Content, Error, Abort, End, etc.)
+     */
+    protected streamRequest({ acRequest, body, context, abortSignal }: ILLMRequestFuncParams): Promise<EventEmitter>;
     protected imageGenRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<OpenAI.ImagesResponse>;
     protected imageEditRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<OpenAI.ImagesResponse>;
     formatToolsConfig({ type, toolDefinitions, toolChoice, modelInfo }: {
@@ -39,7 +59,7 @@ export declare class OpenAIConnector extends LLMConnector {
         role: TLLMMessageRole;
         content?: string | {
             text: string;
-        }[] | Array<import("@anthropic-ai/sdk/resources/messages").TextBlockParam | import("@anthropic-ai/sdk/resources/messages").ImageBlockParam | import("@anthropic-ai/sdk/resources/messages").ToolUseBlockParam | import("@anthropic-ai/sdk/resources/messages").ToolResultBlockParam>;
+        }[] | 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?: {

package/dist/types/subsystems/LLMManager/LLM.service/connectors/openai/apiInterfaces/ChatCompletionsApiInterface.d.ts

@@ -17,8 +17,8 @@ export declare class ChatCompletionsApiInterface extends OpenAIApiInterface {
     private validImageMimeTypes;
     private validDocumentMimeTypes;
     constructor(context: ILLMRequestContext, deps: HandlerDependencies);
-    createRequest(body: OpenAI.ChatCompletionCreateParams, context: ILLMRequestContext): Promise<OpenAI.ChatCompletion>;
-    createStream(body: OpenAI.ChatCompletionCreateParams, context: ILLMRequestContext): Promise<AsyncIterable<OpenAI.ChatCompletionChunk>>;
+    createRequest(body: OpenAI.ChatCompletionCreateParams, context: ILLMRequestContext, abortSignal?: AbortSignal): Promise<OpenAI.ChatCompletion>;
+    createStream(body: OpenAI.ChatCompletionCreateParams, context: ILLMRequestContext, abortSignal?: AbortSignal): Promise<AsyncIterable<OpenAI.ChatCompletionChunk>>;
     handleStream(stream: AsyncIterable<OpenAI.ChatCompletionChunk>, context: ILLMRequestContext): EventEmitter;
     prepareRequestBody(params: TLLMPreparedParams): Promise<OpenAI.ChatCompletionCreateParams>;
     /**

package/dist/types/subsystems/LLMManager/LLM.service/connectors/openai/apiInterfaces/OpenAIApiInterface.d.ts

@@ -27,13 +27,13 @@ export declare abstract class OpenAIApiInterface {
      * @param body - The request body prepared for this API
      * @param context - The request context
      */
-    abstract createRequest(body: any, context: ILLMRequestContext): Promise<any>;
+    abstract createRequest(body: any, context: ILLMRequestContext, abortSignal?: AbortSignal): Promise<any>;
     /**
      * Create a stream for this API interface
      * @param body - The request body prepared for this API
      * @param context - The request context
      */
-    abstract createStream(body: any, context: ILLMRequestContext): Promise<any>;
+    abstract createStream(body: any, context: ILLMRequestContext, abortSignal?: AbortSignal): Promise<any>;
     /**
      * Handle the stream response from this API interface
      * @param stream - The stream returned from createStream

package/dist/types/subsystems/LLMManager/LLM.service/connectors/openai/apiInterfaces/ResponsesApiInterface.d.ts

@@ -18,8 +18,8 @@ export declare class ResponsesApiInterface extends OpenAIApiInterface {
     private validImageMimeTypes;
     private validDocumentMimeTypes;
     constructor(context: ILLMRequestContext, deps: HandlerDependencies);
-    createRequest(body: OpenAI.Responses.ResponseCreateParams, context: ILLMRequestContext): Promise<OpenAI.Responses.Response>;
-    createStream(body: OpenAI.Responses.ResponseCreateParams, context: ILLMRequestContext): Promise<Stream<OpenAI.Responses.ResponseStreamEvent>>;
+    createRequest(body: OpenAI.Responses.ResponseCreateParams, context: ILLMRequestContext, abortSignal?: AbortSignal): Promise<OpenAI.Responses.Response>;
+    createStream(body: OpenAI.Responses.ResponseCreateParams, context: ILLMRequestContext, abortSignal?: AbortSignal): Promise<Stream<OpenAI.Responses.ResponseStreamEvent>>;
     handleStream(stream: Stream<OpenAI.Responses.ResponseStreamEvent>, context: ILLMRequestContext): EventEmitter;
     /**
      * Process the responses API stream format

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

@@ -61,8 +61,8 @@ type TUsage = {
 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 request({ acRequest, body, context, abortSignal }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
+    protected streamRequest({ acRequest, body, context, abortSignal }: ILLMRequestFuncParams): Promise<EventEmitter>;
     protected reqBodyAdapter(params: TLLMParams): Promise<ChatCompletionParams>;
     protected reportUsage(usage: TUsage, metadata: {
         modelEntryName: string;
@@ -99,7 +99,7 @@ export declare class xAIConnector extends LLMConnector {
         role: TLLMMessageRole;
         content?: string | {
             text: string;
-        }[] | Array<import("@anthropic-ai/sdk/resources/messages").TextBlockParam | import("@anthropic-ai/sdk/resources/messages").ImageBlockParam | import("@anthropic-ai/sdk/resources/messages").ToolUseBlockParam | import("@anthropic-ai/sdk/resources/messages").ToolResultBlockParam>;
+        }[] | 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?: {

package/dist/types/subsystems/MemoryManager/LLMContext.d.ts

@@ -5,6 +5,8 @@ export declare class LLMContext {
     private _systemPrompt;
     private _llmContextStore;
     private _llmCache;
+    /** Resolves when the context store has finished loading (if any). Safe to call before using addUserMessage, getContextWindow, or other context operations. */
+    private _readyPromise;
     get systemPrompt(): string;
     set systemPrompt(systemPrompt: string);
     get llmCache(): LLMCache;
@@ -17,9 +19,14 @@ export declare class LLMContext {
      * @param source a messages[] object, or smyth file system uri (smythfs://...)
      */
     constructor(llmInference: any, _systemPrompt?: string, llmContextStore?: ILLMContextStore);
+    /**
+     * Returns a promise that resolves when the context is ready (store loaded if present).
+     * Call before pushing or reading messages to avoid race conditions.
+     */
+    ready(): Promise<void>;
     private push;
-    addUserMessage(content: string, message_id: string, metadata?: any): void;
-    addAssistantMessage(content: string, message_id: string, metadata?: any): void;
-    addToolMessage(messageBlock: any, toolsData: any, message_id: string, metadata?: any): void;
+    addUserMessage(content: string, message_id: string, metadata?: any): Promise<void>;
+    addAssistantMessage(content: string, message_id: string, metadata?: any): Promise<void>;
+    addToolMessage(messageBlock: any, toolsData: any, message_id: string, metadata?: any): Promise<void>;
     getContextWindow(maxTokens: number, maxOutputTokens?: number): Promise<any[]>;
 }

package/dist/types/subsystems/ObservabilityManager/Telemetry.service/connectors/OTel/OTel.class.d.ts

@@ -29,6 +29,14 @@ export type OTelLogConfig = {
      * These will be replaced with '[REDACTED]' in logs
      */
     redactFields?: string[];
+    /**
+     * Enable automatic redaction of sensitive data in logs and traces.
+     * When true (or omitted), sensitive data such as passwords, tokens,
+     * API keys, and JWT tokens are automatically replaced with '[REDACTED]'.
+     * Set to false to disable all automatic redaction.
+     * Default: true
+     */
+    enableRedaction?: boolean;
 };
 export declare class OTel extends TelemetryConnector {
     protected _settings: OTelLogConfig;
@@ -47,6 +55,21 @@ export declare class OTel extends TelemetryConnector {
      * Redact sensitive fields from an object
      */
     private redactSensitiveData;
+    /**
+     * Redact sensitive patterns from a string value.
+     * Skips redaction when enableRedaction is explicitly set to false.
+     */
+    private redactString;
+    /**
+     * Redact sensitive data from any data type (objects, arrays, strings).
+     * Skips redaction when enableRedaction is explicitly set to false.
+     */
+    private redactObject;
+    /**
+     * Redact sensitive HTTP headers.
+     * Skips redaction when enableRedaction is explicitly set to false.
+     */
+    private redactRequestHeaders;
     /**
      * Safely format output for logging with size limits and redaction
      */
@@ -55,5 +78,6 @@ export declare class OTel extends TelemetryConnector {
     protected log(acRequest: AccessRequest, logData: AgentCallLog, callId?: string): Promise<any>;
     protected logTask(acRequest: AccessRequest, tasks: number, isUsingTestDomain: boolean): Promise<void>;
     private prepareComponentData;
+    private prepareContext;
     protected setupHooks(): Promise<void>;
 }

package/dist/types/subsystems/ObservabilityManager/Telemetry.service/connectors/OTel/OTel.redaction.helper.d.ts

@@ -0,0 +1,49 @@
+/**
+ * OTel Redaction Helper
+ *
+ * Provides sensitive data redaction functions for OpenTelemetry logs and traces.
+ * Adapted from Log.helper.ts redactLogMessage() function with enhancements for OTel.
+ *
+ * Key features:
+ * - JSON-aware redaction: handles "key":"value" patterns
+ * - Escaped JSON redaction: handles \"key\":\"value\" patterns in embedded strings
+ * - Truncated value support: handles preview strings without closing quotes
+ * - Key-based redaction: redacts values based on sensitive key names
+ * - JWT token redaction: full token redaction
+ * - Header redaction: full redaction for auth headers
+ */
+/**
+ * Sensitive words for content-based redaction
+ * Used to identify sensitive data in both key names and value content
+ */
+export declare const SENSITIVE_WORDS: string[];
+/**
+ * Sensitive header names that should have their values fully redacted
+ */
+export declare const SENSITIVE_HEADERS: string[];
+/**
+ * Redact sensitive data from a string value
+ * Applies multiple regex patterns to catch sensitive data in various formats.
+ *
+ * @param value - The string to redact
+ * @returns The redacted string with sensitive data replaced by [REDACTED]
+ */
+export declare function redactSensitiveString(value: string): string;
+/**
+ * Redact sensitive HTTP headers
+ * Full value redaction for known auth headers, string redaction for others.
+ *
+ * @param headers - The headers object or string to redact
+ * @returns The redacted headers with sensitive values replaced
+ */
+export declare function redactHeaders(headers: Record<string, unknown> | string | undefined | null): Record<string, unknown> | string | undefined | null;
+/**
+ * Universal data redaction - handles any data type
+ * Recursively applies redaction to strings within objects/arrays.
+ * Also checks key names against sensitive words and redacts entire values.
+ * Preserves the input type structure for OTel compatibility.
+ *
+ * @param data - The data to redact (any type)
+ * @returns The redacted data with the same type structure
+ */
+export declare function redactData<T>(data: T): T;

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

@@ -167,6 +167,8 @@ export type TLLMPreparedParams = TLLMParams & {
         imageEditing?: boolean;
     };
     toolsInfo?: TToolsInfo;
+    outputs?: any[];
+    structuredOutputs?: any[];
 };
 export type TLLMConnectorParams = Omit<TLLMParams, 'model'> & {
     model: string | TLLMModel | TCustomLLMModel;
@@ -455,6 +457,8 @@ export declare enum TLLMEvent {
     Thinking = "thinking",
     /** End of the response */
     End = "end",
+    /** Request aborted */
+    Abort = "abort",
     /** Error */
     Error = "error",
     /** Tool information : emitted by the LLM determines the next tool call */
@@ -486,10 +490,35 @@ export interface ILLMRequestFuncParams<TBody = any> {
     acRequest: AccessRequest;
     body: TBody;
     context: ILLMRequestContext;
+    abortSignal?: AbortSignal;
+}
+/**
+ * Standardized finish reasons for LLM responses across all providers.
+ *
+ * This enum normalizes provider-specific finish reasons (e.g., 'end_turn' from Anthropic,
+ * 'max_tokens' from Google AI) into a consistent set of values.
+ */
+export declare enum TLLMFinishReason {
+    /** Response completed normally (reached natural stopping point or stop sequence) */
+    Stop = "stop",
+    /** Response was truncated due to maximum token limit or context window */
+    Length = "length",
+    /** Response was truncated due to context window limit */
+    ContextWindowLength = "context_window_length",
+    /** Response was filtered by content moderation policies */
+    ContentFilter = "content_filter",
+    /** Response ended because the model called a tool/function */
+    ToolCalls = "tool_calls",
+    /** Request was aborted by user or system */
+    Abort = "abort",
+    /** Request ended due to an error */
+    Error = "error",
+    /** Unknown or unmapped finish reason from provider */
+    Unknown = "unknown"
 }
 export type TLLMChatResponse = {
     content: string;
-    finishReason: string;
+    finishReason: TLLMFinishReason;
     thinkingContent?: string;
     usage?: any;
     useTool?: boolean;