promptopskit 0.3.8 → 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()
@@ -297,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(),
@@ -309,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()
@@ -320,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(),
@@ -971,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) {
@@ -995,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;
@@ -1004,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") {
@@ -1035,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",
@@ -1054,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) {
@@ -1063,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;
@@ -1092,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",
@@ -1124,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.");
     }
@@ -1133,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) {
@@ -1159,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
       };
@@ -1180,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") {
@@ -1221,6 +1466,7 @@ var openrouterAdapter = withPromptInputSupport({
 // src/providers/index.ts
 var adapters = {
   openai: openaiAdapter,
+  "openai-responses": openaiResponsesAdapter,
   anthropic: anthropicAdapter,
   google: geminiAdapter,
   gemini: geminiAdapter,
@@ -1275,7 +1521,8 @@ var KNOWN_FRONT_MATTER_KEYS = /* @__PURE__ */ new Set([
   "includes",
   "environments",
   "tiers",
-  "metadata"
+  "metadata",
+  "cache"
 ]);
 function validateAsset(asset, frontMatterKeys, filePath) {
   const errors = [];
@@ -1849,7 +2096,9 @@ 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}":
@@ -1879,7 +2128,8 @@ var PromptOpsKit = class {
       variables: sanitization.variables,
       history: options.history,
       toolRegistry: options.toolRegistry,
-      strict: options.strict
+      strict: options.strict,
+      openaiResponses: options.openaiResponses
     });
     return {
       resolved,
@@ -1936,6 +2186,7 @@ async function renderPrompt(options) {
   interpolate,
   loadPromptFile,
   openaiAdapter,
+  openaiResponsesAdapter,
   openrouterAdapter,
   parsePrompt,
   renderPrompt,