promptfoo 0.119.13 → 0.119.14

package/dist/src/providers/openai/codex-sdk.d.ts

@@ -0,0 +1,109 @@
+import type { ApiProvider, CallApiContextParams, CallApiOptionsParams, ProviderResponse } from '../../types/index';
+import type { EnvOverrides } from '../../types/env';
+/**
+ * OpenAI Codex SDK Provider
+ *
+ * This provider requires the @openai/codex-sdk package, which may have a
+ * proprietary license and is not installed by default. Users must install it separately:
+ *   npm install @openai/codex-sdk
+ *
+ * Key features:
+ * - Thread-based conversations with persistence in ~/.codex/sessions
+ * - Native JSON schema output with Zod support
+ * - Git repository requirement for safety (can be disabled)
+ * - Custom binary path override support
+ * - Streaming events for real-time progress
+ *
+ * Thread Management:
+ * - No persist_threads: Creates ephemeral thread per call (default)
+ * - With persist_threads: Pools threads by cache key for reuse
+ * - With thread_id: Resumes specific thread from ~/.codex/sessions
+ */
+export interface OpenAICodexSDKConfig {
+    apiKey?: string;
+    /**
+     * Working directory for Codex to operate in
+     * Defaults to process.cwd()
+     */
+    working_dir?: string;
+    /**
+     * Additional directories the agent can access beyond the working directory.
+     * Maps to --add-dir flag in Codex CLI.
+     */
+    additional_directories?: string[];
+    /**
+     * Skip Git repository check (Codex requires Git by default)
+     */
+    skip_git_repo_check?: boolean;
+    /**
+     * Path to custom codex binary
+     */
+    codex_path_override?: string;
+    /**
+     * Model to use (e.g., 'gpt-5.1-codex', 'gpt-4o', 'o3-mini')
+     */
+    model?: string;
+    /**
+     * Fallback model if primary model fails
+     */
+    fallback_model?: string;
+    /**
+     * Maximum tokens for response
+     */
+    max_tokens?: number;
+    /**
+     * Maximum tokens for tool output (default: 10000)
+     * Controls how much output from tool calls is included in the context.
+     */
+    tool_output_token_limit?: number;
+    /**
+     * Thread management
+     */
+    thread_id?: string;
+    persist_threads?: boolean;
+    thread_pool_size?: number;
+    /**
+     * Output schema for structured JSON responses
+     * Supports plain JSON schema or Zod schemas converted with zod-to-json-schema
+     */
+    output_schema?: Record<string, any>;
+    /**
+     * Environment variables to pass to Codex CLI
+     * By default inherits Node.js process.env
+     */
+    cli_env?: Record<string, string>;
+    /**
+     * Custom system instructions
+     */
+    system_prompt?: string;
+    /**
+     * Enable streaming events (default: false for simplicity)
+     */
+    enable_streaming?: boolean;
+}
+export declare class OpenAICodexSDKProvider implements ApiProvider {
+    static OPENAI_MODELS: string[];
+    config: OpenAICodexSDKConfig;
+    env?: EnvOverrides;
+    apiKey?: string;
+    private providerId;
+    private codexModule?;
+    private codexInstance?;
+    private threads;
+    constructor(options?: {
+        id?: string;
+        config?: OpenAICodexSDKConfig;
+        env?: EnvOverrides;
+    });
+    id(): string;
+    getApiKey(): string | undefined;
+    toString(): string;
+    cleanup(): Promise<void>;
+    private prepareEnvironment;
+    private validateWorkingDirectory;
+    private getOrCreateThread;
+    private runStreaming;
+    private generateCacheKey;
+    callApi(prompt: string, context?: CallApiContextParams, callOptions?: CallApiOptionsParams): Promise<ProviderResponse>;
+}
+//# sourceMappingURL=codex-sdk.d.ts.map

package/dist/src/providers/openai/codex-sdk.js

