return params.effort;

}

function isOpenAICodexResponsesModel(model: Model<Api>): boolean {

return model.provider === "openai-codex" && model.api === "openai-codex-responses";

}

function buildOpenAICodexResponsesInstructions(context: Context): string | undefined {

if (!context.systemPrompt) {

return undefined;

}

return sanitizeTransportPayloadText(stripSystemPromptCacheBoundary(context.systemPrompt));

}

export function buildOpenAIResponsesParams(

model: Model<Api>,

context: Context,

options: OpenAIResponsesOptions | undefined,

metadata?: Record<string, string>,

) {

const isCodexResponses = isOpenAICodexResponsesModel(model);

const compat = getCompat(model as OpenAIModeModel);

const supportsDeveloperRole =

typeof compat.supportsDeveloperRole === "boolean" ? compat.supportsDeveloperRole : undefined;

const messages = convertResponsesMessages(

model,

context,

new Set(["openai", "openai-codex", "opencode", "azure-openai-responses"]),

{ supportsDeveloperRole },

{ includeSystemPrompt: !isCodexResponses, supportsDeveloperRole },

);

const cacheRetention = resolveCacheRetention(options?.cacheRetention);

const payloadPolicy = resolveOpenAIResponsesPayloadPolicy(model, {

stream: true,

prompt_cache_key: cacheRetention === "none" ? undefined : options?.sessionId,

prompt_cache_retention: getPromptCacheRetention(model.baseUrl, cacheRetention),

...(isCodexResponses ? { instructions: buildOpenAICodexResponsesInstructions(context) } : {}),

...(metadata ? { metadata } : {}),

};

if (options?.maxTokens) {

model: string;

input: ResponseInput;

stream: true;

instructions?: string;

prompt_cache_key?: string;

prompt_cache_retention?: "24h";

metadata?: Record<string, string>;