@smythos/sre 1.5.37 → 1.5.40

package/src/subsystems/ComputeManager/Code.service/connectors/ECMASandbox.class.ts

@@ -0,0 +1,131 @@
+import { IAccessCandidate, TAccessLevel } from '@sre/types/ACL.types';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { CodeConfig, CodePreparationResult, CodeConnector, CodeInput, CodeDeployment, CodeExecutionResult } from '../CodeConnector';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+import { Logger } from '@sre/helpers/Log.helper';
+import axios from 'axios';
+import { generateExecutableCode, runJs } from '@sre/helpers/ECMASandbox.helper';
+import { validateAsyncMainFunction } from '@sre/helpers/AWSLambdaCode.helper';
+
+const console = Logger('ECMASandbox');
+export class ECMASandbox extends CodeConnector {
+    public name = 'ECMASandbox';
+    private sandboxUrl: string;
+
+    constructor(config: { sandboxUrl: string }) {
+        super(config);
+        this.sandboxUrl = config.sandboxUrl;
+    }
+    public async prepare(acRequest: AccessRequest, codeUID: string, input: CodeInput, config: CodeConfig): Promise<CodePreparationResult> {
+        return {
+            prepared: true,
+            errors: [],
+            warnings: [],
+        };
+    }
+
+    public async deploy(acRequest: AccessRequest, codeUID: string, input: CodeInput, config: CodeConfig): Promise<CodeDeployment> {
+        return {
+            id: codeUID,
+            runtime: config.runtime,
+            createdAt: new Date(),
+            status: 'Deployed',
+        };
+    }
+
+    public async execute(acRequest: AccessRequest, codeUID: string, inputs: Record<string, any>, config: CodeConfig): Promise<CodeExecutionResult> {
+        try {
+            const { isValid, error, parameters } = validateAsyncMainFunction(inputs.code);
+            if (!isValid) {
+                return {
+                    output: undefined,
+                    executionTime: 0,
+                    success: false,
+                    errors: [error],
+                };
+            }
+            const executableCode = generateExecutableCode(inputs.code, parameters, inputs.inputs);
+            if (!this.sandboxUrl) {
+                //Temporarily disable the builtin ECMASandbox
+
+                // run js code in isolated vm
+
+                console.debug('Running code in isolated vm');
+                const executionStartTime = Date.now();
+                const result = await runJs(executableCode);
+                const executionTime = Date.now() - executionStartTime;
+                console.debug(`Code result: ${result}`);
+                return {
+                    output: result,
+                    executionTime,
+                    success: true,
+                    errors: [],
+
+                };
+            } else {
+                console.debug('Running code in remote sandbox');
+                const executionStartTime = Date.now();
+                const result: any = await axios.post(this.sandboxUrl, { code: executableCode }).catch((error) => ({ error }));
+                const executionTime = Date.now() - executionStartTime;
+                if (result.error) {
+                    const error = result.error?.response?.data || result.error?.message || result.error.toString() || 'Unknown error';
+                    console.error(`Error running code: ${JSON.stringify(error, null, 2)}`);
+                    return {
+                        output: undefined,
+                        executionTime,
+                        success: false,
+                        errors: [error],
+                    };
+                } else {
+                    console.debug(`Code result: ${result?.data?.Output}`);
+                    return {
+                        output: result.data?.Output,
+                        executionTime,
+                        success: true,
+                        errors: [],
+                    };
+                }
+            }
+        } catch (error) {
+            console.error(`Error running code: ${error}`);
+            return {
+                output: undefined,
+                executionTime: 0,
+                success: false,
+                errors: [error],
+            };
+        }
+    }
+    public async executeDeployment(
+        acRequest: AccessRequest,
+        codeUID: string,
+        deploymentId: string,
+        inputs: Record<string, any>,
+        config: CodeConfig
+    ): Promise<CodeExecutionResult> {
+        const result = await this.execute(acRequest, codeUID, inputs, config);
+        return result;
+    }
+
+    public async listDeployments(acRequest: AccessRequest, codeUID: string, config: CodeConfig): Promise<CodeDeployment[]> {
+        return [];
+    }
+
+    public async getDeployment(acRequest: AccessRequest, codeUID: string, deploymentId: string, config: CodeConfig): Promise<CodeDeployment | null> {
+        return null;
+    }
+
+    public async deleteDeployment(acRequest: AccessRequest, codeUID: string, deploymentId: string): Promise<void> {
+        return;
+    }
+
+    public async getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL> {
+        const acl = new ACL();
+
+        //give Read access everytime
+        //FIXME: !!!!!! IMPORTANT !!!!!!  this implementation have to be changed in order to reflect the security model of AWS Lambda
+        acl.addAccess(candidate.role, candidate.id, TAccessLevel.Read);
+
+        return acl;
+    }
+}