@@ -0,0 +1,346 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAICodexSDKProvider = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const dedent_1 = __importDefault(require("dedent"));
+const cliState_1 = __importDefault(require("../../cliState"));
+const envars_1 = require("../../envars");
+const esm_1 = require("../../esm");
+const logger_1 = __importDefault(require("../../logger"));
+/**
+ * Helper to load the OpenAI Codex SDK ESM module
+ * Uses importModule utility which handles ESM loading in CommonJS environments
+ */
+async function loadCodexSDK() {
+    try {
+        // Resolve the package path, then use importModule to load it
+        // The SDK is ESM-only, so we need the importModule utility which uses dynamic-import.cjs
+        const basePath = cliState_1.default.basePath && path_1.default.isAbsolute(cliState_1.default.basePath) ? cliState_1.default.basePath : process.cwd();
+        // The package only exports ESM, so we construct the direct path
+        // The SDK is installed in node_modules/@openai/codex-sdk/dist/index.js
+        const modulePath = path_1.default.join(basePath, 'node_modules', '@openai', 'codex-sdk', 'dist', 'index.js');
+        return await (0, esm_1.importModule)(modulePath);
+    }
+    catch (err) {
+        logger_1.default.error(`Failed to load OpenAI Codex SDK: ${err}`);
+        if (err.stack) {
+            logger_1.default.error(err.stack);
+        }
+        throw new Error((0, dedent_1.default) `The @openai/codex-sdk package is required but not installed.
+
+      This package may have a proprietary license and is not installed by default.
+
+      To use the OpenAI Codex SDK provider, install it with:
+        npm install @openai/codex-sdk
+
+      Requires Node.js 18+.
+
+      For more information, see: https://www.promptfoo.dev/docs/providers/openai-codex-sdk/`);
+    }
+}
+// Pricing per 1M tokens (as of November 2025)
+// See: https://openai.com/pricing
+const CODEX_MODEL_PRICING = {
+    'gpt-5.1-codex': { input: 2.0, output: 8.0 },
+    'gpt-5.1-codex-max': { input: 3.0, output: 12.0 },
+    'gpt-5.1-codex-mini': { input: 0.5, output: 2.0 },
+    'gpt-5-codex': { input: 2.0, output: 8.0 },
+    'gpt-5-codex-mini': { input: 0.5, output: 2.0 },
+    'gpt-5': { input: 2.0, output: 8.0 },
+    'gpt-4o': { input: 2.5, output: 10.0 },
+    'gpt-4o-mini': { input: 0.15, output: 0.6 },
+    'gpt-4-turbo': { input: 10.0, output: 30.0 },
+    'gpt-4': { input: 30.0, output: 60.0 },
+    'o3-mini': { input: 1.1, output: 4.4 },
+    o1: { input: 15.0, output: 60.0 },
+    'o1-mini': { input: 3.0, output: 12.0 },
+};
+class OpenAICodexSDKProvider {
+    constructor(options = {}) {
+        this.providerId = 'openai:codex-sdk';
+        this.threads = new Map();
+        const { config, env, id } = options;
+        this.config = config ?? {};
+        this.env = env;
+        this.apiKey = this.getApiKey();
+        this.providerId = id ?? this.providerId;
+        if (this.config.model && !OpenAICodexSDKProvider.OPENAI_MODELS.includes(this.config.model)) {
+            logger_1.default.warn(`Using unknown model for OpenAI Codex SDK: ${this.config.model}`);
+        }
+        if (this.config.fallback_model &&
+            !OpenAICodexSDKProvider.OPENAI_MODELS.includes(this.config.fallback_model)) {
+            logger_1.default.warn(`Using unknown model for OpenAI Codex SDK fallback: ${this.config.fallback_model}`);
+        }
+    }
+    id() {
+        return this.providerId;
+    }
+    getApiKey() {
+        return (this.config?.apiKey ||
+            this.env?.OPENAI_API_KEY ||
+            this.env?.CODEX_API_KEY ||
+            (0, envars_1.getEnvString)('OPENAI_API_KEY') ||
+            (0, envars_1.getEnvString)('CODEX_API_KEY'));
+    }
+    toString() {
+        return '[OpenAI Codex SDK Provider]';
+    }
+    async cleanup() {
+        this.threads.clear();
+    }
+    prepareEnvironment(config) {
+        const env = config.cli_env
+            ? { ...config.cli_env }
+            : { ...process.env };
+        // Sort keys for stable cache key generation
+        const sortedEnv = {};
+        for (const key of Object.keys(env).sort()) {
+            if (env[key] !== undefined) {
+                sortedEnv[key] = env[key];
+            }
+        }
+        // Inject API key
+        if (this.apiKey) {
+            sortedEnv.OPENAI_API_KEY = this.apiKey;
+            sortedEnv.CODEX_API_KEY = this.apiKey;
+        }
+        // Inject env overrides
+        if (this.env) {
+            for (const key of Object.keys(this.env).sort()) {
+                const value = this.env[key];
+                if (value !== undefined) {
+                    sortedEnv[key] = value;
+                }
+            }
+        }
+        return sortedEnv;
+    }
+    validateWorkingDirectory(workingDir, skipGitCheck = false) {
+        let stats;
+        try {
+            stats = fs_1.default.statSync(workingDir);
+        }
+        catch (err) {
+            throw new Error(`Working directory ${workingDir} does not exist or isn't accessible: ${err.message}`);
+        }
+        if (!stats.isDirectory()) {
+            throw new Error(`Working directory ${workingDir} is not a directory`);
+        }
+        if (!skipGitCheck) {
+            const gitDir = path_1.default.join(workingDir, '.git');
+            if (!fs_1.default.existsSync(gitDir)) {
+                throw new Error((0, dedent_1.default) `Working directory ${workingDir} is not a Git repository.
+
+          Codex requires a Git repository by default to prevent unrecoverable errors.
+
+          To bypass this check, set skip_git_repo_check: true in your provider config.`);
+            }
+        }
+    }
+    async getOrCreateThread(config, cacheKey) {
+        // Resume specific thread
+        if (config.thread_id) {
+            const cached = this.threads.get(config.thread_id);
+            if (cached) {
+                return cached;
+            }
+            const thread = this.codexInstance.resumeThread(config.thread_id);
+            if (config.persist_threads) {
+                this.threads.set(config.thread_id, thread);
+            }
+            return thread;
+        }
+        // Use pooled thread
+        if (config.persist_threads && cacheKey) {
+            const cached = this.threads.get(cacheKey);
+            if (cached) {
+                return cached;
+            }
+            // Enforce pool size limit
+            const poolSize = config.thread_pool_size ?? 1;
+            if (this.threads.size >= poolSize) {
+                const oldestKey = this.threads.keys().next().value;
+                if (oldestKey) {
+                    this.threads.delete(oldestKey);
+                }
+            }
+        }
+        // Create new thread
+        const thread = this.codexInstance.startThread({
+            workingDirectory: config.working_dir,
+            skipGitRepoCheck: config.skip_git_repo_check ?? false,
+            ...(config.model ? { model: config.model } : {}),
+            ...(config.additional_directories?.length
+                ? { additionalDirectories: config.additional_directories }
+                : {}),
+        });
+        if (config.persist_threads && cacheKey) {
+            this.threads.set(cacheKey, thread);
+        }
+        return thread;
+    }
+    async runStreaming(thread, prompt, runOptions, callOptions) {
+        const { events } = await thread.runStreamed(prompt, runOptions);
+        const items = [];
+        let usage = undefined;
+        for await (const event of events) {
+            // Check abort signal
+            if (callOptions?.abortSignal?.aborted) {
+                throw new Error('AbortError');
+            }
+            switch (event.type) {
+                case 'item.completed':
+                    items.push(event.item);
+                    logger_1.default.debug('Codex item completed', { item: event.item });
+                    break;
+                case 'turn.completed':
+                    usage = event.usage;
+                    logger_1.default.debug('Codex turn completed', { usage });
+                    break;
+            }
+        }
+        // Extract text from agent_message items for final response
+        const agentMessages = items.filter((i) => i.type === 'agent_message');
+        const finalResponse = agentMessages.length > 0 ? agentMessages.map((i) => i.text).join('\n') : '';
+        return {
+            finalResponse,
+            items,
+            usage,
+        };
+    }
+    generateCacheKey(config, prompt) {
+        const keyData = {
+            working_dir: config.working_dir,
+            additional_directories: config.additional_directories,
+            model: config.model,
+            output_schema: config.output_schema,
+            tool_output_token_limit: config.tool_output_token_limit,
+            prompt,
+        };
+        const hash = crypto_1.default.createHash('sha256').update(JSON.stringify(keyData)).digest('hex');
+        return `openai:codex-sdk:${hash}`;
+    }
+    async callApi(prompt, context, callOptions) {
+        // Merge configs (prompt config takes precedence)
+        const config = {
+            ...this.config,
+            ...context?.prompt?.config,
+        };
+        // Prepare environment
+        const env = this.prepareEnvironment(config);
+        if (!this.apiKey && !env.OPENAI_API_KEY && !env.CODEX_API_KEY) {
+            throw new Error('OpenAI API key is not set. Set OPENAI_API_KEY or CODEX_API_KEY environment variable or add "apiKey" to provider config.');
+        }
+        // Validate working directory
+        if (config.working_dir) {
+            this.validateWorkingDirectory(config.working_dir, config.skip_git_repo_check);
+        }
+        // Check abort signal
+        if (callOptions?.abortSignal?.aborted) {
+            return { error: 'OpenAI Codex SDK call aborted before it started' };
+        }
+        // Load SDK module (lazy)
+        if (!this.codexModule) {
+            this.codexModule = await loadCodexSDK();
+        }
+        // Initialize Codex instance (lazy)
+        if (!this.codexInstance) {
+            this.codexInstance = new this.codexModule.Codex({
+                env,
+                ...(config.codex_path_override ? { codexPathOverride: config.codex_path_override } : {}),
+            });
+        }
+        // Get or create thread
+        const cacheKey = this.generateCacheKey(config, prompt);
+        const thread = await this.getOrCreateThread(config, cacheKey);
+        // Prepare run options
+        const runOptions = {};
+        if (config.output_schema) {
+            runOptions.outputSchema = config.output_schema;
+        }
+        if (config.tool_output_token_limit !== undefined) {
+            runOptions.toolOutputTokenLimit = config.tool_output_token_limit;
+        }
+        // Execute turn
+        try {
+            const turn = config.enable_streaming
+                ? await this.runStreaming(thread, prompt, runOptions, callOptions)
+                : await thread.run(prompt, runOptions);
+            // Extract response
+            const output = turn.finalResponse || '';
+            const raw = JSON.stringify(turn);
+            const tokenUsage = turn.usage
+                ? {
+                    prompt: turn.usage.input_tokens + (turn.usage.cached_input_tokens || 0),
+                    completion: turn.usage.output_tokens,
+                    total: turn.usage.input_tokens +
+                        (turn.usage.cached_input_tokens || 0) +
+                        turn.usage.output_tokens,
+                }
+                : undefined;
+            // Calculate cost from usage
+            let cost = 0;
+            if (tokenUsage && config.model) {
+                const pricing = CODEX_MODEL_PRICING[config.model];
+                if (pricing) {
+                    // Pricing is per 1M tokens
+                    const inputCost = (tokenUsage.prompt || 0) * (pricing.input / 1000000);
+                    const outputCost = (tokenUsage.completion || 0) * (pricing.output / 1000000);
+                    cost = inputCost + outputCost;
+                }
+            }
+            logger_1.default.debug('OpenAI Codex SDK response', { output, usage: turn.usage });
+            return {
+                output,
+                tokenUsage,
+                cost,
+                raw,
+                sessionId: thread.id || 'unknown',
+            };
+        }
+        catch (error) {
+            const isAbort = error?.name === 'AbortError' || callOptions?.abortSignal?.aborted;
+            if (isAbort) {
+                logger_1.default.warn('OpenAI Codex SDK call aborted');
+                return { error: 'OpenAI Codex SDK call aborted' };
+            }
+            logger_1.default.error('Error calling OpenAI Codex SDK', { error: error.message });
+            return {
+                error: `Error calling OpenAI Codex SDK: ${error.message}`,
+            };
+        }
+        finally {
+            // Clean up ephemeral threads
+            if (!config.persist_threads && !config.thread_id && cacheKey) {
+                this.threads.delete(cacheKey);
+            }
+        }
+    }
+}
+exports.OpenAICodexSDKProvider = OpenAICodexSDKProvider;
+OpenAICodexSDKProvider.OPENAI_MODELS = [
+    // GPT-5.1 Codex models (recommended for code tasks)
+    'gpt-5.1-codex',
+    'gpt-5.1-codex-max',
+    'gpt-5.1-codex-mini',
+    // GPT-5 Codex models
+    'gpt-5-codex',
+    'gpt-5-codex-mini',
+    // GPT-5 base
+    'gpt-5',
+    // GPT-4 models
+    'gpt-4',
+    'gpt-4-turbo',
+    'gpt-4o',
+    'gpt-4o-mini',
+    // Reasoning models
+    'o1',
+    'o1-mini',
+    'o3-mini',
+];
+//# sourceMappingURL=codex-sdk.js.map

