@smythos/sre 1.7.20 → 1.7.41

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

@@ -1,5 +1,6 @@
 import EventEmitter from 'events';
 import Anthropic from '@anthropic-ai/sdk';
+import type { MessageStreamEvents } from '@anthropic-ai/sdk/lib/MessageStream';
 
 import { JSON_RESPONSE_INSTRUCTION, BUILT_IN_MODEL_PREFIX } from '@sre/constants';
 import { BinaryInput } from '@sre/helpers/BinaryInput.helper';
@@ -35,6 +36,26 @@ const LEGACY_THINKING_MODELS = ['smythos/claude-3.7-sonnet-thinking', 'claude-3.
 
 // Type aliases
 type AnthropicMessageParams = Anthropic.MessageCreateParamsNonStreaming | Anthropic.Messages.MessageStreamParams;
+type AnthropicStreamEventType = keyof MessageStreamEvents;
+
+// Event names automatically validated against MessageStreamEvents type
+// TypeScript will error if any events are missing or incorrect
+// This ensures we always use the correct event names as defined by Anthropic SDK
+const AnthropicStreamEvent = {
+    connect: 'connect',
+    streamEvent: 'streamEvent',
+    text: 'text',
+    citation: 'citation',
+    inputJson: 'inputJson',
+    thinking: 'thinking',
+    signature: 'signature',
+    message: 'message',
+    contentBlock: 'contentBlock',
+    finalMessage: 'finalMessage',
+    error: 'error',
+    abort: 'abort',
+    end: 'end',
+} satisfies Record<keyof MessageStreamEvents, AnthropicStreamEventType>;
 
 // TODO [Forhad]: implement proper typing
 
@@ -132,34 +153,38 @@ export class AnthropicConnector extends LLMConnector {
             const needsPrefillInjection = this.hasPrefillText(body.messages);
             let prefillInjected = false;
 
-            stream.on('streamEvent', (event: any) => {
+            stream.on(AnthropicStreamEvent.streamEvent, (event: any) => {
                 if (event.message?.usage) {
                     //console.log('usage', event.message?.usage);
                 }
             });
 
-            stream.on('error', (error) => {
+            stream.on(AnthropicStreamEvent.error, (error) => {
                 //console.log('error', error);
 
-                emitter.emit('error', error);
+                emitter.emit(TLLMEvent.Error, error);
             });
 
-            stream.on('text', (text: string) => {
+            stream.on(AnthropicStreamEvent.message, (message) => {
+                emitter.emit(TLLMEvent.Data, message);
+            });
+
+            stream.on(AnthropicStreamEvent.text, (text: string) => {
                 // Inject prefill text only once at the very beginning if needed
                 if (needsPrefillInjection && !prefillInjected) {
                     text = `${PREFILL_TEXT_FOR_JSON_RESPONSE}${text}`;
                     prefillInjected = true;
                 }
 
-                emitter.emit('content', text);
+                emitter.emit(TLLMEvent.Content, text);
             });
 
-            stream.on('thinking', (thinking) => {
+            stream.on(AnthropicStreamEvent.thinking, (thinking) => {
                 // Handle thinking blocks during streaming
-                emitter.emit('thinking', thinking);
+                emitter.emit(TLLMEvent.Thinking, thinking);
             });
 
-            stream.on('finalMessage', (finalMessage) => {
+            stream.on(AnthropicStreamEvent.finalMessage, (finalMessage) => {
                 let finishReason = 'stop';
                 // Preserve thinking blocks for subsequent tool interactions
                 thinkingBlocks = finalMessage.content.filter((block) => block.type === 'thinking' || block.type === 'redacted_thinking');
@@ -197,12 +222,12 @@ export class AnthropicConnector extends LLMConnector {
                     usage_data.push(reportedUsage);
                 }
                 if (finishReason !== 'stop' && finishReason !== 'end_turn') {
-                    emitter.emit('interrupted', finishReason);
+                    emitter.emit(TLLMEvent.Interrupted, finishReason);
                 }
 
                 //only emit end event after processing the final message
                 setTimeout(() => {
-                    emitter.emit('end', toolsData, usage_data, finishReason);
+                    emitter.emit(TLLMEvent.End, toolsData, usage_data, finishReason);
                 }, 100);
             });
 

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

@@ -126,14 +126,14 @@ export class BedrockConnector extends LLMConnector {
                         // Handle message start
                         if (chunk.messageStart) {
                             currentMessage.role = chunk.messageStart.role || '';
-                            emitter.emit('data', { role: currentMessage.role });
+                            emitter.emit(TLLMEvent.Data, { role: currentMessage.role });
                         }
 
                         // Handle content deltas
                         if (chunk.contentBlockDelta?.delta?.text) {
                             currentMessage.content += chunk.contentBlockDelta.delta.text;
-                            emitter.emit('data', chunk.contentBlockDelta.delta.text);
-                            emitter.emit('content', chunk.contentBlockDelta.delta.text, currentMessage.role);
+                            emitter.emit(TLLMEvent.Data, chunk.contentBlockDelta.delta.text);
+                            emitter.emit(TLLMEvent.Content, chunk.contentBlockDelta.delta.text, currentMessage.role);
                         }
 
                         // Handle tool use start
@@ -175,10 +175,18 @@ export class BedrockConnector extends LLMConnector {
 
                         // Handle message completion
                         if (chunk.messageStop) {
+                            const finishReason = chunk.messageStop.stopReason || 'stop';
+
                             if (currentMessage.toolCalls.length > 0) {
                                 emitter.emit(TLLMEvent.ToolInfo, currentMessage.toolCalls);
                             }
-                            emitter.emit(TLLMEvent.End, currentMessage.toolCalls);
+
+                            // Emit interrupted event if finishReason is not 'stop'
+                            if (finishReason !== 'stop' && finishReason !== 'end_turn') {
+                                emitter.emit(TLLMEvent.Interrupted, finishReason);
+                            }
+
+                            emitter.emit(TLLMEvent.End, currentMessage.toolCalls, [], finishReason);
                         }
 
                         if (chunk?.metadata?.usage) {

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

@@ -1,7 +1,7 @@
 import { JSONContent } from '@sre/helpers/JsonContent.helper';
 import { LLMConnector } from '../LLMConnector';
 import EventEmitter from 'events';
-import { APIKeySource, ILLMRequestFuncParams, TLLMChatResponse, TLLMPreparedParams } from '@sre/types/LLM.types';
+import { APIKeySource, ILLMRequestFuncParams, TLLMChatResponse, TLLMEvent, TLLMPreparedParams } from '@sre/types/LLM.types';
 import { Logger } from '@sre/helpers/Log.helper';
 import { delay } from '@sre/utils/index';
 import { hookAsync } from '@sre/Core/HookService';
@@ -54,13 +54,13 @@ export class EchoConnector extends LLMConnector {
                     const isLastChunk = i === chunks.length - 1;
                     // Add space between chunks except for the last one to avoid trailing space in file URLs
                     const delta = { content: chunks[i] + (isLastChunk ? '' : ' ') };
-                    emitter.emit('data', delta);
-                    emitter.emit('content', delta.content);
+                    emitter.emit(TLLMEvent.Data, delta);
+                    emitter.emit(TLLMEvent.Content, delta.content);
                 }
 
                 // Emit end event after all chunks are processed
                 setTimeout(() => {
-                    emitter.emit('end', [], []); // Empty arrays for toolsData and usage_data
+                    emitter.emit(TLLMEvent.End, [], [], 'stop'); // Empty arrays for toolsData and usage_data, with finishReason
                 }, 100);
             })();