package/src/subsystems/ComputeManager/Code.service/index.ts

@@ -3,9 +3,11 @@
 import { ConnectorService, ConnectorServiceProvider } from '@sre/Core/ConnectorsService';
 import { TConnectorService } from '@sre/types/SRE.types';
 import { AWSLambdaCode } from './connectors/AWSLambdaCode.class';
+import { ECMASandbox } from './connectors/ECMASandbox.class';
 
 export class CodeService extends ConnectorServiceProvider {
     public register() {
         ConnectorService.register(TConnectorService.Code, 'AWSLambda', AWSLambdaCode);
+        ConnectorService.register(TConnectorService.Code, 'ECMASandbox', ECMASandbox);
     }
 }

package/src/subsystems/LLMManager/LLM.helper.ts

@@ -65,25 +65,36 @@ export class LLMHelper {
      * 2. Calculating tokens for each image in the prompt based on its dimensions.
      * 3. Summing up text and image tokens to get the total token count.
      *
+     * IMPORTANT: This returns the base token calculation for rate limiting and quota management.
+     * The actual tokens charged by OpenAI may differ significantly:
+     * - GPT-4o: Uses base calculation (matches this result)
+     * - GPT-4o-mini: Intentionally inflates image tokens by ~33x (e.g., 431 → 14,180 tokens)
+     * - GPT-4.1 series: Uses different patch-based calculations with various multipliers
+     *
+     * For consistent user limits regardless of model choice, use this base calculation.
+     * For billing estimates, refer to OpenAI's pricing calculator or API response.
+     *
+     * @see https://platform.openai.com/docs/guides/images-vision?api-mode=responses#calculating-costs
+     *
      * @example
      * const prompt = [
      *   { type: 'text', text: 'Describe this image:' },
      *   { type: 'image_url', image_url: { url: 'https://example.com/image.jpg' } }
      * ];
      * const tokenCount = await countVisionPromptTokens(prompt);
-     * console.log(tokenCount); // e.g., 150
+     * console.log(tokenCount); // e.g., 150 (base calculation for rate limiting)
      */
     public static async countVisionPromptTokens(prompt: any): Promise<number> {
         let tokens = 0;
 
-        const textObj = prompt?.filter((item) => item.type === 'text');
+        const textObj = prompt?.filter((item) => ['text', 'input_text'].includes(item.type));
         const textTokens = encode(textObj?.[0]?.text).length;
 
-        const images = prompt?.filter((item) => item.type === 'image_url');
+        const images = prompt?.filter((item) => ['image_url', 'input_image'].includes(item.type));
         let imageTokens = 0;
 
         for (const image of images) {
-            const imageUrl = image?.image_url?.url;
+            const imageUrl = image?.image_url?.url || image?.image_url; // image?.image_url?.url for 'chat.completions', image?.image_url for 'responses' interface
             const { width, height } = await this.getImageDimensions(imageUrl);
             const tokens = this.countImageTokens(width, height);
             imageTokens += tokens;
@@ -124,7 +135,7 @@ export class LLMHelper {
                 throw new Error('Please provide a valid image url!');
             }
 
-            const dimensions =  imageSize(buffer);
+            const dimensions = imageSize(buffer);
 
             return {
                 width: dimensions?.width || 0,
@@ -145,40 +156,59 @@ export class LLMHelper {
      * @returns {number} The number of tokens required to process the image.
      *
      * @description
-     * This method estimates the token count for image processing based on the image dimensions and detail mode.
-     * It uses a tiling approach to calculate the token count, scaling the image if necessary.
+     * This method calculates the token count for image processing based on OpenAI's official documentation:
      *
-     * - If detailMode is 'low', it returns a fixed token count of 85.
-     * - For other modes, it calculates based on the image dimensions:
-     *   - Scales down images larger than 2048 pixels in any dimension.
-     *   - Adjusts the scaled dimension to fit within a 768x1024 aspect ratio.
-     *   - Calculates the number of 512x512 tiles needed to cover the image.
-     *   - Returns the total token count based on the number of tiles.
+     * For 'low' detail mode: Returns 85 tokens regardless of image size.
+     *
+     * For 'high' detail mode (default):
+     * 1. Scale image to fit within 2048x2048 square (maintaining aspect ratio)
+     * 2. Scale image so shortest side is 768px (if both dimensions > 768px)
+     * 3. Calculate number of 512x512 tiles needed
+     * 4. Return 85 + (170 * number_of_tiles)
      *
      * @example
      * const tokenCount = countImageTokens(1024, 768);
      * console.log(tokenCount); // Outputs the calculated token count
      */
     public static countImageTokens(width: number, height: number, detailMode: string = 'auto'): number {
-        if (detailMode === 'low') return 85;
-
-        const maxDimension = Math.max(width, height);
-        const minDimension = Math.min(width, height);
-        let scaledMinDimension = minDimension;
-
-        if (maxDimension > 2048) {
-            scaledMinDimension = (2048 / maxDimension) * minDimension;
+        // For low detail mode, always return 85 tokens
+        if (detailMode === 'low') {
+            return 85;
         }
-        scaledMinDimension = Math.floor((768 / 1024) * scaledMinDimension);
 
-        let tileSize = 512;
-        let tiles = Math.ceil(scaledMinDimension / tileSize);
+        // Step 1: Scale to fit within 2048x2048 square (maintaining aspect ratio)
+        if (width > 2048 || height > 2048) {
+            const aspectRatio = width / height;
+            if (aspectRatio > 1) {
+                width = 2048;
+                height = Math.floor(2048 / aspectRatio);
+            } else {
+                height = 2048;
+                width = Math.floor(2048 * aspectRatio);
+            }
+        }
 
-        if (minDimension !== scaledMinDimension) {
-            tiles *= Math.ceil((scaledMinDimension * (maxDimension / minDimension)) / tileSize);
+        // Step 2: Scale such that shortest side is 768px (if both dimensions > 768px)
+        if (width > 768 && height > 768) {
+            const aspectRatio = width / height;
+            if (aspectRatio > 1) {
+                // height is shorter, scale to 768px
+                height = 768;
+                width = Math.floor(768 * aspectRatio);
+            } else {
+                // width is shorter, scale to 768px
+                width = 768;
+                height = Math.floor(768 / aspectRatio);
+            }
         }
 
-        return tiles * 170 + 85;
+        // Step 3: Calculate number of 512x512 tiles needed
+        const tilesWidth = Math.ceil(width / 512);
+        const tilesHeight = Math.ceil(height / 512);
+        const totalTiles = tilesWidth * tilesHeight;
+
+        // Step 4: Calculate total tokens (85 base + 170 per tile)
+        return 85 + 170 * totalTiles;
     }
 
     /**

package/src/subsystems/LLMManager/LLM.inference.ts

@@ -261,6 +261,10 @@ export class LLMInference {
             maxInputContext -= maxInputContext + maxOutputContext - maxModelContext;
         }
 
+        if (maxInputContext <= 0) {
+            console.warn('Max input context is 0, returning empty context window, This usually indicates a wrong model configuration');
+        }
+
         const systemMessage = { role: 'system', content: systemPrompt };
 
         let smythContextWindow = [];

package/src/subsystems/LLMManager/LLM.service/LLMConnector.ts

@@ -3,20 +3,20 @@ import { ConnectorService } from '@sre/Core/ConnectorsService';
 import { Logger } from '@sre/helpers/Log.helper';
 import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
 import { JSONContent } from '@sre/helpers/JsonContent.helper';
-import {
-    TLLMParams,
+import type {
     TLLMConnectorParams,
     TLLMMessageBlock,
     TLLMToolResultMessageBlock,
     ToolData,
     APIKeySource,
     TLLMModel,
-    TLLMCredentials,
-    TBedrockSettings,
-    TVertexAISettings,
     ILLMRequestFuncParams,
     TLLMChatResponse,
     TLLMRequestBody,
+    TOpenAIToolsInfo,
+    TxAIToolsInfo,
+    TLLMPreparedParams,
+    TToolsInfo,
 } from '@sre/types/LLM.types';
 import EventEmitter from 'events';
 import { Readable } from 'stream';
@@ -44,13 +44,10 @@ export interface ILLMConnectorRequest {
 
 export class LLMStream extends Readable {
     private dataQueue: any[];
-    private toolsData: any[];
-    private hasData: boolean;
     isReading: boolean;
     constructor(options?) {
         super(options);
         this.dataQueue = [];
-        this.toolsData = [];
         this.isReading = true;
     }
 
@@ -83,7 +80,6 @@ export abstract class LLMConnector extends Connector {
 
     protected abstract request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse>;
     protected abstract streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
-    protected abstract webSearchRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter>;
 
     protected abstract reqBodyAdapter(params: TLLMConnectorParams): Promise<TLLMRequestBody>;
     protected abstract reportUsage(usage: any, metadata: { modelEntryName: string; keySource: APIKeySource; agentId: string; teamId: string }): any;
@@ -111,6 +107,8 @@ export abstract class LLMConnector extends Connector {
             request: async (params: TLLMConnectorParams) => {
                 const preparedParams = await this.prepareParams(candidate, params);
 
+                const provider = preparedParams.modelInfo.provider;
+
                 const response = await this.request({
                     acRequest: candidate.readRequest,
                     body: preparedParams.body,
@@ -122,6 +120,9 @@ export abstract class LLMConnector extends Connector {
                         hasFiles: preparedParams.files?.length > 0,
                         modelInfo: preparedParams.modelInfo,
                         credentials: preparedParams.credentials,
+                        toolsInfo: {
+                            [provider]: preparedParams.toolsInfo[provider],
+                        } as TToolsInfo,
                     },
                 });
 
@@ -130,6 +131,8 @@ export abstract class LLMConnector extends Connector {
             streamRequest: async (params: TLLMConnectorParams) => {
                 const preparedParams = await this.prepareParams(candidate, params);
 
+                const provider = preparedParams.modelInfo.provider?.toLowerCase();
+
                 const requestParams = {
                     acRequest: candidate.readRequest,
                     body: preparedParams.body,
@@ -141,21 +144,13 @@ export abstract class LLMConnector extends Connector {
                         hasFiles: preparedParams.files?.length > 0,
                         modelInfo: preparedParams.modelInfo,
                         credentials: preparedParams.credentials,
+                        toolsInfo: {
+                            [provider]: preparedParams.toolsInfo[provider],
+                        } as TToolsInfo,
                     },
                 };
 
-                let response;
-
-                if (
-                    preparedParams.capabilities?.search === true &&
-                    preparedParams.useWebSearch === true &&
-                    preparedParams.modelInfo.provider === 'OpenAI'
-                ) {
-                    // ! webSearchRequest will be removed in next update
-                    response = await this.webSearchRequest(requestParams);
-                } else {
-                    response = await this.streamRequest(requestParams);
-                }
+                const response = await this.streamRequest(requestParams);
 
                 return response;
             },
@@ -244,7 +239,7 @@ export abstract class LLMConnector extends Connector {
             };
         }
     }
-    public formatToolsConfig({ type = 'function', toolDefinitions, toolChoice = 'auto' }) {
+    public formatToolsConfig({ type = 'function', toolDefinitions, toolChoice = 'auto', modelInfo = null }) {
         throw new Error('This model does not support tools');
     }
 
@@ -262,7 +257,7 @@ export abstract class LLMConnector extends Connector {
         return messages; // if a LLM connector does not implement this method, the messages will not be modified
     }
 
-    private async prepareParams(candidate: AccessCandidate, params: TLLMConnectorParams): Promise<TLLMConnectorParams & { body: any }> {
+    private async prepareParams(candidate: AccessCandidate, params: TLLMConnectorParams): Promise<TLLMPreparedParams> {
         const modelsProvider: ModelsProviderConnector = ConnectorService.getModelsProviderConnector();
         // Assign file from the original parameters to avoid overwriting the original constructor
         const files = params?.files;
@@ -271,7 +266,7 @@ export abstract class LLMConnector extends Connector {
         const clonedParams = JSON.parse(JSON.stringify(params)); // Avoid mutation of the original params
 
         // Format the parameters to ensure proper type of values
-        const _params: TLLMConnectorParams = this.formatParamValues(clonedParams);
+        const _params: TLLMPreparedParams = this.formatParamValues(clonedParams);
 
         const model = _params.model;
         const teamId = await this.getTeamId(candidate);
@@ -292,10 +287,6 @@ export abstract class LLMConnector extends Connector {
             }
         }
 
-        const isStandardLLM = await modelProviderCandidate.isStandardLLM(model);
-
-        const llmProvider = await modelProviderCandidate.getProvider(model);
-
         _params.credentials = await getLLMCredentials(candidate, modelInfo);
 
         //_params.model = (await modelProviderCandidate.getModelId(model)) || model;
@@ -324,6 +315,15 @@ export abstract class LLMConnector extends Connector {
             imageGeneration: features.includes('image-generation'),
         };
 
+        // We're using an object with providers instead of setting toolsInfo directly based on the provider,
+        // so the code stays clean and easy to read in connectors like toolsInfo.openai.webSearch or toolsInfo.xai.search.
+        // it helps prevent errors such as mistakenly using toolsInfo.search in the OpenAI connector and similar cases.
+        // This also helps enable autocomplete, so when typing toolsInfo.openai, it shows suggestions like webSearch.
+        _params.toolsInfo = {
+            openai: await this.prepareOpenAIToolsInfo(_params),
+            xai: await this.prepareXAIToolsInfo(_params),
+        };
+
         // The input adapter transforms the standardized parameters into the specific format required by the target LLM provider
         _params.agentId = candidate.id;
         const body = await this.reqBodyAdapter(_params);
@@ -331,6 +331,103 @@ export abstract class LLMConnector extends Connector {
         return { ..._params, body };
     }
 
+    private async prepareOpenAIToolsInfo(params: TLLMPreparedParams) {
+        const openAIToolsInfo: TOpenAIToolsInfo = {
+            webSearch: {
+                enabled: params?.useWebSearch && params.capabilities.search === true,
+                contextSize: params?.webSearchContextSize || 'medium',
+            },
+        };
+
+        if (params?.webSearchCity) {
+            openAIToolsInfo.webSearch.city = params?.webSearchCity;
+        }
+
+        if (params?.webSearchCountry) {
+            openAIToolsInfo.webSearch.country = params?.webSearchCountry;
+        }
+
+        if (params?.webSearchRegion) {
+            openAIToolsInfo.webSearch.region = params?.webSearchRegion;
+        }
+
+        if (params?.webSearchTimezone) {
+            openAIToolsInfo.webSearch.timezone = params?.webSearchTimezone;
+        }
+
+        return openAIToolsInfo;
+    }
+
+    private async prepareXAIToolsInfo(params: TLLMPreparedParams) {
+        const xaiToolsInfo: TxAIToolsInfo = {
+            search: {
+                enabled: params?.useSearch === true && params.capabilities.search === true,
+            },
+        };
+
+        if (params?.searchMode) {
+            xaiToolsInfo.search.mode = params?.searchMode;
+        }
+
+        if (params?.returnCitations) {
+            xaiToolsInfo.search.returnCitations = params?.returnCitations;
+        }
+
+        if (params?.maxSearchResults) {
+            xaiToolsInfo.search.maxResults = params?.maxSearchResults;
+        }
+
+        if (params?.searchDataSources) {
+            xaiToolsInfo.search.dataSources = params?.searchDataSources;
+        }
+
+        if (params?.searchCountry) {
+            xaiToolsInfo.search.country = params?.searchCountry;
+        }
+
+        if (params?.excludedWebsites) {
+            xaiToolsInfo.search.excludedWebsites = params?.excludedWebsites;
+        }
+
+        if (params?.allowedWebsites) {
+            xaiToolsInfo.search.allowedWebsites = params?.allowedWebsites;
+        }
+
+        if (params?.includedXHandles) {
+            xaiToolsInfo.search.includedXHandles = params?.includedXHandles;
+        }
+
+        if (params?.excludedXHandles) {
+            xaiToolsInfo.search.excludedXHandles = params?.excludedXHandles;
+        }
+
+        if (params?.postFavoriteCount) {
+            xaiToolsInfo.search.postFavoriteCount = params?.postFavoriteCount;
+        }
+
+        if (params?.postViewCount) {
+            xaiToolsInfo.search.postViewCount = params?.postViewCount;
+        }
+
+        if (params?.rssLinks) {
+            xaiToolsInfo.search.rssLinks = params?.rssLinks;
+        }
+
+        if (params?.safeSearch) {
+            xaiToolsInfo.search.safeSearch = params?.safeSearch;
+        }
+
+        if (params?.fromDate) {
+            xaiToolsInfo.search.fromDate = params?.fromDate;
+        }
+
+        if (params?.toDate) {
+            xaiToolsInfo.search.toDate = params?.toDate;
+        }
+
+        return xaiToolsInfo;
+    }
+
     // TODO [Forhad]: apply proper typing for _value and return value
     private formatParamValues(params: Record<string, string | number | string[] | TLLMMessageBlock[]>): any {
         let _params = {};

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

@@ -5,7 +5,6 @@ import { JSON_RESPONSE_INSTRUCTION, BUILT_IN_MODEL_PREFIX } from '@sre/constants
 import { BinaryInput } from '@sre/helpers/BinaryInput.helper';
 import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
 import {
-    TLLMParams,
     ToolData,
     TLLMMessageBlock,
     TLLMToolResultMessageBlock,
@@ -17,6 +16,7 @@ import {
     BasicCredentials,
     TAnthropicRequestBody,
     ILLMRequestContext,
+    TLLMPreparedParams,
 } from '@sre/types/LLM.types';
 
 import { LLMHelper } from '@sre/LLMManager/LLM.helper';
@@ -203,11 +203,7 @@ export class AnthropicConnector extends LLMConnector {
         }
     }
 
-    protected async webSearchRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter> {
-        throw new Error('Web search requests are not supported by Anthropic');
-    }
-
-    protected async reqBodyAdapter(params: TLLMParams): Promise<TAnthropicRequestBody> {
+    protected async reqBodyAdapter(params: TLLMPreparedParams): Promise<TAnthropicRequestBody> {
         const body = await this.prepareBody(params);
 
         const shouldUseThinking = await this.shouldUseThinkingMode(params);
@@ -224,7 +220,7 @@ export class AnthropicConnector extends LLMConnector {
 
     protected reportUsage(
         usage: Anthropic.Messages.Usage & { cache_creation_input_tokens?: number; cache_read_input_tokens?: number },
-        metadata: { modelEntryName: string; keySource: APIKeySource; agentId: string; teamId: string },
+        metadata: { modelEntryName: string; keySource: APIKeySource; agentId: string; teamId: string }
     ) {
         // SmythOS (built-in) models have a prefix, so we need to remove it to get the model name
         const modelName = metadata.modelEntryName.replace(BUILT_IN_MODEL_PREFIX, '');
@@ -355,7 +351,7 @@ export class AnthropicConnector extends LLMConnector {
             } else if (Array.isArray(message?.content)) {
                 if (Array.isArray(message.content)) {
                     const toolBlocks = message.content.filter(
-                        (item) => typeof item === 'object' && 'type' in item && (item.type === 'tool_use' || item.type === 'tool_result'),
+                        (item) => typeof item === 'object' && 'type' in item && (item.type === 'tool_use' || item.type === 'tool_result')
                     );
 
                     if (toolBlocks?.length > 0) {
@@ -407,7 +403,7 @@ export class AnthropicConnector extends LLMConnector {
         return _messages;
     }
 
-    private async prepareBody(params: TLLMParams): Promise<Anthropic.MessageCreateParamsNonStreaming> {
+    private async prepareBody(params: TLLMPreparedParams): Promise<Anthropic.MessageCreateParamsNonStreaming> {
         let messages = await this.prepareMessages(params);
 
         let body: Anthropic.MessageCreateParamsNonStreaming = {
@@ -444,9 +440,11 @@ export class AnthropicConnector extends LLMConnector {
         }
         //#endregion Prepare system message and add JSON response instruction if needed
 
-        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;
+        const isReasoningModel = params?.capabilities?.reasoning;
+
+        if (params?.temperature !== undefined && !isReasoningModel) body.temperature = params.temperature;
+        if (params?.topP !== undefined && !isReasoningModel) body.top_p = params.topP;
+        if (params?.topK !== undefined && !isReasoningModel) body.top_k = params.topK;
         if (params?.stopSequences?.length) body.stop_sequences = params.stopSequences;
 
         // #region Tools
@@ -479,7 +477,7 @@ export class AnthropicConnector extends LLMConnector {
     }): Promise<Anthropic.MessageCreateParamsNonStreaming> {
         // Remove the assistant message with the prefill text for JSON response, it's not supported with thinking
         let messages = body.messages.filter(
-            (message) => message?.role !== TLLMMessageRole.Assistant && message?.content !== PREFILL_TEXT_FOR_JSON_RESPONSE,
+            (message) => !(message?.role === TLLMMessageRole.Assistant && message?.content === PREFILL_TEXT_FOR_JSON_RESPONSE)
         );
 
         let budget_tokens = Math.min(maxThinkingTokens, body.max_tokens);
@@ -523,7 +521,7 @@ export class AnthropicConnector extends LLMConnector {
         return thinkingBody;
     }
 
-    private async prepareMessages(params: TLLMParams) {
+    private async prepareMessages(params: TLLMPreparedParams) {
         const messages = params?.messages || [];
 
         const files: BinaryInput[] = params?.files || [];
@@ -556,7 +554,10 @@ export class AnthropicConnector extends LLMConnector {
         return messages;
     }
 
-    private async prepareSystemPrompt(systemMessage: TLLMMessageBlock, params: TLLMParams): Promise<string | Array<Anthropic.TextBlockParam>> {
+    private async prepareSystemPrompt(
+        systemMessage: TLLMMessageBlock,
+        params: TLLMPreparedParams
+    ): Promise<string | Array<Anthropic.TextBlockParam>> {
         let systemPrompt = systemMessage?.content;
 
         if (typeof systemPrompt === 'string') {
@@ -584,7 +585,7 @@ export class AnthropicConnector extends LLMConnector {
     /**
      * Determines if thinking mode should be used based on model capabilities and parameters.
      */
-    private async shouldUseThinkingMode(params: TLLMParams): Promise<boolean> {
+    private async shouldUseThinkingMode(params: TLLMPreparedParams): Promise<boolean> {
         // Legacy thinking models always use thinking mode
         if (LEGACY_THINKING_MODELS.includes(params.modelEntryName)) {
             return true;
@@ -614,7 +615,7 @@ export class AnthropicConnector extends LLMConnector {
 
     private async getImageData(
         files: BinaryInput[],
-        agentId: string,
+        agentId: string
     ): Promise<
         {
             type: string;