promptfoo 0.119.13 → 0.119.14

package/dist/src/providers/{groq.d.ts → groq/chat.d.ts}

@@ -1,19 +1,26 @@
-import { OpenAiChatCompletionProvider } from './openai/chat';
-import type { ProviderOptions } from '../types/providers';
-import type { OpenAiCompletionOptions } from './openai/types';
-type GroqCompletionOptions = OpenAiCompletionOptions & {
-    systemPrompt?: string;
-    parallel_tool_calls?: boolean | null;
-    reasoning_format?: string | null;
-};
-type GroqProviderOptions = ProviderOptions & {
-    config?: GroqCompletionOptions;
-};
+import type { CallApiContextParams, CallApiOptionsParams } from '../../types/index';
+import { OpenAiChatCompletionProvider } from '../openai/chat';
+import type { GroqProviderOptions } from './types';
+/**
+ * Groq Chat Completions API Provider
+ *
+ * Extends OpenAI Chat Completions provider with Groq-specific configuration.
+ * Supports reasoning models (DeepSeek R1, GPT-OSS, Qwen) with temperature control.
+ *
+ * Usage:
+ *   groq:llama-3.3-70b-versatile
+ *   groq:openai/gpt-oss-120b
+ *   groq:qwen/qwen3-32b
+ */
 export declare class GroqProvider extends OpenAiChatCompletionProvider {
     protected get apiKey(): string | undefined;
     protected isReasoningModel(): boolean;
     protected supportsTemperature(): boolean;
     constructor(modelName: string, providerOptions: GroqProviderOptions);
+    getOpenAiBody(prompt: string, context?: CallApiContextParams, callApiOptions?: CallApiOptionsParams): Promise<{
+        body: any;
+        config: any;
+    }>;
     id(): string;
     toString(): string;
     toJSON(): {
@@ -38,11 +45,11 @@ export declare class GroqProvider extends OpenAiChatCompletionProvider {
             frequency_penalty?: number;
             presence_penalty?: number;
             best_of?: number;
-            functions?: import("./openai/util").OpenAiFunction[];
+            functions?: import("../openai/util").OpenAiFunction[];
             function_call?: "none" | "auto" | {
                 name: string;
             };
-            tools?: (import("./openai/util").OpenAiTool | import("./openai/types").OpenAiMCPTool | import("./openai/types").OpenAiWebSearchTool | import("./openai/types").OpenAiCodeInterpreterTool)[];
+            tools?: (import("../openai/util").OpenAiTool | import("../openai/types").OpenAiMCPTool | import("../openai/types").OpenAiWebSearchTool | import("../openai/types").OpenAiCodeInterpreterTool)[];
             tool_choice?: "none" | "auto" | "required" | {
                 type: "function";
                 function?: {
@@ -69,8 +76,8 @@ export declare class GroqProvider extends OpenAiChatCompletionProvider {
             stop?: string[];
             seed?: number;
             passthrough?: object;
-            reasoning_effort?: import("./openai/types").ReasoningEffort;
-            reasoning?: import("./openai/types").Reasoning | import("./openai/types").GPT5Reasoning;
+            reasoning_effort?: import("../openai/types").ReasoningEffort;
+            reasoning?: import("../openai/types").Reasoning | import("../openai/types").GPT5Reasoning;
             service_tier?: ("auto" | "default" | "premium") | null;
             modalities?: string[];
             audio?: {
@@ -91,11 +98,10 @@ export declare class GroqProvider extends OpenAiChatCompletionProvider {
             user?: string;
             background?: boolean;
             webhook_url?: string;
-            functionToolCallbacks?: Record<import("openai").default.FunctionDefinition["name"], import("./openai/types").AssistantFunctionCallback | string>;
-            mcp?: import("./mcp/types").MCPConfig;
-            verbosity?: import("./openai/types").GPT5Verbosity;
+            functionToolCallbacks?: Record<import("openai").default.FunctionDefinition["name"], import("../openai/types").AssistantFunctionCallback | string>;
+            mcp?: import("../mcp/types").MCPConfig;
+            verbosity?: import("../openai/types").GPT5Verbosity;
         };
     };
 }
-export {};
-//# sourceMappingURL=groq.d.ts.map
+//# sourceMappingURL=chat.d.ts.map

package/dist/src/providers/groq/chat.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroqProvider = void 0;
+const chat_1 = require("../openai/chat");
+const util_1 = require("./util");
+const GROQ_API_BASE_URL = 'https://api.groq.com/openai/v1';
+/**
+ * Groq Chat Completions API Provider
+ *
+ * Extends OpenAI Chat Completions provider with Groq-specific configuration.
+ * Supports reasoning models (DeepSeek R1, GPT-OSS, Qwen) with temperature control.
+ *
+ * Usage:
+ *   groq:llama-3.3-70b-versatile
+ *   groq:openai/gpt-oss-120b
+ *   groq:qwen/qwen3-32b
+ */
+class GroqProvider extends chat_1.OpenAiChatCompletionProvider {
+    get apiKey() {
+        return this.config?.apiKey;
+    }
+    isReasoningModel() {
+        return (0, util_1.isGroqReasoningModel)(this.modelName) || super.isReasoningModel();
+    }
+    supportsTemperature() {
+        // Groq's reasoning models support temperature, unlike OpenAI's o1 models
+        if ((0, util_1.groqSupportsTemperature)(this.modelName)) {
+            return true;
+        }
+        return super.supportsTemperature();
+    }
+    constructor(modelName, providerOptions) {
+        super(modelName, {
+            ...providerOptions,
+            config: {
+                ...providerOptions.config,
+                apiKeyEnvar: 'GROQ_API_KEY',
+                apiBaseUrl: GROQ_API_BASE_URL,
+            },
+        });
+    }
+    async getOpenAiBody(prompt, context, callApiOptions) {
+        const { body, config } = await super.getOpenAiBody(prompt, context, callApiOptions);
+        const groqConfig = this.config;
+        // Add Groq-specific reasoning parameters
+        if (groqConfig.reasoning_format !== undefined) {
+            body.reasoning_format = groqConfig.reasoning_format;
+        }
+        if (groqConfig.include_reasoning !== undefined) {
+            body.include_reasoning = groqConfig.include_reasoning;
+        }
+        // Add Compound model parameters
+        if (groqConfig.compound_custom) {
+            body.compound_custom = groqConfig.compound_custom;
+        }
+        if (groqConfig.search_settings) {
+            body.search_settings = groqConfig.search_settings;
+        }
+        return { body, config };
+    }
+    id() {
+        return `groq:${this.modelName}`;
+    }
+    toString() {
+        return `[Groq Provider ${this.modelName}]`;
+    }
+    toJSON() {
+        return {
+            provider: 'groq',
+            model: this.modelName,
+            config: {
+                ...this.config,
+                ...(this.apiKey && { apiKey: undefined }),
+            },
+        };
+    }
+}
+exports.GroqProvider = GroqProvider;
+//# sourceMappingURL=chat.js.map

package/dist/src/providers/groq/index.d.ts

@@ -0,0 +1,5 @@
+export { GroqProvider } from './chat';
+export { GroqResponsesProvider } from './responses';
+export * from './types';
+export * from './util';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/providers/groq/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroqResponsesProvider = exports.GroqProvider = void 0;
+var chat_1 = require("./chat");
+Object.defineProperty(exports, "GroqProvider", { enumerable: true, get: function () { return chat_1.GroqProvider; } });
+var responses_1 = require("./responses");
+Object.defineProperty(exports, "GroqResponsesProvider", { enumerable: true, get: function () { return responses_1.GroqResponsesProvider; } });
+__exportStar(require("./types"), exports);
+__exportStar(require("./util"), exports);
+//# sourceMappingURL=index.js.map

package/dist/src/providers/groq/responses.d.ts

@@ -0,0 +1,106 @@
+import { OpenAiResponsesProvider } from '../openai/responses';
+import type { GroqResponsesProviderOptions } from './types';
+/**
+ * Groq Responses API Provider
+ *
+ * Extends OpenAI Responses API provider with Groq-specific configuration.
+ * Supports reasoning models (DeepSeek R1, GPT-OSS, Qwen) with temperature control.
+ *
+ * Note: Unlike the Chat Completions API, the Responses API does NOT support
+ * `reasoning_format` or `include_reasoning` parameters. Reasoning is controlled
+ * via the `reasoning.effort` parameter inherited from OpenAiCompletionOptions.
+ *
+ * Usage:
+ *   groq:responses:llama-3.3-70b-versatile
+ *   groq:responses:openai/gpt-oss-120b
+ *   groq:responses:qwen/qwen3-32b
+ */
+export declare class GroqResponsesProvider extends OpenAiResponsesProvider {
+    protected get apiKey(): string | undefined;
+    protected isReasoningModel(): boolean;
+    protected supportsTemperature(): boolean;
+    constructor(modelName: string, providerOptions: GroqResponsesProviderOptions);
+    id(): string;
+    toString(): string;
+    toJSON(): {
+        provider: string;
+        model: string;
+        config: {
+            apiKey?: string;
+            apiKeyEnvar?: string;
+            apiKeyRequired?: boolean;
+            apiHost?: string;
+            apiBaseUrl?: string;
+            organization?: string;
+            cost?: number;
+            headers?: {
+                [key: string]: string;
+            };
+            maxRetries?: number;
+            temperature?: number;
+            max_completion_tokens?: number;
+            max_tokens?: number;
+            top_p?: number;
+            frequency_penalty?: number;
+            presence_penalty?: number;
+            best_of?: number;
+            functions?: import("../openai/util").OpenAiFunction[];
+            function_call?: "none" | "auto" | {
+                name: string;
+            };
+            tools?: (import("../openai/util").OpenAiTool | import("../openai/types").OpenAiMCPTool | import("../openai/types").OpenAiWebSearchTool | import("../openai/types").OpenAiCodeInterpreterTool)[];
+            tool_choice?: "none" | "auto" | "required" | {
+                type: "function";
+                function?: {
+                    name: string;
+                };
+            };
+            tool_resources?: Record<string, any>;
+            showThinking?: boolean;
+            response_format?: {
+                type: "json_object";
+            } | {
+                type: "json_schema";
+                json_schema: {
+                    name: string;
+                    strict: boolean;
+                    schema: {
+                        type: "object";
+                        properties: Record<string, any>;
+                        required?: string[];
+                        additionalProperties: false;
+                    };
+                };
+            };
+            stop?: string[];
+            seed?: number;
+            passthrough?: object;
+            reasoning_effort?: import("../openai/types").ReasoningEffort;
+            reasoning?: import("../openai/types").Reasoning | import("../openai/types").GPT5Reasoning;
+            service_tier?: ("auto" | "default" | "premium") | null;
+            modalities?: string[];
+            audio?: {
+                bitrate?: string;
+                format?: string | "wav" | "mp3" | "flac" | "opus" | "pcm16" | "aac";
+                speed?: number;
+                voice?: string;
+            };
+            instructions?: string;
+            max_output_tokens?: number;
+            max_tool_calls?: number;
+            metadata?: Record<string, string>;
+            parallel_tool_calls?: boolean;
+            previous_response_id?: string;
+            store?: boolean;
+            stream?: boolean;
+            truncation?: "auto" | "disabled";
+            user?: string;
+            background?: boolean;
+            webhook_url?: string;
+            functionToolCallbacks?: Record<import("openai").default.FunctionDefinition["name"], import("../openai/types").AssistantFunctionCallback | string>;
+            mcp?: import("../mcp/types").MCPConfig;
+            verbosity?: import("../openai/types").GPT5Verbosity;
+        };
+    };
+}
+//# sourceMappingURL=responses.d.ts.map

package/dist/src/providers/groq/responses.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroqResponsesProvider = void 0;
+const responses_1 = require("../openai/responses");
+const util_1 = require("./util");
+const GROQ_API_BASE_URL = 'https://api.groq.com/openai/v1';
+/**
+ * Groq Responses API Provider
+ *
+ * Extends OpenAI Responses API provider with Groq-specific configuration.
+ * Supports reasoning models (DeepSeek R1, GPT-OSS, Qwen) with temperature control.
+ *
+ * Note: Unlike the Chat Completions API, the Responses API does NOT support
+ * `reasoning_format` or `include_reasoning` parameters. Reasoning is controlled
+ * via the `reasoning.effort` parameter inherited from OpenAiCompletionOptions.
+ *
+ * Usage:
+ *   groq:responses:llama-3.3-70b-versatile
+ *   groq:responses:openai/gpt-oss-120b
+ *   groq:responses:qwen/qwen3-32b
+ */
+class GroqResponsesProvider extends responses_1.OpenAiResponsesProvider {
+    get apiKey() {
+        return this.config?.apiKey;
+    }
+    isReasoningModel() {
+        return (0, util_1.isGroqReasoningModel)(this.modelName) || super.isReasoningModel();
+    }
+    supportsTemperature() {
+        // Groq's reasoning models support temperature, unlike OpenAI's o1 models
+        if ((0, util_1.groqSupportsTemperature)(this.modelName)) {
+            return true;
+        }
+        return super.supportsTemperature();
+    }
+    constructor(modelName, providerOptions) {
+        super(modelName, {
+            ...providerOptions,
+            config: {
+                ...providerOptions.config,
+                apiKeyEnvar: 'GROQ_API_KEY',
+                apiBaseUrl: GROQ_API_BASE_URL,
+            },
+        });
+    }
+    id() {
+        return `groq:responses:${this.modelName}`;
+    }
+    toString() {
+        return `[Groq Responses Provider ${this.modelName}]`;
+    }
+    toJSON() {
+        return {
+            provider: 'groq:responses',
+            model: this.modelName,
+            config: {
+                ...this.config,
+                ...(this.apiKey && { apiKey: undefined }),
+            },
+        };
+    }
+}
+exports.GroqResponsesProvider = GroqResponsesProvider;
+//# sourceMappingURL=responses.js.map

package/dist/src/providers/groq/types.d.ts

@@ -0,0 +1,44 @@
+import type { ProviderOptions } from '../../types/providers';
+import type { OpenAiCompletionOptions } from '../openai/types';
+/**
+ * Groq-specific completion options for Chat Completions API.
+ */
+export type GroqCompletionOptions = OpenAiCompletionOptions & {
+    systemPrompt?: string;
+    parallel_tool_calls?: boolean | null;
+    /** Controls how reasoning is presented. Options: 'parsed', 'raw', 'hidden'. */
+    reasoning_format?: 'parsed' | 'raw' | 'hidden' | null;
+    /** For GPT-OSS models, set to false to hide reasoning output. */
+    include_reasoning?: boolean;
+    /** Compound model tool configuration. */
+    compound_custom?: {
+        tools?: {
+            enabled_tools?: string[];
+            wolfram_settings?: {
+                authorization?: string;
+            };
+        };
+    };
+    /** Web search customization settings. */
+    search_settings?: {
+        exclude_domains?: string[];
+        include_domains?: string[];
+        country?: string;
+    };
+};
+/**
+ * Groq Responses API options.
+ * Note: Unlike Chat Completions API, does NOT support reasoning_format or include_reasoning.
+ * Reasoning is controlled via reasoning.effort inherited from OpenAiCompletionOptions.
+ */
+export type GroqResponsesOptions = OpenAiCompletionOptions & {
+    systemPrompt?: string;
+    parallel_tool_calls?: boolean | null;
+};
+export type GroqProviderOptions = ProviderOptions & {
+    config?: GroqCompletionOptions;
+};
+export type GroqResponsesProviderOptions = ProviderOptions & {
+    config?: GroqResponsesOptions;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/src/providers/groq/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/src/providers/groq/util.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Groq-specific utility functions shared between Chat and Responses providers.
+ */
+/**
+ * Check if a model name corresponds to a Groq reasoning model.
+ * Groq's reasoning models include DeepSeek R1, GPT-OSS, and Qwen variants.
+ */
+export declare function isGroqReasoningModel(modelName: string): boolean;
+/**
+ * Check if a Groq model supports temperature configuration.
+ * Unlike some reasoning models (e.g., o1), Groq's reasoning models
+ * (DeepSeek R1, GPT-OSS, Qwen) support temperature settings.
+ */
+export declare function groqSupportsTemperature(modelName: string): boolean;
+//# sourceMappingURL=util.d.ts.map

package/dist/src/providers/groq/util.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * Groq-specific utility functions shared between Chat and Responses providers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGroqReasoningModel = isGroqReasoningModel;
+exports.groqSupportsTemperature = groqSupportsTemperature;
+/**
+ * Groq reasoning models that support extended thinking capabilities.
+ * These models include DeepSeek R1 variants, OpenAI GPT-OSS, and Qwen models.
+ */
+const GROQ_REASONING_MODEL_PATTERNS = ['deepseek-r1', 'gpt-oss', 'qwen'];
+/**
+ * Check if a model name corresponds to a Groq reasoning model.
+ * Groq's reasoning models include DeepSeek R1, GPT-OSS, and Qwen variants.
+ */
+function isGroqReasoningModel(modelName) {
+    return GROQ_REASONING_MODEL_PATTERNS.some((pattern) => modelName.includes(pattern));
+}
+/**
+ * Check if a Groq model supports temperature configuration.
+ * Unlike some reasoning models (e.g., o1), Groq's reasoning models
+ * (DeepSeek R1, GPT-OSS, Qwen) support temperature settings.
+ */
+function groqSupportsTemperature(modelName) {
+    return isGroqReasoningModel(modelName);
+}
+//# sourceMappingURL=util.js.map

package/dist/src/providers/mcp/client.d.ts

@@ -6,6 +6,14 @@ export declare class MCPClient {
     private transports;
     get hasInitialized(): boolean;
     get connectedServers(): string[];
+    /**
+     * Check if debug mode is enabled (config takes priority over env var)
+     */
+    private get isDebugEnabled();
+    /**
+     * Check if verbose mode is enabled (config takes priority over env var)
+     */
+    private get isVerboseEnabled();
     constructor(config: MCPConfig);
     initialize(): Promise<void>;
     private connectToServer;

package/dist/src/providers/mcp/client.js

@@ -38,8 +38,31 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MCPClient = void 0;
 const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const envars_1 = require("../../envars");
 const logger_1 = __importDefault(require("../../logger"));
 const util_1 = require("./util");
+/**
+ * Get the effective request options for MCP requests.
+ * Priority: config values > MCP_REQUEST_TIMEOUT_MS env var > undefined (SDK default of 60s)
+ */
+function getEffectiveRequestOptions(config) {
+    const timeout = config.timeout ?? (0, envars_1.getEnvInt)('MCP_REQUEST_TIMEOUT_MS');
+    // If no timeout options are set, return undefined to use SDK defaults
+    if (!timeout && !config.resetTimeoutOnProgress && !config.maxTotalTimeout) {
+        return undefined;
+    }
+    const options = {};
+    if (timeout) {
+        options.timeout = timeout;
+    }
+    if (config.resetTimeoutOnProgress) {
+        options.resetTimeoutOnProgress = config.resetTimeoutOnProgress;
+    }
+    if (config.maxTotalTimeout) {
+        options.maxTotalTimeout = config.maxTotalTimeout;
+    }
+    return options;
+}
 class MCPClient {
     get hasInitialized() {
         return this.clients.size > 0;
@@ -47,6 +70,18 @@ class MCPClient {
     get connectedServers() {
         return Array.from(this.clients.keys());
     }
+    /**
+     * Check if debug mode is enabled (config takes priority over env var)
+     */
+    get isDebugEnabled() {
+        return this.config.debug ?? (0, envars_1.getEnvBool)('MCP_DEBUG') ?? false;
+    }
+    /**
+     * Check if verbose mode is enabled (config takes priority over env var)
+     */
+    get isVerboseEnabled() {
+        return this.config.verbose ?? (0, envars_1.getEnvBool)('MCP_VERBOSE') ?? false;
+    }
     constructor(config) {
         this.clients = new Map();
         this.tools = new Map();
@@ -69,6 +104,7 @@ class MCPClient {
         const client = new index_js_1.Client({ name: 'promptfoo-MCP', version: '1.0.0' });
         let transport;
         try {
+            const requestOptions = getEffectiveRequestOptions(this.config);
             if (server.command && server.args) {
                 const { StdioClientTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/client/stdio.js')));
                 // NPM package or other command execution
@@ -77,7 +113,7 @@ class MCPClient {
                     args: server.args,
                     env: process.env,
                 });
-                await client.connect(transport);
+                await client.connect(transport, requestOptions);
             }
             else if (server.path) {
                 // Local server file
@@ -97,7 +133,7 @@ class MCPClient {
                     args: [server.path],
                     env: process.env,
                 });
-                await client.connect(transport);
+                await client.connect(transport, requestOptions);
             }
             else if (server.url) {
                 // Get auth headers and combine with custom headers
@@ -111,22 +147,34 @@ class MCPClient {
                 try {
                     const { StreamableHTTPClientTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/client/streamableHttp.js')));
                     transport = new StreamableHTTPClientTransport(new URL(server.url), options);
-                    await client.connect(transport);
+                    await client.connect(transport, requestOptions);
                     logger_1.default.debug('Connected using Streamable HTTP transport');
                 }
                 catch (error) {
                     logger_1.default.debug(`Failed to connect to MCP server with Streamable HTTP transport ${serverKey}: ${error}`);
                     const { SSEClientTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/client/sse.js')));
                     transport = new SSEClientTransport(new URL(server.url), options);
-                    await client.connect(transport);
+                    await client.connect(transport, requestOptions);
                     logger_1.default.debug('Connected using SSE transport');
                 }
             }
             else {
                 throw new Error('Either command+args or path or url must be specified for MCP server');
             }
+            // Ping server to verify connection if configured
+            if (this.config.pingOnConnect) {
+                try {
+                    await client.ping(requestOptions);
+                    logger_1.default.debug(`MCP server ${serverKey} ping successful`);
+                }
+                catch (pingError) {
+                    const pingErrorMessage = pingError instanceof Error ? pingError.message : String(pingError);
+                    throw new Error(`MCP server ${serverKey} ping failed: ${pingErrorMessage}`);
+                }
+            }
             // List available tools
-            const toolsResult = await client.listTools();
+            const toolsResult = await client.listTools(undefined, // no pagination params
+            requestOptions);
             const serverTools = toolsResult?.tools?.map((tool) => ({
                 name: tool.name,
                 description: tool.description || '',
@@ -143,13 +191,13 @@ class MCPClient {
             this.transports.set(serverKey, transport);
             this.clients.set(serverKey, client);
             this.tools.set(serverKey, filteredTools);
-            if (this.config.verbose) {
+            if (this.isVerboseEnabled) {
                 console.log(`Connected to MCP server ${serverKey} with tools:`, filteredTools.map((tool) => tool.name));
             }
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            if (this.config.debug) {
+            if (this.isDebugEnabled) {
                 logger_1.default.error(`Failed to connect to MCP server ${serverKey}: ${errorMessage}`);
             }
             throw new Error(`Failed to connect to MCP server ${serverKey}: ${errorMessage}`);
@@ -159,12 +207,14 @@ class MCPClient {
         return Array.from(this.tools.values()).flat();
     }
     async callTool(name, args) {
+        const requestOptions = getEffectiveRequestOptions(this.config);
         // Find which server has this tool
         for (const [serverKey, client] of this.clients.entries()) {
             const serverTools = this.tools.get(serverKey) || [];
             if (serverTools.some((tool) => tool.name === name)) {
                 try {
-                    const result = await client.callTool({ name, arguments: args });
+                    const result = await client.callTool({ name, arguments: args }, undefined, // use default result schema
+                    requestOptions);
                     // Handle different content types appropriately
                     let content = '';
                     if (result?.content) {
@@ -191,7 +241,7 @@ class MCPClient {
                 }
                 catch (error) {
                     const errorMessage = error instanceof Error ? error.message : String(error);
-                    if (this.config.debug) {
+                    if (this.isDebugEnabled) {
                         logger_1.default.error(`Error calling tool ${name}: ${errorMessage}`);
                     }
                     return {
@@ -213,7 +263,7 @@ class MCPClient {
                 await client.close();
             }
             catch (error) {
-                if (this.config.debug) {
+                if (this.isDebugEnabled) {
                     logger_1.default.error(`Error during cleanup: ${error instanceof Error ? error.message : String(error)}`);
                 }
             }

package/dist/src/providers/mcp/types.d.ts

@@ -19,7 +19,28 @@ export interface MCPConfig {
     enabled: boolean;
     server?: MCPServerConfig;
     servers?: MCPServerConfig[];
+    /**
+     * Request timeout in milliseconds for MCP operations.
+     * Defaults to 60000 (60 seconds) if not specified.
+     */
     timeout?: number;
+    /**
+     * If true, receiving progress notifications will reset the request timeout.
+     * Useful for long-running operations that send periodic progress updates.
+     * Default: false
+     */
+    resetTimeoutOnProgress?: boolean;
+    /**
+     * Maximum total time in milliseconds to wait for a response, regardless of progress.
+     * If exceeded, the request will timeout even if progress notifications are received.
+     * If not specified, there is no maximum total timeout.
+     */
+    maxTotalTimeout?: number;
+    /**
+     * If true, ping the MCP server after connecting to verify it's responsive.
+     * Default: false
+     */
+    pingOnConnect?: boolean;
     tools?: string[];
     exclude_tools?: string[];
     debug?: boolean;