package/dist/src/providers/openai/defaults.d.ts

@@ -1,9 +1,11 @@
 import { OpenAiChatCompletionProvider } from './chat';
 import { OpenAiEmbeddingProvider } from './embedding';
 import { OpenAiModerationProvider } from './moderation';
+import { OpenAiResponsesProvider } from './responses';
 export declare const DefaultEmbeddingProvider: OpenAiEmbeddingProvider;
 export declare const DefaultGradingProvider: OpenAiChatCompletionProvider;
 export declare const DefaultGradingJsonProvider: OpenAiChatCompletionProvider;
 export declare const DefaultSuggestionsProvider: OpenAiChatCompletionProvider;
 export declare const DefaultModerationProvider: OpenAiModerationProvider;
+export declare const DefaultWebSearchProvider: OpenAiResponsesProvider;
 //# sourceMappingURL=defaults.d.ts.map

package/dist/src/providers/openai/defaults.js

@@ -1,16 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultModerationProvider = exports.DefaultSuggestionsProvider = exports.DefaultGradingJsonProvider = exports.DefaultGradingProvider = exports.DefaultEmbeddingProvider = void 0;
+exports.DefaultWebSearchProvider = exports.DefaultModerationProvider = exports.DefaultSuggestionsProvider = exports.DefaultGradingJsonProvider = exports.DefaultGradingProvider = exports.DefaultEmbeddingProvider = void 0;
 const chat_1 = require("./chat");
 const embedding_1 = require("./embedding");
 const moderation_1 = require("./moderation");
