@smythos/sre 1.7.41 → 1.8.0

package/src/subsystems/LLMManager/LLM.service/connectors/Ollama.class.ts

@@ -15,6 +15,7 @@ import {
     TLLMToolResultMessageBlock,
     TLLMRequestBody,
     BasicCredentials,
+    TLLMFinishReason,
 } from '@sre/types/LLM.types';
 import { LLMHelper } from '@sre/LLMManager/LLM.helper';
 
@@ -42,7 +43,7 @@ type OllamaChatRequest = {
 export class OllamaConnector extends LLMConnector {
     public name = 'LLM:Ollama';
 
-    private getClient(context: ILLMRequestContext): Ollama {
+    private getClient(context: ILLMRequestContext, abortSignal?: AbortSignal): Ollama {
         // Extract baseURL and sanitize it for Ollama SDK
         let host = 'http://localhost:11434';
 
@@ -55,7 +56,7 @@ export class OllamaConnector extends LLMConnector {
             host = url.origin;
         }
 
-        const config: { host: string; headers?: { Authorization?: string } } = { host };
+        const config: { host: string; headers?: { Authorization?: string }; fetch?: typeof fetch } = { host };
 
         if (apiKey) {
             config.headers = {
@@ -63,15 +64,27 @@ export class OllamaConnector extends LLMConnector {
             };
         }
 
+        // Pass abortSignal through custom fetch function
+        // Best practice: Respect existing signal in init if present, otherwise use our abortSignal
+        if (abortSignal) {
+            config.fetch = (url: RequestInfo | URL, init?: RequestInit) => {
+                return fetch(url, {
+                    ...init,
+                    // Use abortSignal if no signal exists in init, otherwise respect the existing signal
+                    signal: init?.signal || abortSignal,
+                });
+            };
+        }
+
         // No API key validation required for Ollama (local by default)
         return new Ollama(config);
     }
 
     @hookAsync('LLMConnector.request')
-    protected async request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse> {
+    protected async request({ acRequest, body, context, abortSignal }: ILLMRequestFuncParams): Promise<TLLMChatResponse> {
         try {
             logger.debug(`request ${this.name}`, acRequest.candidate);
-            const ollama = this.getClient(context);
+            const ollama = this.getClient(context, abortSignal);
 
             const result = (await ollama.chat({
                 ...body,
@@ -79,7 +92,7 @@ export class OllamaConnector extends LLMConnector {
             })) as unknown as ChatResponse;
 
             const message = result.message;
-            const finishReason = result.done_reason || 'stop';
+            const finishReason = LLMHelper.normalizeFinishReason(result.done_reason || TLLMFinishReason.Stop);
             const usage = {
                 prompt_tokens: result.prompt_eval_count || 0,
                 completion_tokens: result.eval_count || 0,
@@ -117,112 +130,191 @@ export class OllamaConnector extends LLMConnector {
                 message: message as any,
                 usage,
             };
-        } catch (error) {
+        } catch (error: any) {
+            // Handle AbortError specifically - this is expected when abortSignal is triggered
+            if (error?.name === 'AbortError' || abortSignal?.aborted) {
+                logger.debug(`request ${this.name} aborted`, acRequest.candidate);
+                throw error;
+            }
             logger.error(`request ${this.name}`, error, acRequest.candidate);
             throw error;
         }
     }
 
+    /**
+     * 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.)
+     */
     @hookAsync('LLMConnector.streamRequest')
-    protected async streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter> {
+    protected async streamRequest({ acRequest, body, context, abortSignal }: ILLMRequestFuncParams): Promise<EventEmitter> {
+        const emitter = new EventEmitter();
+
         try {
             logger.debug(`streamRequest ${this.name}`, acRequest.candidate);
-            const emitter = new EventEmitter();
             const usage_data = [];
 
-            const ollama = this.getClient(context);
+            const ollama = this.getClient(context, abortSignal);
             const stream = (await ollama.chat({
                 ...body,
                 stream: true,
             })) as AsyncIterable<ChatResponse>;
 
+            if (abortSignal) {
+                abortSignal.addEventListener('abort', () => {
+                    // Abort the stream if it supports abort
+                    if (typeof (stream as any)?.abort === 'function') {
+                        (stream as any).abort();
+                    }
+                    // Emit abort event on the emitter for proper cleanup
+                    const abortError = new DOMException('Request aborted', 'AbortError');
+                    setImmediate(() => {
+                        emitter.emit(TLLMEvent.Abort, abortError);
+                        emitter.emit(TLLMEvent.End, [], [], TLLMFinishReason.Abort);
+                    });
+                });
+            }
+
             let toolsData: ToolData[] = [];
             let fullContent = '';
-            let finishReason = 'stop';
+            let finishReason: TLLMFinishReason = TLLMFinishReason.Stop;
 
             (async () => {
-                for await (const chunk of stream) {
-                    emitter.emit(TLLMEvent.Data, chunk);
-
-                    // Emit content deltas
-                    if (chunk.message?.content) {
-                        const content = chunk.message.content;
-                        fullContent += content;
-                        emitter.emit(TLLMEvent.Content, content);
-                    }
+                try {
+                    for await (const chunk of stream) {
+                        // Check if aborted before processing chunk
+                        if (abortSignal?.aborted) {
+                            break;
+                        }
+                        emitter.emit(TLLMEvent.Data, chunk);
 
-                    // Handle tool calls accumulation
-                    if (chunk.message?.tool_calls) {
-                        chunk.message.tool_calls.forEach((toolCall, index) => {
-                            if (!toolsData[index]) {
-                                toolsData[index] = {
-                                    index,
-                                    id: toolCall.function?.name || `tool_${index}`,
-                                    type: 'function',
-                                    name: toolCall.function?.name,
-                                    arguments: toolCall.function?.arguments || '',
-                                    role: 'assistant',
-                                };
-                            } else {
-                                // Merge arguments across chunks for string arguments
-                                if (typeof toolsData[index].arguments === 'string' && typeof toolCall.function?.arguments === 'string') {
-                                    toolsData[index].arguments += toolCall.function.arguments;
+                        // Emit content deltas
+                        if (chunk.message?.content) {
+                            const content = chunk.message.content;
+                            fullContent += content;
+                            emitter.emit(TLLMEvent.Content, content);
+                        }
+
+                        // Handle tool calls accumulation
+                        if (chunk.message?.tool_calls) {
+                            chunk.message.tool_calls.forEach((toolCall, index) => {
+                                if (!toolsData[index]) {
+                                    toolsData[index] = {
+                                        index,
+                                        id: toolCall.function?.name || `tool_${index}`,
+                                        type: 'function',
+                                        name: toolCall.function?.name,
+                                        arguments: toolCall.function?.arguments || '',
+                                        role: 'assistant',
+                                    };
                                 } else {
-                                    // For object arguments, merge them properly
-                                    toolsData[index].arguments = { ...(toolsData[index].arguments as any), ...toolCall.function?.arguments };
+                                    // Merge arguments across chunks for string arguments
+                                    if (typeof toolsData[index].arguments === 'string' && typeof toolCall.function?.arguments === 'string') {
+                                        toolsData[index].arguments += toolCall.function.arguments;
+                                    } else {
+                                        // For object arguments, merge them properly
+                                        toolsData[index].arguments = { ...(toolsData[index].arguments as any), ...toolCall.function?.arguments };
+                                    }
                                 }
-                            }
-                        });
-                    }
+                            });
+                        }
 
-                    // Capture usage data when available
-                    if (chunk.prompt_eval_count !== undefined || chunk.eval_count !== undefined) {
-                        const usage = {
-                            prompt_tokens: chunk.prompt_eval_count || 0,
-                            completion_tokens: chunk.eval_count || 0,
-                            total_tokens: (chunk.prompt_eval_count || 0) + (chunk.eval_count || 0),
-                        };
-                        usage_data.push(usage);
-                    }
+                        // Capture usage data when available
+                        if (chunk.prompt_eval_count !== undefined || chunk.eval_count !== undefined) {
+                            const usage = {
+                                prompt_tokens: chunk.prompt_eval_count || 0,
+                                completion_tokens: chunk.eval_count || 0,
+                                total_tokens: (chunk.prompt_eval_count || 0) + (chunk.eval_count || 0),
+                            };
+                            usage_data.push(usage);
+                        }
 
-                    // Capture finish reason from Ollama's done_reason
-                    if (chunk.done_reason) {
-                        finishReason = chunk.done_reason;
+                        // Capture finish reason from Ollama's done_reason
+                        if (chunk.done_reason) {
+                            finishReason = LLMHelper.normalizeFinishReason(chunk.done_reason);
+                        }
                     }
-                }
 
-                // Emit tool info if tools were requested
-                if (toolsData.length > 0) {
-                    emitter.emit(TLLMEvent.ToolInfo, toolsData);
-                }
+                    // Emit tool info if tools were requested
+                    if (toolsData.length > 0) {
+                        emitter.emit(TLLMEvent.ToolInfo, toolsData);
+                    }
 
-                // Report usage
-                const reportedUsage: any[] = [];
-                usage_data.forEach((usage) => {
-                    const reported = this.reportUsage(usage, {
-                        modelEntryName: context.modelEntryName,
-                        keySource: context.isUserKey ? APIKeySource.User : APIKeySource.Smyth,
-                        agentId: context.agentId,
-                        teamId: context.teamId,
+                    // Report usage
+                    const reportedUsage: any[] = [];
+                    usage_data.forEach((usage) => {
+                        const reported = this.reportUsage(usage, {
+                            modelEntryName: context.modelEntryName,
+                            keySource: context.isUserKey ? APIKeySource.User : APIKeySource.Smyth,
+                            agentId: context.agentId,
+                            teamId: context.teamId,
+                        });
+                        reportedUsage.push(reported);
                     });
-                    reportedUsage.push(reported);
-                });
 
-                // Emit interrupted event if finishReason is not 'stop'
-                if (finishReason !== 'stop') {
-                    emitter.emit(TLLMEvent.Interrupted, finishReason);
-                }
+                    // Emit interrupted event if finishReason is not 'stop'
+                    if (finishReason !== TLLMFinishReason.Stop) {
+                        emitter.emit(TLLMEvent.Interrupted, finishReason);
+                    }
 
-                // Final end event
-                setTimeout(() => {
-                    emitter.emit(TLLMEvent.End, toolsData, reportedUsage, finishReason);
-                }, 100);
+                    // Final end event
+                    setTimeout(() => {
+                        emitter.emit(TLLMEvent.End, toolsData, reportedUsage, finishReason);
+                    }, 100);
+                } catch (error: any) {
+                    // Handle AbortError specifically - this is expected when abortSignal is triggered
+                    if (error?.name === 'AbortError' || abortSignal?.aborted) {
+                        logger.debug(`streamRequest ${this.name} aborted`, acRequest.candidate);
+                        // Always use DOMException with name 'AbortError' per Web API standards for consistency
+                        const abortError = new DOMException('Request aborted', 'AbortError');
+                        setImmediate(() => {
+                            emitter.emit(TLLMEvent.Abort, abortError);
+                            emitter.emit(TLLMEvent.End, [], [], TLLMFinishReason.Abort);
+                        });
+                    } else {
+                        logger.error(`streamRequest ${this.name} error`, error, acRequest.candidate);
+                        setImmediate(() => {
+                            emitter.emit(TLLMEvent.Error, error);
+                            emitter.emit(TLLMEvent.End, [], [], TLLMFinishReason.Error);
+                        });
+                    }
+                }
             })();
 
             return emitter;
         } catch (error: any) {
+            // Handle AbortError specifically - this is expected when abortSignal is triggered
+            if (error?.name === 'AbortError' || abortSignal?.aborted) {
+                logger.debug(`streamRequest ${this.name} aborted`, acRequest.candidate);
+                // Always use DOMException with name 'AbortError' per Web API standards for consistency
+                const abortError = new DOMException('Request aborted', 'AbortError');
+                setImmediate(() => {
+                    emitter.emit(TLLMEvent.Abort, abortError);
+                    emitter.emit(TLLMEvent.End, [], [], TLLMFinishReason.Abort);
+                });
+                return emitter;
+            }
             logger.error(`streamRequest ${this.name}`, error, acRequest.candidate);
-            throw error;
+            setImmediate(() => {
+                emitter.emit(TLLMEvent.Error, error);
+                emitter.emit(TLLMEvent.End, [], [], TLLMFinishReason.Error);
+            });
+            return emitter;
         }
     }
 

package/src/subsystems/LLMManager/LLM.service/connectors/Perplexity.class.ts

@@ -15,6 +15,7 @@ import {
     ILLMRequestContext,
     TLLMPreparedParams,
     TLLMEvent,
+    TLLMFinishReason,
 } from '@sre/types/LLM.types';
 import { LLMHelper } from '@sre/LLMManager/LLM.helper';
 
@@ -61,14 +62,14 @@ export class PerplexityConnector extends LLMConnector {
     }
 
     @hookAsync('LLMConnector.request')
-    protected async request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse> {
+    protected async request({ acRequest, body, context, abortSignal }: ILLMRequestFuncParams): Promise<TLLMChatResponse> {
         try {
             logger.debug(`request ${this.name}`, acRequest.candidate);
             const perplexity = await this.getClient(context);
-            const response = await perplexity.post('/chat/completions', body);
+            const response = await perplexity.post('/chat/completions', body, { signal: abortSignal });
 
             const content = response?.data?.choices?.[0]?.message.content;
-            const finishReason = response?.data?.choices?.[0]?.finish_reason;
+            const finishReason = LLMHelper.normalizeFinishReason(response?.data?.choices?.[0]?.finish_reason);
             const usage = response?.data?.usage as any;
 
             this.reportUsage(usage, {
@@ -87,13 +88,15 @@ export class PerplexityConnector extends LLMConnector {
                 usage,
             };
         } catch (error) {
+            // set the actual error message from the response
+            error.message = error?.response?.data?.error?.message || error?.message || 'Unknown error';
             logger.error(`request ${this.name}`, error, acRequest.candidate);
             throw error;
         }
     }
 
     @hookAsync('LLMConnector.streamRequest')
-    protected async streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter> {
+    protected async streamRequest({ acRequest, body, context, abortSignal }: ILLMRequestFuncParams): Promise<EventEmitter> {
         //throw new Error('Multimodal request is not supported for Perplexity.');
         //fallback to chatRequest
         const emitter = new EventEmitter();
@@ -103,7 +106,7 @@ export class PerplexityConnector extends LLMConnector {
         setTimeout(() => {
             try {
                 logger.debug(`streamRequest ${this.name}`, acRequest.candidate);
-                this.request({ acRequest, body, context })
+                this.request({ acRequest, body, context, abortSignal })
                     .then((respose) => {
                         const finishReason = respose.finishReason;
                         const usage = respose.usage;
@@ -112,7 +115,7 @@ export class PerplexityConnector extends LLMConnector {
                         emitter.emit(TLLMEvent.Content, respose.content);
 
                         // Only emit Interrupted if finishReason is not 'stop'
-                        if (finishReason !== 'stop') {
+                        if (finishReason !== TLLMFinishReason.Stop) {
                             emitter.emit(TLLMEvent.Interrupted, finishReason);
                         }
 
@@ -158,8 +161,15 @@ export class PerplexityConnector extends LLMConnector {
         if (params?.temperature !== undefined) body.temperature = params.temperature;
         if (params?.topP !== undefined) body.top_p = params.topP;
         if (params?.topK !== undefined) body.top_k = params.topK;
-        if (params?.frequencyPenalty) body.frequency_penalty = params.frequencyPenalty;
-        if (params?.presencePenalty !== undefined) body.presence_penalty = params.presencePenalty;
+
+        // Perplexity API does not allow both presence_penalty and frequency_penalty to be set simultaneously.
+        // A value of 0 means no penalty (same as default), so we only include these parameters when they have a non-zero value.
+        // Apply either frequencyPenalty or presencePenalty, prioritizing frequencyPenalty
+        if (params?.frequencyPenalty) {
+            body.frequency_penalty = params.frequencyPenalty;
+        } else if (params?.presencePenalty) {
+            body.presence_penalty = params.presencePenalty;
+        }
 
         if (params.responseFormat) {
             body.response_format = params.responseFormat;

package/src/subsystems/LLMManager/LLM.service/connectors/VertexAI.class.ts

@@ -16,6 +16,7 @@ import {
     TLLMMessageRole,
     TLLMChatResponse,
     TLLMEvent,
+    TLLMFinishReason,
 } from '@sre/types/LLM.types';
 import { LLMHelper } from '@sre/LLMManager/LLM.helper';
 import { BinaryInput } from '@sre/helpers/BinaryInput.helper';
@@ -69,7 +70,7 @@ export class VertexAIConnector extends LLMConnector {
             const response = await result.response;
 
             const content = response.candidates?.[0]?.content?.parts?.[0]?.text || '';
-            const finishReason = response.candidates?.[0]?.finishReason || 'stop';
+            const finishReason = LLMHelper.normalizeFinishReason(response.candidates?.[0]?.finishReason || 'stop');
             const usage = response.usageMetadata;
 
             let toolsData: ToolData[] = [];
@@ -175,9 +176,9 @@ export class VertexAIConnector extends LLMConnector {
                     usageData.push(reportedUsage);
                 }
 
-                const finishReason = (aggregatedResponse.candidates?.[0]?.finishReason || 'stop').toLowerCase();
+                const finishReason = LLMHelper.normalizeFinishReason(aggregatedResponse.candidates?.[0]?.finishReason || 'stop');
 
-                if (finishReason !== 'stop') {
+                if (finishReason !== TLLMFinishReason.Stop) {
                     emitter.emit(TLLMEvent.Interrupted, finishReason);
                 }
 
@@ -186,7 +187,10 @@ export class VertexAIConnector extends LLMConnector {
                 }, 100);
             } catch (error) {
                 logger.error(`streamRequest ${this.name}`, error, acRequest.candidate);
-                emitter.emit(TLLMEvent.Error, error);
+                setImmediate(() => {
+                    emitter.emit(TLLMEvent.Error, error);
+                    emitter.emit(TLLMEvent.End, [], [], TLLMFinishReason.Error);
+                });
             }
         }, 100);
 

package/src/subsystems/LLMManager/LLM.service/connectors/openai/OpenAIConnector.class.ts

@@ -20,6 +20,8 @@ import {
     TLLMToolResultMessageBlock,
     ToolData,
     TOpenAIRequestBody,
+    TLLMEvent,
+    TLLMFinishReason,
 } from '@sre/types/LLM.types';
 
 import { ConnectorService } from '@sre/Core/ConnectorsService';
@@ -85,7 +87,7 @@ export class OpenAIConnector extends LLMConnector {
     }
 
     @hookAsync('LLMConnector.request')
-    protected async request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse> {
+    protected async request({ acRequest, body, context, abortSignal }: ILLMRequestFuncParams): Promise<TLLMChatResponse> {
         try {
             logger.debug(`request ${this.name}`, acRequest.candidate);
             const _body = body as OpenAI.ChatCompletionCreateParams;
@@ -107,15 +109,15 @@ export class OpenAIConnector extends LLMConnector {
             const responseInterface = this.getInterfaceType(context);
             const apiInterface = this.getApiInterface(responseInterface, context);
 
-            const result = await apiInterface.createRequest(body, context);
+            const result = await apiInterface.createRequest(body, context, abortSignal);
 
             const message = result?.choices?.[0]?.message || { content: result?.output_text };
-            const finishReason = result?.choices?.[0]?.finish_reason || result?.incomplete_details || 'stop';
+            const finishReason = LLMHelper.normalizeFinishReason(result?.choices?.[0]?.finish_reason || result?.incomplete_details || TLLMFinishReason.Stop);
 
             let toolsData: ToolData[] = [];
             let useTool = false;
 
-            if (finishReason === 'tool_calls') {
+            if (finishReason === TLLMFinishReason.ToolCalls) {
                 toolsData =
                     message?.tool_calls?.map((tool, index) => ({
                         index,
@@ -151,8 +153,30 @@ export class OpenAIConnector extends LLMConnector {
         }
     }
 
+    /**
+     * 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.)
+     */
     @hookAsync('LLMConnector.streamRequest')
-    protected async streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter> {
+    protected async streamRequest({ acRequest, body, context, abortSignal }: ILLMRequestFuncParams): Promise<EventEmitter> {
+        let emitter: EventEmitter = new EventEmitter();
+
         try {
             logger.debug(`streamRequest ${this.name}`, acRequest.candidate);
 
@@ -173,14 +197,32 @@ export class OpenAIConnector extends LLMConnector {
             const responseInterface = this.getInterfaceType(context);
             const apiInterface = this.getApiInterface(responseInterface, context);
 
-            const stream = await apiInterface.createStream(body, context);
+            const stream = await apiInterface.createStream(body, context, abortSignal);
 
-            const emitter = apiInterface.handleStream(stream, context);
+            emitter = apiInterface.handleStream(stream, context);
 
             return emitter;
         } catch (error) {
+            const isAbort = (error as any)?.name === 'AbortError' || abortSignal?.aborted;
+
+            if (isAbort) {
+                // Always use DOMException with name 'AbortError' per Web API standards for consistency
+                const abortError = new DOMException('Request aborted', 'AbortError');
+                logger.debug(`streamRequest ${this.name} aborted`, abortError, acRequest.candidate);
+                setImmediate(() => {
+                    emitter.emit(TLLMEvent.Abort, abortError);
+                    emitter.emit(TLLMEvent.End, [], [], TLLMFinishReason.Abort);
+                });
+                return emitter;
+            }
+
             logger.error(`streamRequest ${this.name}`, error, acRequest.candidate);
-            throw error;
+            setImmediate(() => {
+                emitter.emit(TLLMEvent.Error, error);
+                emitter.emit(TLLMEvent.End, [], [], TLLMFinishReason.Error);
+            });
+            
+            return emitter;
         }
     }
 

package/src/subsystems/LLMManager/LLM.service/connectors/openai/apiInterfaces/ChatCompletionsApiInterface.ts

@@ -2,7 +2,8 @@ import EventEmitter from 'events';
 import OpenAI from 'openai';
 import { BinaryInput } from '@sre/helpers/BinaryInput.helper';
 import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
-import { TLLMParams, TLLMPreparedParams, ILLMRequestContext, ToolData, TLLMMessageRole, APIKeySource, TLLMEvent } from '@sre/types/LLM.types';
+import { TLLMParams, TLLMPreparedParams, ILLMRequestContext, ToolData, TLLMMessageRole, APIKeySource, TLLMEvent, TLLMFinishReason } from '@sre/types/LLM.types';
+import { LLMHelper } from '@sre/LLMManager/LLM.helper';
 import { OpenAIApiInterface, ToolConfig } from './OpenAIApiInterface';
 import { HandlerDependencies } from '../types';
 import { JSON_RESPONSE_INSTRUCTION, SUPPORTED_MIME_TYPES_MAP, BUILT_IN_MODEL_PREFIX } from '@sre/constants';
@@ -32,24 +33,35 @@ export class ChatCompletionsApiInterface extends OpenAIApiInterface {
         this.deps = deps;
     }
 
-    public async createRequest(body: OpenAI.ChatCompletionCreateParams, context: ILLMRequestContext): Promise<OpenAI.ChatCompletion> {
+    public async createRequest(
+        body: OpenAI.ChatCompletionCreateParams,
+        context: ILLMRequestContext,
+        abortSignal?: AbortSignal
+    ): Promise<OpenAI.ChatCompletion> {
         const openai = await this.deps.getClient(context);
-        return await openai.chat.completions.create({
-            ...body,
-            stream: false,
-        });
+        return await openai.chat.completions.create(
+            {
+                ...body,
+                stream: false,
+            },
+            { signal: abortSignal }
+        );
     }
 
     public async createStream(
         body: OpenAI.ChatCompletionCreateParams,
-        context: ILLMRequestContext
+        context: ILLMRequestContext,
+        abortSignal?: AbortSignal
     ): Promise<AsyncIterable<OpenAI.ChatCompletionChunk>> {
         const openai = await this.deps.getClient(context);
-        return await openai.chat.completions.create({
-            ...body,
-            stream: true,
-            stream_options: { include_usage: true },
-        });
+        return await openai.chat.completions.create(
+            {
+                ...body,
+                stream: true,
+                stream_options: { include_usage: true },
+            },
+            { signal: abortSignal }
+        );
     }
 
     public handleStream(stream: AsyncIterable<OpenAI.ChatCompletionChunk>, context: ILLMRequestContext): EventEmitter {
@@ -342,20 +354,22 @@ export class ChatCompletionsApiInterface extends OpenAIApiInterface {
     /**
      * Emit final events
      */
-    private emitFinalEvents(emitter: EventEmitter, toolsData: ToolData[], reportedUsage: any[], finishReason: string): void {
+    private emitFinalEvents(emitter: EventEmitter, toolsData: ToolData[], reportedUsage: any[], finishReason: string | TLLMFinishReason): void {
+        const normalizedFinishReason = typeof finishReason === 'string' ? LLMHelper.normalizeFinishReason(finishReason) : finishReason;
+        
         // Emit tool info event if tools were called
         if (toolsData.length > 0) {
             emitter.emit(TLLMEvent.ToolInfo, toolsData);
         }
 
         // Emit interrupted event if finishReason is not 'stop'
-        if (finishReason !== 'stop') {
-            emitter.emit(TLLMEvent.Interrupted, finishReason);
+        if (normalizedFinishReason !== TLLMFinishReason.Stop) {
+            emitter.emit(TLLMEvent.Interrupted, normalizedFinishReason);
         }
 
         // Emit end event with setImmediate to ensure proper event ordering
         setImmediate(() => {
-            emitter.emit(TLLMEvent.End, toolsData, reportedUsage, finishReason);
+            emitter.emit(TLLMEvent.End, toolsData, reportedUsage, normalizedFinishReason);
         });
     }
 

package/src/subsystems/LLMManager/LLM.service/connectors/openai/apiInterfaces/OpenAIApiInterface.ts

@@ -33,14 +33,14 @@ export 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