promptopskit 0.3.7 → 0.3.9

package/dist/index.cjs

@@ -51,6 +51,7 @@ __export(src_exports, {
   interpolate: () => interpolate,
   loadPromptFile: () => loadPromptFile,
   openaiAdapter: () => openaiAdapter,
+  openaiResponsesAdapter: () => openaiResponsesAdapter,
   openrouterAdapter: () => openrouterAdapter,
   parsePrompt: () => parsePrompt,
   renderPrompt: () => renderPrompt,
@@ -144,6 +145,20 @@ function mergeOverride(base, override) {
   if (override.response !== void 0) {
     result.response = { ...result.response, ...override.response };
   }
+  if (override.provider_options !== void 0) {
+    result.provider_options = {
+      ...result.provider_options,
+      ...override.provider_options,
+      anthropic: {
+        ...result.provider_options?.anthropic,
+        ...override.provider_options.anthropic
+      },
+      gemini: {
+        ...result.provider_options?.gemini,
+        ...override.provider_options.gemini
+      }
+    };
+  }
   return result;
 }
 
@@ -246,7 +261,47 @@ var SamplingSchema = import_zod.z.object({
 });
 var ResponseSchema = import_zod.z.object({
   format: import_zod.z.enum(["text", "json", "markdown"]).optional(),
-  stream: import_zod.z.boolean().optional()
+  stream: import_zod.z.boolean().optional(),
+  schema: import_zod.z.record(import_zod.z.unknown()).optional(),
+  schema_name: import_zod.z.string().optional(),
+  schema_strict: import_zod.z.boolean().optional()
+});
+var AnthropicProviderOptionsSchema = import_zod.z.object({
+  top_k: import_zod.z.number().int().min(0).optional(),
+  tool_choice: import_zod.z.record(import_zod.z.unknown()).optional()
+});
+var GeminiProviderOptionsSchema = import_zod.z.object({
+  candidate_count: import_zod.z.number().int().positive().optional(),
+  top_k: import_zod.z.number().int().min(0).optional(),
+  seed: import_zod.z.number().int().optional(),
+  response_schema: import_zod.z.record(import_zod.z.unknown()).optional(),
+  response_modalities: import_zod.z.array(import_zod.z.string()).optional(),
+  thinking_budget_tokens: import_zod.z.number().int().positive().optional()
+});
+var ProviderOptionsSchema = import_zod.z.object({
+  anthropic: AnthropicProviderOptionsSchema.optional(),
+  gemini: GeminiProviderOptionsSchema.optional()
+});
+var OpenAICacheSchema = import_zod.z.object({
+  prompt_cache_key: import_zod.z.string().min(1).optional(),
+  retention: import_zod.z.enum(["in_memory", "24h"]).optional()
+});
+var AnthropicCacheSchema = import_zod.z.object({
+  mode: import_zod.z.enum(["automatic", "explicit"]).optional(),
+  type: import_zod.z.literal("ephemeral").optional(),
+  ttl: import_zod.z.enum(["5m", "1h"]).optional(),
+  cache_system_instructions: import_zod.z.boolean().optional(),
+  cache_tools: import_zod.z.boolean().optional(),
+  cache_prompt_template: import_zod.z.boolean().optional()
+});
+var GeminiCacheSchema = import_zod.z.object({
+  cached_content: import_zod.z.string().min(1).optional()
+});
+var CacheSchema = import_zod.z.object({
+  openai: OpenAICacheSchema.optional(),
+  anthropic: AnthropicCacheSchema.optional(),
+  gemini: GeminiCacheSchema.optional(),
+  google: GeminiCacheSchema.optional()
 });
 var HistorySchema = import_zod.z.object({
   max_items: import_zod.z.number().int().positive().optional()
@@ -255,7 +310,14 @@ var ContextRegexSchema = import_zod.z.union([
   import_zod.z.string(),
   import_zod.z.object({
     pattern: import_zod.z.string(),
-    flags: import_zod.z.string().optional()
+    flags: import_zod.z.string().optional(),
+    return_message: import_zod.z.string().optional()
+  })
+]);
+var ContextBuiltInValidatorSchema = import_zod.z.union([
+  import_zod.z.boolean(),
+  import_zod.z.object({
+    return_message: import_zod.z.string().optional()
   })
 ]);
 var ContextInputDefinitionObjectSchema = import_zod.z.object({
@@ -264,8 +326,8 @@ var ContextInputDefinitionObjectSchema = import_zod.z.object({
   trim: import_zod.z.union([import_zod.z.boolean(), import_zod.z.enum(["start", "end", "both"])]).optional(),
   allow_regex: ContextRegexSchema.optional(),
   deny_regex: ContextRegexSchema.optional(),
-  non_empty: import_zod.z.boolean().optional(),
-  reject_secrets: import_zod.z.boolean().optional()
+  non_empty: ContextBuiltInValidatorSchema.optional(),
+  reject_secrets: ContextBuiltInValidatorSchema.optional()
 });
 var ContextInputDefinitionSchema = import_zod.z.union([
   import_zod.z.string(),
@@ -290,7 +352,9 @@ var PromptAssetOverridesSchema = import_zod.z.object({
   reasoning: ReasoningSchema.optional(),
   sampling: SamplingSchema.optional(),
   response: ResponseSchema.optional(),
-  tools: import_zod.z.array(ToolRefSchema).optional()
+  cache: CacheSchema.optional(),
+  tools: import_zod.z.array(ToolRefSchema).optional(),
+  provider_options: ProviderOptionsSchema.optional()
 });
 var SourceSchema = import_zod.z.object({
   file_path: import_zod.z.string().optional(),
@@ -302,8 +366,9 @@ var SectionsSchema = import_zod.z.object({
   notes: import_zod.z.string().optional()
 });
 var PromptDefaultsSchema = import_zod.z.object({
-  provider: import_zod.z.enum(["openai", "anthropic", "google", "gemini", "openrouter", "any"]).optional(),
+  provider: import_zod.z.enum(["openai", "openai-responses", "anthropic", "google", "gemini", "openrouter", "any"]).optional(),
   model: import_zod.z.string().optional(),
+  cache: CacheSchema.optional(),
   metadata: MetadataSchema.optional(),
   sections: import_zod.z.object({
     system_instructions: import_zod.z.string().optional()
@@ -313,13 +378,15 @@ var PromptAssetSchema = import_zod.z.object({
   id: import_zod.z.string(),
   schema_version: import_zod.z.number().int().positive().default(1),
   description: import_zod.z.string().optional(),
-  provider: import_zod.z.enum(["openai", "anthropic", "google", "gemini", "openrouter", "any"]).optional(),
+  provider: import_zod.z.enum(["openai", "openai-responses", "anthropic", "google", "gemini", "openrouter", "any"]).optional(),
   model: import_zod.z.string().optional(),
   fallback_models: import_zod.z.array(import_zod.z.string()).optional(),
   reasoning: ReasoningSchema.optional(),
   sampling: SamplingSchema.optional(),
   response: ResponseSchema.optional(),
+  cache: CacheSchema.optional(),
   tools: import_zod.z.array(ToolRefSchema).optional(),
+  provider_options: ProviderOptionsSchema.optional(),
   mcp: MCPSchema.optional(),
   context: ContextSchema.optional(),
   includes: import_zod.z.array(import_zod.z.string()).optional(),
@@ -628,8 +695,8 @@ function normalizeContextInput(input) {
     trim: input.trim,
     allow_regex: normalizeContextRegex(input.allow_regex),
     deny_regex: normalizeContextRegex(input.deny_regex),
-    non_empty: input.non_empty,
-    reject_secrets: input.reject_secrets
+    non_empty: normalizeBuiltInValidator(input.non_empty),
+    reject_secrets: normalizeBuiltInValidator(input.reject_secrets)
   };
 }
 function normalizeContextRegex(value) {
@@ -655,7 +722,19 @@ function normalizeContextRegex(value) {
   return {
     pattern: value.pattern,
     flags: value.flags ?? "",
-    raw: JSON.stringify(value)
+    raw: JSON.stringify(value),
+    returnMessage: value.return_message
+  };
+}
+function normalizeBuiltInValidator(value) {
+  if (value === void 0 || value === false) {
+    return void 0;
+  }
+  if (value === true) {
+    return {};
+  }
+  return {
+    returnMessage: value.return_message
   };
 }
 function parseRegexLiteral(value) {
@@ -787,6 +866,17 @@ function sanitizeContextVariables(asset, variables = {}, options = {}) {
         field: "allow_regex"
       });
       if (!matcher.test(candidate2)) {
+        if (input.allow_regex.returnMessage) {
+          return {
+            variables: sanitized,
+            shortCircuit: {
+              returnMessage: input.allow_regex.returnMessage,
+              code: "POK031",
+              variable: input.name,
+              field: "allow_regex"
+            }
+          };
+        }
         throw new Error(
           `POK031: Context variable "${input.name}" failed allow_regex validation for prompt "${asset.id}".`
         );
@@ -800,12 +890,34 @@ function sanitizeContextVariables(asset, variables = {}, options = {}) {
         field: "deny_regex"
       });
       if (matcher.test(candidate2)) {
+        if (input.deny_regex.returnMessage) {
+          return {
+            variables: sanitized,
+            shortCircuit: {
+              returnMessage: input.deny_regex.returnMessage,
+              code: "POK032",
+              variable: input.name,
+              field: "deny_regex"
+            }
+          };
+        }
         throw new Error(
           `POK032: Context variable "${input.name}" matched deny_regex for prompt "${asset.id}".`
         );
       }
     }
     if (input.non_empty && candidate.trim().length === 0) {
+      if (input.non_empty.returnMessage) {
+        return {
+          variables: sanitized,
+          shortCircuit: {
+            returnMessage: input.non_empty.returnMessage,
+            code: "POK033",
+            variable: input.name,
+            field: "non_empty"
+          }
+        };
+      }
       throw new Error(
         `POK033: Context variable "${input.name}" failed non_empty validation for prompt "${asset.id}".`
       );
@@ -817,13 +929,24 @@ function sanitizeContextVariables(asset, variables = {}, options = {}) {
         field: "reject_secrets"
       });
       if (matcher.test(candidate)) {
+        if (input.reject_secrets.returnMessage) {
+          return {
+            variables: sanitized,
+            shortCircuit: {
+              returnMessage: input.reject_secrets.returnMessage,
+              code: "POK034",
+              variable: input.name,
+              field: "reject_secrets"
+            }
+          };
+        }
         throw new Error(
           `POK034: Context variable "${input.name}" matched reject_secrets validation for prompt "${asset.id}".`
         );
       }
     }
   }
-  return sanitized;
+  return { variables: sanitized };
 }
 function measureContextValueSize(value) {
   return textEncoder.encode(value).length;
@@ -873,12 +996,19 @@ function withPromptInputSupport(adapter) {
   };
   const renderPrompt2 = async (input, runtime) => {
     const resolved = await resolveProviderPromptInput(input, runtime);
-    const variables = sanitizeContextVariables(resolved, runtime.variables, {
+    const sanitization = sanitizeContextVariables(resolved, runtime.variables, {
       onContextOverflow: runtime.onContextOverflow
     });
+    if (sanitization.shortCircuit) {
+      return {
+        provider: adapter.name,
+        model: resolved.model ?? "",
+        returnMessage: sanitization.shortCircuit.returnMessage
+      };
+    }
     return adapter.render(resolved, {
       ...runtime,
-      variables
+      variables: sanitization.variables
     });
   };
   return {
@@ -901,6 +1031,9 @@ var openaiAdapter = withPromptInputSupport({
     if (resolvedAsset.reasoning?.budget_tokens !== void 0) {
       warnings.push("OpenAI uses reasoning_effort, not budget_tokens. budget_tokens will be ignored.");
     }
+    if (resolvedAsset.response?.schema !== void 0 && resolvedAsset.response?.format !== "json") {
+      warnings.push("OpenAI response.schema requires response.format: json. schema will still be applied as JSON schema output.");
+    }
     return { valid: errors.length === 0, errors, warnings };
   },
   render(asset, runtime) {
@@ -925,6 +1058,7 @@ var openaiAdapter = withPromptInputSupport({
       model: resolvedAsset.model,
       messages
     };
+    const openaiCacheConfig = resolvedAsset.cache?.openai;
     if (resolvedAsset.sampling?.temperature !== void 0) body.temperature = resolvedAsset.sampling.temperature;
     if (resolvedAsset.sampling?.top_p !== void 0) body.top_p = resolvedAsset.sampling.top_p;
     if (resolvedAsset.sampling?.frequency_penalty !== void 0) body.frequency_penalty = resolvedAsset.sampling.frequency_penalty;
@@ -934,12 +1068,27 @@ var openaiAdapter = withPromptInputSupport({
     if (resolvedAsset.reasoning?.effort) {
       body.reasoning_effort = resolvedAsset.reasoning.effort;
     }
-    if (resolvedAsset.response?.format === "json") {
+    if (resolvedAsset.response?.schema) {
+      body.response_format = {
+        type: "json_schema",
+        json_schema: {
+          name: resolvedAsset.response.schema_name ?? `${resolvedAsset.id}_response`,
+          schema: resolvedAsset.response.schema,
+          strict: resolvedAsset.response.schema_strict ?? true
+        }
+      };
+    } else if (resolvedAsset.response?.format === "json") {
       body.response_format = { type: "json_object" };
     }
     if (resolvedAsset.response?.stream !== void 0) {
       body.stream = resolvedAsset.response.stream;
     }
+    if (openaiCacheConfig?.prompt_cache_key) {
+      body.prompt_cache_key = openaiCacheConfig.prompt_cache_key;
+    }
+    if (openaiCacheConfig?.retention) {
+      body.prompt_cache_retention = openaiCacheConfig.retention;
+    }
     if (resolvedAsset.tools && resolvedAsset.tools.length > 0) {
       body.tools = resolvedAsset.tools.map((tool) => {
         if (typeof tool === "string") {
@@ -965,6 +1114,107 @@ var openaiAdapter = withPromptInputSupport({
   }
 });
 
+// src/providers/openai-responses.ts
+var openaiResponsesAdapter = withPromptInputSupport({
+  name: "openai-responses",
+  validate(asset, runtime) {
+    const resolvedAsset = resolveAssetForProvider(asset, runtime);
+    const errors = [];
+    const warnings = [];
+    if (!resolvedAsset.model) {
+      errors.push("OpenAI Responses adapter requires a model to be specified.");
+    }
+    if (resolvedAsset.reasoning?.budget_tokens !== void 0) {
+      warnings.push("OpenAI Responses uses reasoning.effort, not budget_tokens. budget_tokens will be ignored.");
+    }
+    if (resolvedAsset.response?.schema !== void 0 && resolvedAsset.response?.format !== "json") {
+      warnings.push("OpenAI Responses response.schema requires response.format: json. schema will still be applied as JSON schema output.");
+    }
+    if (runtime?.openaiResponses?.conversation !== void 0 && runtime?.openaiResponses?.previous_response_id !== void 0) {
+      errors.push('OpenAI Responses options "conversation" and "previous_response_id" cannot both be set.');
+    }
+    return { valid: errors.length === 0, errors, warnings };
+  },
+  render(asset, runtime) {
+    const resolvedAsset = resolveAssetForProvider(asset, runtime);
+    const sections = renderSections(resolvedAsset, {
+      variables: runtime.variables,
+      strict: runtime.strict
+    });
+    const responseOptions = runtime.openaiResponses;
+    const input = [];
+    if (runtime.history) {
+      for (const msg of runtime.history) {
+        input.push({ role: msg.role, content: msg.content });
+      }
+    }
+    if (sections.prompt_template) {
+      input.push({ role: "user", content: sections.prompt_template });
+    }
+    const body = {
+      model: resolvedAsset.model,
+      input
+    };
+    if (responseOptions?.instructions !== void 0) {
+      body.instructions = responseOptions.instructions;
+    } else if (sections.system_instructions) {
+      body.instructions = sections.system_instructions;
+    }
+    if (resolvedAsset.sampling?.temperature !== void 0) body.temperature = resolvedAsset.sampling.temperature;
+    if (resolvedAsset.sampling?.top_p !== void 0) body.top_p = resolvedAsset.sampling.top_p;
+    if (resolvedAsset.sampling?.frequency_penalty !== void 0) body.frequency_penalty = resolvedAsset.sampling.frequency_penalty;
+    if (resolvedAsset.sampling?.presence_penalty !== void 0) body.presence_penalty = resolvedAsset.sampling.presence_penalty;
+    if (resolvedAsset.sampling?.stop !== void 0) body.stop = resolvedAsset.sampling.stop;
+    if (resolvedAsset.sampling?.max_output_tokens !== void 0) body.max_output_tokens = resolvedAsset.sampling.max_output_tokens;
+    if (resolvedAsset.reasoning?.effort) {
+      body.reasoning = { effort: resolvedAsset.reasoning.effort };
+    }
+    if (resolvedAsset.response?.schema) {
+      body.text = {
+        format: {
+          type: "json_schema",
+          name: resolvedAsset.response.schema_name ?? `${resolvedAsset.id}_response`,
+          schema: resolvedAsset.response.schema,
+          strict: resolvedAsset.response.schema_strict ?? true
+        }
+      };
+    } else if (resolvedAsset.response?.format === "json") {
+      body.text = { format: { type: "json_object" } };
+    }
+    if (resolvedAsset.response?.stream !== void 0) {
+      body.stream = resolvedAsset.response.stream;
+    }
+    if (resolvedAsset.tools && resolvedAsset.tools.length > 0) {
+      body.tools = resolvedAsset.tools.map((tool) => {
+        if (typeof tool === "string") {
+          const def = runtime.toolRegistry?.[tool];
+          if (def) return def;
+          return { type: "function", name: tool };
+        }
+        return {
+          type: "function",
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.input_schema
+        };
+      });
+    }
+    if (responseOptions?.previous_response_id !== void 0) body.previous_response_id = responseOptions.previous_response_id;
+    if (responseOptions?.conversation !== void 0) body.conversation = responseOptions.conversation;
+    if (responseOptions?.parallel_tool_calls !== void 0) body.parallel_tool_calls = responseOptions.parallel_tool_calls;
+    if (responseOptions?.max_tool_calls !== void 0) body.max_tool_calls = responseOptions.max_tool_calls;
+    if (responseOptions?.store !== void 0) body.store = responseOptions.store;
+    if (responseOptions?.metadata !== void 0) body.metadata = responseOptions.metadata;
+    if (responseOptions?.include !== void 0) body.include = responseOptions.include;
+    if (responseOptions?.background !== void 0) body.background = responseOptions.background;
+    return {
+      body,
+      provider: "openai-responses",
+      model: resolvedAsset.model ?? "unknown"
+    };
+  }
+});
+
 // src/providers/anthropic.ts
 var anthropicAdapter = withPromptInputSupport({
   name: "anthropic",
@@ -984,6 +1234,12 @@ var anthropicAdapter = withPromptInputSupport({
     if (resolvedAsset.reasoning?.effort !== void 0) {
       warnings.push("Anthropic uses budget_tokens for thinking, not effort. effort will be mapped approximately.");
     }
+    if (resolvedAsset.response?.schema !== void 0) {
+      warnings.push("Anthropic does not support response.schema structured output in this adapter. It will be ignored.");
+    }
+    if (resolvedAsset.provider_options?.anthropic?.top_k !== void 0 && resolvedAsset.provider_options.anthropic.top_k < 0) {
+      errors.push("Anthropic provider_options.top_k must be >= 0.");
+    }
     return { valid: errors.length === 0, errors, warnings };
   },
   render(asset, runtime) {
@@ -993,20 +1249,38 @@ var anthropicAdapter = withPromptInputSupport({
       strict: runtime.strict
     });
     const messages = [];
+    const anthropicCacheConfig = resolvedAsset.cache?.anthropic;
+    const cacheType = anthropicCacheConfig?.type ?? "ephemeral";
+    const cacheControl = anthropicCacheConfig ? {
+      type: cacheType,
+      ...anthropicCacheConfig.ttl ? { ttl: anthropicCacheConfig.ttl } : {}
+    } : void 0;
+    const cacheMode = anthropicCacheConfig?.mode ?? "automatic";
     if (runtime.history) {
       for (const msg of runtime.history) {
         messages.push({ role: msg.role, content: msg.content });
       }
     }
     if (sections.prompt_template) {
-      messages.push({ role: "user", content: sections.prompt_template });
+      if (cacheControl && cacheMode === "explicit" && anthropicCacheConfig?.cache_prompt_template) {
+        messages.push({
+          role: "user",
+          content: [{ type: "text", text: sections.prompt_template, cache_control: cacheControl }]
+        });
+      } else {
+        messages.push({ role: "user", content: sections.prompt_template });
+      }
     }
     const body = {
       model: resolvedAsset.model,
       messages
     };
     if (sections.system_instructions) {
-      body.system = sections.system_instructions;
+      if (cacheControl && cacheMode === "explicit" && anthropicCacheConfig?.cache_system_instructions !== false) {
+        body.system = [{ type: "text", text: sections.system_instructions, cache_control: cacheControl }];
+      } else {
+        body.system = sections.system_instructions;
+      }
     }
     if (resolvedAsset.sampling?.temperature !== void 0) body.temperature = resolvedAsset.sampling.temperature;
     if (resolvedAsset.sampling?.top_p !== void 0) body.top_p = resolvedAsset.sampling.top_p;
@@ -1022,23 +1296,41 @@ var anthropicAdapter = withPromptInputSupport({
         budget_tokens: resolvedAsset.reasoning.budget_tokens
       };
     }
+    if (resolvedAsset.provider_options?.anthropic?.top_k !== void 0) {
+      body.top_k = resolvedAsset.provider_options.anthropic.top_k;
+    }
     if (resolvedAsset.response?.stream !== void 0) {
       body.stream = resolvedAsset.response.stream;
     }
+    if (cacheControl && cacheMode === "automatic") {
+      body.cache_control = cacheControl;
+    }
     if (resolvedAsset.tools && resolvedAsset.tools.length > 0) {
       body.tools = resolvedAsset.tools.map((tool) => {
         if (typeof tool === "string") {
           const def = runtime.toolRegistry?.[tool];
-          if (def) return def;
-          return { name: tool };
+          if (def) {
+            if (cacheControl && cacheMode === "explicit" && anthropicCacheConfig?.cache_tools) {
+              return { ...def, cache_control: cacheControl };
+            }
+            return def;
+          }
+          return {
+            name: tool,
+            ...cacheControl && cacheMode === "explicit" && anthropicCacheConfig?.cache_tools ? { cache_control: cacheControl } : {}
+          };
         }
         return {
           name: tool.name,
           description: tool.description,
-          input_schema: tool.input_schema ?? { type: "object", properties: {} }
+          input_schema: tool.input_schema ?? { type: "object", properties: {} },
+          ...cacheControl && cacheMode === "explicit" && anthropicCacheConfig?.cache_tools ? { cache_control: cacheControl } : {}
         };
       });
     }
+    if (resolvedAsset.provider_options?.anthropic?.tool_choice !== void 0) {
+      body.tool_choice = resolvedAsset.provider_options.anthropic.tool_choice;
+    }
     return {
       body,
       provider: "anthropic",
@@ -1054,6 +1346,8 @@ var geminiAdapter = withPromptInputSupport({
     const resolvedAsset = resolveAssetForProvider(asset, runtime);
     const errors = [];
     const warnings = [];
+    const geminiCache = resolvedAsset.cache?.gemini?.cached_content;
+    const googleCache = resolvedAsset.cache?.google?.cached_content;
     if (!resolvedAsset.model) {
       errors.push("Gemini adapter requires a model to be specified.");
     }
@@ -1063,6 +1357,12 @@ var geminiAdapter = withPromptInputSupport({
     if (resolvedAsset.sampling?.presence_penalty !== void 0) {
       warnings.push("Gemini does not support presence_penalty. It will be ignored.");
     }
+    if (geminiCache && googleCache && geminiCache !== googleCache) {
+      warnings.push("Both cache.gemini.cached_content and cache.google.cached_content are set. Gemini uses cache.gemini.cached_content.");
+    }
+    if (resolvedAsset.response?.stream !== void 0) {
+      warnings.push("Gemini streaming is endpoint-based (streamGenerateContent), not body-based. response.stream will be ignored.");
+    }
     return { valid: errors.length === 0, errors, warnings };
   },
   render(asset, runtime) {
@@ -1089,20 +1389,32 @@ var geminiAdapter = withPromptInputSupport({
     const body = {
       contents
     };
+    const geminiCacheConfig = resolvedAsset.cache?.gemini ?? resolvedAsset.cache?.google;
     if (sections.system_instructions) {
       body.systemInstruction = {
         parts: [{ text: sections.system_instructions }]
       };
     }
     const generationConfig = {};
+    const geminiOptions = resolvedAsset.provider_options?.gemini;
     if (resolvedAsset.sampling?.temperature !== void 0) generationConfig.temperature = resolvedAsset.sampling.temperature;
     if (resolvedAsset.sampling?.top_p !== void 0) generationConfig.topP = resolvedAsset.sampling.top_p;
     if (resolvedAsset.sampling?.max_output_tokens !== void 0) generationConfig.maxOutputTokens = resolvedAsset.sampling.max_output_tokens;
     if (resolvedAsset.sampling?.stop !== void 0) generationConfig.stopSequences = resolvedAsset.sampling.stop;
+    if (geminiOptions?.candidate_count !== void 0) generationConfig.candidateCount = geminiOptions.candidate_count;
+    if (geminiOptions?.top_k !== void 0) generationConfig.topK = geminiOptions.top_k;
+    if (geminiOptions?.seed !== void 0) generationConfig.seed = geminiOptions.seed;
+    if (geminiOptions?.response_schema !== void 0) generationConfig.responseSchema = geminiOptions.response_schema;
+    if (geminiOptions?.response_modalities !== void 0) generationConfig.responseModalities = geminiOptions.response_modalities;
+    if (resolvedAsset.response?.schema !== void 0) generationConfig.responseSchema = resolvedAsset.response.schema;
     if (resolvedAsset.response?.format === "json") {
       generationConfig.responseMimeType = "application/json";
     }
-    if (resolvedAsset.reasoning?.effort) {
+    if (geminiOptions?.thinking_budget_tokens !== void 0) {
+      body.thinkingConfig = {
+        thinkingBudget: geminiOptions.thinking_budget_tokens
+      };
+    } else if (resolvedAsset.reasoning?.effort) {
       body.thinkingConfig = {
         thinkingBudget: resolvedAsset.reasoning.effort === "high" ? 8192 : resolvedAsset.reasoning.effort === "medium" ? 4096 : 1024
       };
@@ -1110,6 +1422,9 @@ var geminiAdapter = withPromptInputSupport({
     if (Object.keys(generationConfig).length > 0) {
       body.generationConfig = generationConfig;
     }
+    if (geminiCacheConfig?.cached_content) {
+      body.cachedContent = geminiCacheConfig.cached_content;
+    }
     if (resolvedAsset.tools && resolvedAsset.tools.length > 0) {
       const functionDeclarations = resolvedAsset.tools.map((tool) => {
         if (typeof tool === "string") {
@@ -1151,6 +1466,7 @@ var openrouterAdapter = withPromptInputSupport({
 // src/providers/index.ts
 var adapters = {
   openai: openaiAdapter,
+  "openai-responses": openaiResponsesAdapter,
   anthropic: anthropicAdapter,
   google: geminiAdapter,
   gemini: geminiAdapter,
@@ -1205,7 +1521,8 @@ var KNOWN_FRONT_MATTER_KEYS = /* @__PURE__ */ new Set([
   "includes",
   "environments",
   "tiers",
-  "metadata"
+  "metadata",
+  "cache"
 ]);
 function validateAsset(asset, frontMatterKeys, filePath) {
   const errors = [];
@@ -1779,17 +2096,26 @@ var PromptOpsKit = class {
       throw new Error('Either "path" or "source" must be provided to renderPrompt()');
     }
     const adapter = getAdapter(options.provider);
-    const validation = adapter.validate(resolved);
+    const validation = adapter.validate(resolved, {
+      openaiResponses: options.openaiResponses
+    });
     if (!validation.valid) {
       throw new Error(
         `Provider validation failed for "${options.provider}":
 ` + validation.errors.map((e) => `  - ${e}`).join("\n")
       );
     }
-    const sanitizedVariables = sanitizeContextVariables(resolved, options.variables, {
+    const sanitization = sanitizeContextVariables(resolved, options.variables, {
       onContextOverflow: options.onContextOverflow
     });
-    const contextSizeWarnings = collectContextSizeWarnings(resolved, sanitizedVariables).map(
+    if (sanitization.shortCircuit) {
+      return {
+        resolved,
+        returnMessage: sanitization.shortCircuit.returnMessage,
+        warnings: validation.warnings
+      };
+    }
+    const contextSizeWarnings = collectContextSizeWarnings(resolved, sanitization.variables).map(
       (warning) => formatContextSizeWarning(resolved, warning)
     );
     const contextWarningPolicy = this.config.warnings?.contextSize;
@@ -1799,10 +2125,11 @@ var PromptOpsKit = class {
       }
     }
     const request = adapter.render(resolved, {
-      variables: sanitizedVariables,
+      variables: sanitization.variables,
       history: options.history,
       toolRegistry: options.toolRegistry,
-      strict: options.strict
+      strict: options.strict,
+      openaiResponses: options.openaiResponses
     });
     return {
       resolved,
@@ -1859,6 +2186,7 @@ async function renderPrompt(options) {
   interpolate,
   loadPromptFile,
   openaiAdapter,
+  openaiResponsesAdapter,
   openrouterAdapter,
   parsePrompt,
   renderPrompt,