+const responses_1 = require("./responses");
 exports.DefaultEmbeddingProvider = new embedding_1.OpenAiEmbeddingProvider('text-embedding-3-large');
-exports.DefaultGradingProvider = new chat_1.OpenAiChatCompletionProvider('gpt-4.1-2025-04-14');
-exports.DefaultGradingJsonProvider = new chat_1.OpenAiChatCompletionProvider('gpt-4.1-2025-04-14', {
+exports.DefaultGradingProvider = new chat_1.OpenAiChatCompletionProvider('gpt-5-2025-08-07');
+exports.DefaultGradingJsonProvider = new chat_1.OpenAiChatCompletionProvider('gpt-5-2025-08-07', {
     config: {
         response_format: { type: 'json_object' },
     },
 });
-exports.DefaultSuggestionsProvider = new chat_1.OpenAiChatCompletionProvider('gpt-4.1-2025-04-14');
+exports.DefaultSuggestionsProvider = new chat_1.OpenAiChatCompletionProvider('gpt-5-2025-08-07');
 exports.DefaultModerationProvider = new moderation_1.OpenAiModerationProvider('omni-moderation-latest');
+exports.DefaultWebSearchProvider = new responses_1.OpenAiResponsesProvider('gpt-5.1', {
+    config: {
+        tools: [{ type: 'web_search_preview' }],
+    },
+});
 //# sourceMappingURL=defaults.js.map

package/dist/src/providers/registry.js

@@ -68,6 +68,7 @@ const foundry_agent_1 = require("./azure/foundry-agent");
 const moderation_1 = require("./azure/moderation");
 const responses_1 = require("./azure/responses");
 const index_4 = require("./bedrock/index");
+const converse_1 = require("./bedrock/converse");
 const browser_1 = require("./browser");
 const cerebras_1 = require("./cerebras");
 const cloudera_1 = require("./cloudera");
@@ -83,7 +84,7 @@ const ai_studio_1 = require("./google/ai.studio");
 const image_1 = require("./google/image");
 const live_1 = require("./google/live");
 const vertex_1 = require("./google/vertex");
-const groq_1 = require("./groq");
+const index_6 = require("./groq/index");
 const helicone_1 = require("./helicone");
 const http_1 = require("./http");
 const huggingface_1 = require("./huggingface");
@@ -92,11 +93,10 @@ const llama_1 = require("./llama");
 const llamaApi_1 = require("./llamaApi");
 const localai_1 = require("./localai");
 const manualInput_1 = require("./manualInput");
-const index_6 = require("./mcp/index");
+const index_7 = require("./mcp/index");
 const mistral_1 = require("./mistral");
 const nscale_1 = require("./nscale");
 const ollama_1 = require("./ollama");
-const agents_1 = require("./openai/agents");
 const assistant_2 = require("./openai/assistant");
 const chat_2 = require("./openai/chat");
 const completion_3 = require("./openai/completion");
@@ -126,6 +126,7 @@ const webhook_1 = require("./webhook");
 const websocket_1 = require("./websocket");
 const chat_3 = require("./xai/chat");
 const image_3 = require("./xai/image");
+const responses_3 = require("./xai/responses");
 exports.providerMap = [
     (0, scriptBasedProvider_1.createScriptBasedProviderFactory)('exec', null, scriptCompletion_1.ScriptCompletionProvider),
     (0, scriptBasedProvider_1.createScriptBasedProviderFactory)('golang', 'go', golangCompletion_1.GolangProvider),
@@ -270,6 +271,10 @@ exports.providerMap = [
             const splits = providerPath.split(':');
             const modelType = splits[1];
             const modelName = splits.slice(2).join(':');
+            // Handle Converse API
+            if (modelType === 'converse') {
+                return new converse_1.AwsBedrockConverseProvider(modelName, providerOptions);
+            }
             // Handle nova-sonic model
             if (modelType === 'nova-sonic' || modelType.includes('amazon.nova-sonic')) {
                 const { NovaSonicProvider } = await Promise.resolve().then(() => __importStar(require('./bedrock/nova-sonic')));
@@ -469,8 +474,22 @@ exports.providerMap = [
     {
         test: (providerPath) => providerPath.startsWith('groq:'),
         create: async (providerPath, providerOptions, _context) => {
-            const modelName = providerPath.split(':')[1];
-            return new groq_1.GroqProvider(modelName, providerOptions);
+            // Handle groq:responses:<model> format for Responses API
+            if (providerPath.startsWith('groq:responses:')) {
+                const modelName = providerPath.slice('groq:responses:'.length);
+                if (!modelName) {
+                    throw new Error(`Invalid groq:responses provider path: "${providerPath}". ` +
+                        'Use format groq:responses:<model> (e.g., groq:responses:llama-3.3-70b-versatile)');
+                }
+                return new index_6.GroqResponsesProvider(modelName, providerOptions);
+            }
+            // Handle groq:<model> format for Chat Completions API
+            const modelName = providerPath.slice('groq:'.length);
+            if (!modelName) {
+                throw new Error(`Invalid groq provider path: "${providerPath}". ` +
+                    'Use format groq:<model> (e.g., groq:llama-3.3-70b-versatile)');
+            }
+            return new index_6.GroqProvider(modelName, providerOptions);
         },
     },
     {
@@ -583,11 +602,19 @@ exports.providerMap = [
     },
     {
         test: (providerPath) => providerPath.startsWith('openai:'),
-        create: async (providerPath, providerOptions, _context) => {
+        create: async (providerPath, providerOptions, context) => {
             // Load OpenAI module
             const splits = providerPath.split(':');
             const modelType = splits[1];
             const modelName = splits.slice(2).join(':');
+            // Codex SDK providers (openai:codex-sdk or openai:codex)
+            if (modelType === 'codex-sdk' || modelType === 'codex') {
+                const { OpenAICodexSDKProvider } = await Promise.resolve().then(() => __importStar(require('./openai/codex-sdk')));
+                return new OpenAICodexSDKProvider({
+                    ...providerOptions,
+                    env: context.env,
+                });
+            }
             if (modelType === 'chat') {
                 return new chat_2.OpenAiChatCompletionProvider(modelName || 'gpt-4.1-2025-04-14', providerOptions);
             }
@@ -623,7 +650,12 @@ exports.providerMap = [
                 return new responses_2.OpenAiResponsesProvider(modelType, providerOptions);
             }
             if (modelType === 'agents') {
-                return new agents_1.OpenAiAgentsProvider(modelName || 'default-agent', providerOptions);
+                const { OpenAiAgentsProvider } = await Promise.resolve().then(() => __importStar(require('./openai/agents')));
+                return new OpenAiAgentsProvider(modelName || 'default-agent', providerOptions);
+            }
+            if (modelType === 'chatkit') {
+                const { OpenAiChatKitProvider } = await Promise.resolve().then(() => __importStar(require('./openai/chatkit')));
+                return new OpenAiChatKitProvider(modelName || '', providerOptions);
             }
             if (modelType === 'assistant') {
                 return new assistant_2.OpenAiAssistantProvider(modelName, providerOptions);
@@ -632,7 +664,7 @@ exports.providerMap = [
                 return new image_2.OpenAiImageProvider(modelName, providerOptions);
             }
             // Assume user did not provide model type, and it's a chat model
-            logger_1.default.warn(`Unknown OpenAI model type: ${modelType}. Treating it as a chat model. Use one of the following providers: openai:chat:<model name>, openai:completion:<model name>, openai:embeddings:<model name>, openai:image:<model name>, openai:realtime:<model name>, openai:agents:<agent name>`);
+            logger_1.default.warn(`Unknown OpenAI model type: ${modelType}. Treating it as a chat model. Use one of the following providers: openai:chat:<model name>, openai:completion:<model name>, openai:embeddings:<model name>, openai:image:<model name>, openai:realtime:<model name>, openai:agents:<agent name>, openai:chatkit:<workflow_id>, openai:codex-sdk`);
             return new chat_2.OpenAiChatCompletionProvider(modelType, providerOptions);
         },
     },
@@ -789,6 +821,13 @@ exports.providerMap = [
                     env: context.env,
                 });
             }
+            // Handle xai:responses:<model> format for Agent Tools API
+            if (modelType === 'responses') {
+                return (0, responses_3.createXAIResponsesProvider)(providerPath, {
+                    ...providerOptions,
+                    env: context.env,
+                });
+            }
             // Handle regular xai:<model> format
             return (0, chat_3.createXAIProvider)(providerPath, {
                 config: providerOptions,
@@ -877,7 +916,7 @@ exports.providerMap = [
                     serverName,
                 };
             }
-            return new index_6.MCPProvider({
+            return new index_7.MCPProvider({
                 config,
                 id: providerOptions.id,
             });

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

@@ -1,7 +1,7 @@
 import type { FunctionCallbackHandler } from '../functionCallbackUtils';
 export interface ProcessorConfig {
     modelName: string;
-    providerType: 'openai' | 'azure';
+    providerType: 'openai' | 'azure' | 'xai';
     functionCallbackHandler: FunctionCallbackHandler;
     costCalculator: (modelName: string, usage: any, config?: any) => number;
 }

package/dist/src/providers/sagemaker.d.ts

@@ -40,11 +40,11 @@ declare const SageMakerConfigSchema: z.ZodObject<{
     basePath?: string | undefined;
     maxTokens?: number | undefined;
     temperature?: number | undefined;
-    contentType?: string | undefined;
     accessKeyId?: string | undefined;
     secretAccessKey?: string | undefined;
     sessionToken?: string | undefined;
     region?: string | undefined;
+    contentType?: string | undefined;
     topP?: number | undefined;
     stopSequences?: string[] | undefined;
     responseFormat?: {
@@ -61,11 +61,11 @@ declare const SageMakerConfigSchema: z.ZodObject<{
     basePath?: string | undefined;
     maxTokens?: number | undefined;
     temperature?: number | undefined;
-    contentType?: string | undefined;
     accessKeyId?: string | undefined;
     secretAccessKey?: string | undefined;
     sessionToken?: string | undefined;
     region?: string | undefined;
+    contentType?: string | undefined;
     topP?: number | undefined;
     stopSequences?: string[] | undefined;
     responseFormat?: {