@od-oneapp/ai-platform 0.1.0

package/dist/prompts.mjs

@@ -0,0 +1,732 @@
+import { t as __exportAll } from "./chunk-CkzbjWQW.mjs";
+
+//#region src/prompts/model-variants.ts
+/**
+* Catalog of supported models and their profiles
+*/
+const MODEL_PROFILES = {
+	"claude-opus": {
+		model: "claude-opus",
+		provider: "anthropic",
+		maxTokens: 4096,
+		supportsFunctions: true,
+		supportsStreaming: true,
+		supportsVision: true,
+		contextWindow: 2e5,
+		strengths: [
+			"reasoning",
+			"analysis",
+			"code",
+			"writing"
+		],
+		formatting: "anthropic"
+	},
+	"claude-sonnet": {
+		model: "claude-sonnet",
+		provider: "anthropic",
+		maxTokens: 4096,
+		supportsFunctions: true,
+		supportsStreaming: true,
+		supportsVision: true,
+		contextWindow: 2e5,
+		strengths: [
+			"speed",
+			"reasoning",
+			"code"
+		],
+		formatting: "anthropic"
+	},
+	"claude-haiku": {
+		model: "claude-haiku",
+		provider: "anthropic",
+		maxTokens: 2048,
+		supportsFunctions: true,
+		supportsStreaming: true,
+		supportsVision: true,
+		contextWindow: 2e5,
+		strengths: ["speed", "efficiency"],
+		formatting: "anthropic"
+	},
+	"gpt-4": {
+		model: "gpt-4",
+		provider: "openai",
+		maxTokens: 8192,
+		supportsFunctions: true,
+		supportsStreaming: true,
+		supportsVision: true,
+		contextWindow: 128e3,
+		strengths: [
+			"reasoning",
+			"code",
+			"analysis"
+		],
+		formatting: "openai"
+	},
+	"gpt-4-turbo": {
+		model: "gpt-4-turbo",
+		provider: "openai",
+		maxTokens: 4096,
+		supportsFunctions: true,
+		supportsStreaming: true,
+		supportsVision: true,
+		contextWindow: 128e3,
+		strengths: [
+			"speed",
+			"code",
+			"reasoning"
+		],
+		formatting: "openai"
+	},
+	"gpt-3.5-turbo": {
+		model: "gpt-3.5-turbo",
+		provider: "openai",
+		maxTokens: 4096,
+		supportsFunctions: true,
+		supportsStreaming: true,
+		supportsVision: false,
+		contextWindow: 16e3,
+		strengths: ["speed", "efficiency"],
+		formatting: "openai"
+	},
+	"gemini-pro": {
+		model: "gemini-pro",
+		provider: "google",
+		maxTokens: 8192,
+		supportsFunctions: true,
+		supportsStreaming: true,
+		supportsVision: false,
+		contextWindow: 32e3,
+		strengths: ["reasoning", "speed"],
+		formatting: "google"
+	},
+	"gemini-pro-vision": {
+		model: "gemini-pro-vision",
+		provider: "google",
+		maxTokens: 4096,
+		supportsFunctions: true,
+		supportsStreaming: true,
+		supportsVision: true,
+		contextWindow: 32e3,
+		strengths: ["vision", "multimodal"],
+		formatting: "google"
+	}
+};
+/**
+* Get the model profile for a given model identifier
+* @param model Model identifier (e.g., 'claude-opus', 'gpt-4')
+* @returns Model profile or undefined if not found
+*/
+function getModelProfile(model) {
+	return MODEL_PROFILES[model];
+}
+/**
+* Formats a prompt with Claude-specific conventions.
+*
+* Wraps the prompt in XML-like `<system>` tags, which Claude models
+* use to clearly delineate system instructions from user content.
+*
+* @param basePrompt - The base system prompt to format
+* @returns The prompt wrapped in Claude-style XML tags
+*/
+function formatPromptForClaude(basePrompt) {
+	if (!basePrompt.includes("<system>")) return `<system>
+${basePrompt}
+</system>`;
+	return basePrompt;
+}
+/**
+* Formats a prompt with GPT-specific conventions.
+*
+* Prepends an explicit role definition prefix for OpenAI models,
+* which benefit from clear role-based framing.
+*
+* @param basePrompt - The base system prompt to format
+* @returns The prompt with GPT-style role prefix
+*/
+function formatPromptForGPT(basePrompt) {
+	if (!basePrompt.includes("As an")) return `You are a helpful AI assistant. ${basePrompt}`;
+	return basePrompt;
+}
+/**
+* Formats a prompt with Gemini-specific conventions.
+*
+* Currently returns the prompt unmodified, as Gemini responds well
+* to direct, clear instructions without special formatting.
+*
+* @param basePrompt - The base system prompt to format
+* @returns The prompt formatted for Gemini models
+*/
+function formatPromptForGemini(basePrompt) {
+	return basePrompt;
+}
+/**
+* Adjust prompt based on context window limitations
+* @param prompt The prompt to adjust
+* @param model Model identifier
+* @param maxPromptTokens Maximum tokens for the prompt (leaving room for response)
+* @returns Adjusted prompt
+*/
+function adjustForContextWindow(prompt, model, maxPromptTokens = 2e3) {
+	if (!getModelProfile(model)) return prompt;
+	const estimatedTokens = Math.ceil(prompt.length / 4);
+	if (estimatedTokens > maxPromptTokens) {
+		const ratio = maxPromptTokens / estimatedTokens;
+		if (ratio > .8) return prompt.substring(0, Math.floor(prompt.length * .9));
+		else if (ratio > .5) return prompt.substring(0, Math.floor(prompt.length * ratio));
+		else return prompt.substring(0, Math.floor(prompt.length * .5));
+	}
+	return prompt;
+}
+/**
+* Optimize prompt for specific model capabilities
+* @param prompt Base prompt
+* @param model Model identifier
+* @returns Optimized prompt
+*/
+function optimizeForModel(prompt, model) {
+	const profile = getModelProfile(model);
+	if (!profile) return prompt;
+	let optimized = prompt;
+	if (profile.supportsVision && !prompt.includes("image")) {} else if (!profile.supportsVision && prompt.includes("image")) optimized = optimized.replace(/You can (?:analyze|interpret|describe) images?\.?\s*/gi, "");
+	if (profile.supportsFunctions && !prompt.includes("function")) optimized += "\n\nYou have access to various tools and functions to help accomplish tasks.";
+	switch (profile.provider) {
+		case "anthropic":
+			optimized = formatPromptForClaude(optimized);
+			break;
+		case "openai":
+			optimized = formatPromptForGPT(optimized);
+			break;
+		case "google":
+			optimized = formatPromptForGemini(optimized);
+			break;
+		case "other": break;
+		default: {
+			const exhaustiveCheck = profile.provider;
+			throw new Error(`Unsupported provider: ${exhaustiveCheck}`);
+		}
+	}
+	return optimized;
+}
+/**
+* Get model-specific response format guidance
+* @param model Model identifier
+* @returns Format guidance string
+*/
+function getModelFormatGuidance(model) {
+	const profile = getModelProfile(model);
+	if (!profile) return "Provide clear, well-formatted responses.";
+	return {
+		anthropic: `Format your response with clear sections. Use XML-like tags for structure:
+<response>
+  <summary>Brief overview</summary>
+  <details>Main content</details>
+  <conclusion>Wrap-up</conclusion>
+</response>`,
+		openai: `Structure your response clearly:
+- Use numbered or bulleted lists for multiple items
+- Use code blocks (\`\`\`) for code examples
+- Use headers for organization
+- Be direct and concise`,
+		google: `Organize your response for clarity:
+1. Lead with the most important information
+2. Use clear formatting and bullet points
+3. Provide examples when helpful
+4. End with a clear conclusion`
+	}[profile.provider] || "Provide clear, well-formatted responses.";
+}
+/**
+* Get streaming-specific adjustments for a model
+* @param prompt Base prompt
+* @param model Model identifier
+* @returns Streaming-optimized prompt
+*/
+function optimizeForStreaming(prompt, model) {
+	if (!getModelProfile(model)?.supportsStreaming) return prompt;
+	return `${prompt}
+
+Note: Provide your response in a streaming-friendly format.
+Begin with the most important information first.
+Structure your response in logical chunks that can be transmitted progressively.`;
+}
+/**
+* Get cost-optimized variant (prefers faster/cheaper models)
+* @param basePrompt Base prompt
+* @param targetModel Target model to optimize for
+* @returns Cost-optimized prompt
+*/
+function optimizeForCost(basePrompt, targetModel) {
+	const profile = getModelProfile(targetModel);
+	if (!profile) return basePrompt;
+	let optimized = basePrompt;
+	if (profile.model.includes("haiku") || profile.model.includes("3.5")) optimized = `${basePrompt}
+
+Be concise and direct. Avoid unnecessary elaboration. Focus on the essential information needed to answer the user's question.`;
+	optimized = adjustForContextWindow(optimized, targetModel, 1500);
+	return optimized;
+}
+/**
+* Get complete model configuration with optimized prompt
+* @param basePrompt Base system prompt
+* @param model Model identifier
+* @param optimizationMode 'balanced' | 'speed' | 'quality' | 'cost'
+* @returns Complete model configuration
+*/
+function getModelConfig(basePrompt, model, optimizationMode = "balanced") {
+	const profile = getModelProfile(model);
+	if (!profile) throw new Error(`Unknown model: ${model}`);
+	let optimizedPrompt = basePrompt;
+	switch (optimizationMode) {
+		case "speed":
+			optimizedPrompt = optimizeForCost(basePrompt, model);
+			break;
+		case "quality":
+			optimizedPrompt = optimizeForModel(basePrompt, model);
+			break;
+		case "cost":
+			optimizedPrompt = optimizeForCost(basePrompt, model);
+			break;
+		default:
+			optimizedPrompt = optimizeForModel(basePrompt, model);
+			break;
+	}
+	return {
+		model,
+		profile,
+		optimizedPrompt,
+		formatGuidance: getModelFormatGuidance(model),
+		capabilities: profile.strengths
+	};
+}
+
+//#endregion
+//#region src/prompts/templates.ts
+/**
+* Prompt Template Utilities
+* Provides template creation, validation, and interpolation functionality
+*/
+/**
+* Template variable placeholder pattern
+* Matches {{variableName}} or {variableName}
+*/
+const TEMPLATE_VAR_PATTERN = /\{\{?(\w+)\}?\}/g;
+/**
+* Create a reusable prompt template with variable support
+* @param template Template string with {{variableName}} placeholders
+* @returns PromptTemplate object with template and extracted variables
+*/
+function createPromptTemplate(template) {
+	const variables = /* @__PURE__ */ new Set();
+	let match;
+	TEMPLATE_VAR_PATTERN.lastIndex = 0;
+	while ((match = TEMPLATE_VAR_PATTERN.exec(template)) !== null) {
+		const varName = match[1];
+		if (varName) variables.add(varName);
+	}
+	return {
+		template,
+		variables,
+		interpolate: (vars) => {
+			return interpolateTemplate(template, vars, variables);
+		},
+		getRequiredVariables: () => Array.from(variables),
+		validate: (vars) => {
+			const missing = Array.from(variables).filter((v) => !(v in vars));
+			return {
+				valid: missing.length === 0,
+				missing
+			};
+		}
+	};
+}
+/**
+* Interpolate template variables into a string
+* @param template Template string with {{variableName}} placeholders
+* @param variables Object containing variable values
+* @param knownVariables Set of known variable names (for validation)
+* @returns Interpolation result with substituted string and metadata
+*/
+function interpolateTemplate(template, variables, knownVariables) {
+	const missingVariables = [];
+	const substitutedVariables = [];
+	let result = template;
+	result = result.replace(/\{\{?(\w+)\}?\}/g, (matchText, varName) => {
+		if (!varName) return matchText;
+		if (knownVariables && !knownVariables.has(varName)) {
+			missingVariables.push(varName);
+			return matchText;
+		}
+		if (varName in variables) {
+			substitutedVariables.push(varName);
+			return String(variables[varName]);
+		}
+		missingVariables.push(varName);
+		return matchText;
+	});
+	return {
+		result,
+		success: missingVariables.length === 0,
+		missingVariables,
+		substitutedVariables
+	};
+}
+/**
+* Validate that all required template variables are provided
+* @param template Template string with {{variableName}} placeholders
+* @param variables Object containing variable values
+* @returns Validation result with list of missing variables
+*/
+function validatePromptTemplate(template, variables) {
+	const varPattern = /\{\{?(\w+)\}?\}/g;
+	const missing = [];
+	let match;
+	while ((match = varPattern.exec(template)) !== null) {
+		const varName = match[1];
+		if (!varName) continue;
+		if (!(varName in variables)) missing.push(varName);
+	}
+	return {
+		valid: missing.length === 0,
+		missing
+	};
+}
+/**
+* Merge multiple templates/fragments ensuring no variable conflicts
+* @param templates Array of template strings to merge
+* @param separator String to join templates with (default: double newline)
+* @returns Merged template string and combined variable set
+*/
+function mergePromptTemplates(templates, separator = "\n\n") {
+	const varPattern = /\{\{?(\w+)\}?\}/g;
+	const allVariables = /* @__PURE__ */ new Map();
+	const conflicts = [];
+	templates.forEach((template) => {
+		varPattern.lastIndex = 0;
+		let match;
+		while ((match = varPattern.exec(template)) !== null) {
+			const varName = match[1];
+			if (!varName) continue;
+			allVariables.set(varName, (allVariables.get(varName) || 0) + 1);
+		}
+	});
+	allVariables.forEach((count, varName) => {
+		if (count > 1) conflicts.push(varName);
+	});
+	return {
+		merged: templates.filter((t) => t.trim().length > 0).join(separator),
+		variables: new Set(allVariables.keys()),
+		conflicts
+	};
+}
+/**
+* Extract all variables from a template
+* @param template Template string with {{variableName}} placeholders
+* @returns Array of variable names found in template
+*/
+function extractTemplateVariables(template) {
+	const varPattern = /\{\{?(\w+)\}?\}/g;
+	const variables = [];
+	let match;
+	while ((match = varPattern.exec(template)) !== null) {
+		const varName = match[1];
+		if (!varName) continue;
+		if (!variables.includes(varName)) variables.push(varName);
+	}
+	return variables;
+}
+/**
+* Create a cached template for performance
+*/
+var CachedPromptTemplate = class {
+	template;
+	variables;
+	cache = /* @__PURE__ */ new Map();
+	constructor(template) {
+		this.template = template;
+		this.variables = /* @__PURE__ */ new Set();
+		const varPattern = /\{\{?(\w+)\}?\}/g;
+		let match;
+		while ((match = varPattern.exec(template)) !== null) {
+			const varName = match[1];
+			if (varName) this.variables.add(varName);
+		}
+	}
+	/**
+	* Get the raw template string
+	*/
+	getTemplate() {
+		return this.template;
+	}
+	/**
+	* Get list of required variables
+	*/
+	getVariables() {
+		return Array.from(this.variables);
+	}
+	/**
+	* Interpolate with caching
+	*/
+	interpolate(variables) {
+		const cacheKey = JSON.stringify(variables);
+		if (this.cache.has(cacheKey)) {
+			const cached = this.cache.get(cacheKey);
+			if (cached !== void 0) return cached;
+		}
+		const { result } = interpolateTemplate(this.template, variables, this.variables);
+		this.cache.set(cacheKey, result);
+		return result;
+	}
+	/**
+	* Clear the interpolation cache
+	*/
+	clearCache() {
+		this.cache.clear();
+	}
+	/**
+	* Get cache statistics
+	*/
+	getCacheStats() {
+		return {
+			size: this.cache.size,
+			maxSize: 1e3
+		};
+	}
+};
+/**
+* Preset templates for common prompt patterns
+*/
+const PROMPT_TEMPLATES = {
+	task: createPromptTemplate(`You are tasked with: {{task}}
+Context: {{context}}
+Expected output format: {{format}}
+Constraints: {{constraints}}`),
+	conversation: createPromptTemplate(`You are {{role}}.
+Your expertise: {{expertise}}
+Conversation tone: {{tone}}
+Response style: {{style}}`),
+	analysis: createPromptTemplate(`Analyze the following {{subject}}:
+Data: {{data}}
+Focus areas: {{focusAreas}}
+Provide: {{deliverables}}`),
+	codeGeneration: createPromptTemplate(`Generate {{language}} code for: {{task}}
+Requirements: {{requirements}}
+Code style: {{style}}
+Include: {{includes}}`)
+};
+
+//#endregion
+//#region src/prompts/index.ts
+/**
+* @fileoverview Centralized system prompt management with model-specific composition and variants.
+* @module @od-oneapp/ai-platform/prompts
+*/
+var prompts_exports = /* @__PURE__ */ __exportAll({
+	CachedPromptTemplate: () => CachedPromptTemplate,
+	MODEL_PROFILES: () => MODEL_PROFILES,
+	PROMPT_FRAGMENTS: () => PROMPT_FRAGMENTS,
+	PROMPT_TEMPLATES: () => PROMPT_TEMPLATES,
+	SYSTEM_PROMPTS: () => SYSTEM_PROMPTS,
+	TEMPS: () => TEMPS,
+	TOKENS: () => TOKENS,
+	adjustForContextWindow: () => adjustForContextWindow,
+	chatFragments: () => chatFragments,
+	composeSystemPrompt: () => composeSystemPrompt,
+	createPromptTemplate: () => createPromptTemplate,
+	extractTemplateVariables: () => extractTemplateVariables,
+	formatPromptForClaude: () => formatPromptForClaude,
+	formatPromptForGPT: () => formatPromptForGPT,
+	formatPromptForGemini: () => formatPromptForGemini,
+	formatPromptForModel: () => formatPromptForModel,
+	getModelConfig: () => getModelConfig,
+	getModelFormatGuidance: () => getModelFormatGuidance,
+	getModelProfile: () => getModelProfile,
+	interpolateTemplate: () => interpolateTemplate,
+	mergePromptFragments: () => mergePromptFragments,
+	mergePromptTemplates: () => mergePromptTemplates,
+	optimizeForCost: () => optimizeForCost,
+	optimizeForModel: () => optimizeForModel,
+	optimizeForStreaming: () => optimizeForStreaming,
+	validatePromptTemplate: () => validatePromptTemplate,
+	validatePromptVariables: () => validatePromptVariables
+});
+const SYSTEM_PROMPTS = {
+	default: `You are a helpful, harmless, and honest AI assistant.
+You provide accurate, thoughtful responses while maintaining clarity and concision.
+Always prioritize user safety and accuracy in your responses.`,
+	assistant: `You are a professional AI assistant designed to help users with a wide variety of tasks.
+You are knowledgeable, helpful, and respectful. You provide detailed, accurate information.
+You ask clarifying questions when needed and adapt your communication style to the user's needs.`,
+	coder: `You are an expert software engineer and code reviewer.
+You write clean, maintainable, and well-documented code following best practices.
+You provide comprehensive explanations of technical concepts and help debug complex issues.
+You recommend performance optimizations and security improvements.`,
+	analyst: `You are a data analyst and business intelligence expert.
+You interpret data accurately, identify trends, and provide actionable insights.
+You communicate complex analytical findings in clear, understandable terms.
+You consider context and limitations when making recommendations based on data.`,
+	researcher: `You are a thorough research expert with strong analytical capabilities.
+You synthesize information from multiple sources and identify patterns and connections.
+You distinguish between facts, evidence, and speculation clearly.
+You acknowledge gaps in knowledge and suggest further research directions.`,
+	writer: `You are a skilled professional writer and editor.
+You create compelling, well-structured content tailored to your audience.
+You maintain consistency in tone, style, and messaging.
+You provide constructive feedback and help refine written work.`
+};
+const PROMPT_FRAGMENTS = {
+	safety: `Always prioritize safety and accuracy. Never provide harmful information.
+Be transparent about limitations and uncertainties in your knowledge.
+If you're unsure, say so and suggest reliable ways to find accurate information.`,
+	formatting: `Structure your response clearly with appropriate formatting:
+- Use bullet points for lists
+- Use code blocks for code examples with language specification
+- Use tables for comparative information
+- Use headers to organize long responses
+- Use emphasis (bold/italic) for important points`,
+	codeStyle: `When writing code:
+- Follow the language's standard conventions and best practices
+- Include meaningful variable and function names
+- Add comments for complex logic
+- Provide error handling where appropriate
+- Consider edge cases and potential issues`,
+	reasoning: `Show your reasoning and thought process:
+- Explain the why behind recommendations
+- Break down complex problems step by step
+- Consider multiple perspectives and approaches
+- Acknowledge trade-offs and limitations`,
+	citations: `When referencing information:
+- Cite sources when using specific facts or data
+- Distinguish between widely-known information and specialized knowledge
+- Indicate the recency and reliability of sources when relevant
+- Acknowledge when information might be outdated`
+};
+/**
+* Compose a system prompt from base prompt and fragments
+* @param options Configuration for prompt composition
+* @returns Composed system prompt string
+*/
+function composeSystemPrompt(options) {
+	const { basePrompt, fragments = [], customInstructions, style = "balanced" } = options;
+	let composed = basePrompt;
+	if (fragments.length > 0) {
+		composed += "\n\n";
+		composed += fragments.join("\n\n");
+	}
+	if (style === "concise") {
+		composed += "\n\n";
+		composed += "Keep responses concise and to the point. Avoid unnecessary elaboration.";
+	} else if (style === "detailed") {
+		composed += "\n\n";
+		composed += "Provide comprehensive, detailed responses with thorough explanations.";
+	}
+	if (customInstructions) {
+		composed += "\n\n";
+		composed += `Additional instructions: ${customInstructions}`;
+	}
+	return composed;
+}
+/**
+* Formats a base prompt with model-specific conventions based on the model identifier.
+*
+* Detects the model family from the ID prefix (e.g., `claude-*`, `gpt-*`, `gemini-*`)
+* and applies the corresponding formatting variant. Returns the prompt unchanged
+* if the model family is not recognized.
+*
+* @param basePrompt - The base system prompt to format
+* @param model - Model identifier (e.g., `'claude-opus'`, `'gpt-4'`, `'gemini-pro'`)
+* @returns The prompt formatted for the target model's conventions
+*
+* @example
+* ```ts
+* const prompt = formatPromptForModel('You are a helpful assistant.', 'claude-opus');
+* // Returns: '<system>\nYou are a helpful assistant.\n</system>'
+* ```
+*/
+const MODEL_VARIANTS = {
+	claude: formatPromptForClaude,
+	gemini: formatPromptForGemini,
+	gpt: formatPromptForGPT
+};
+function formatPromptForModel(basePrompt, model) {
+	const [modelPrefixRaw] = model.split("-");
+	const modelPrefix = modelPrefixRaw?.toLowerCase();
+	if (!modelPrefix) return basePrompt;
+	const variantFn = MODEL_VARIANTS[modelPrefix];
+	if (!variantFn) return basePrompt;
+	return variantFn(basePrompt);
+}
+/**
+* Validate that all template variables are provided
+* @param template The prompt template
+* @param variables Provided variable values
+* @returns Object indicating validation result and missing variables
+*/
+function validatePromptVariables(template, variables) {
+	const missing = Array.from(template.variables).filter((v) => !(v in variables));
+	return {
+		valid: missing.length === 0,
+		missing
+	};
+}
+/**
+* Merge multiple prompt fragments into a cohesive prompt
+* @param fragments Array of prompt fragments to merge
+* @param separator String to join fragments with (default: double newline)
+* @returns Merged prompt string
+*/
+function mergePromptFragments(fragments, separator = "\n\n") {
+	return fragments.filter((f) => f.trim().length > 0).join(separator);
+}
+/**
+* Common temperature presets used across providers.
+* Single source of truth for temperature values.
+*/
+const TEMPS = {
+	PRECISE: 0,
+	VERY_LOW: .1,
+	FACTUAL: .2,
+	LOW_CREATIVE: .3,
+	MODERATE: .5,
+	BALANCED: .7,
+	HIGH_CREATIVE: .8,
+	CREATIVE: .9
+};
+/**
+* Common token limit presets.
+* Standardized across providers where applicable.
+*/
+const TOKENS = {
+	TINY: 256,
+	SHORT: 1024,
+	MEDIUM: 2048,
+	LONG: 4096,
+	EXTENDED: 8192,
+	MAX: 16384
+};
+/**
+* Chat configuration fragments - frequently reused patterns only.
+*
+* @example
+* ```typescript
+* const { basicChat } = chatFragments;
+* const config = { ...basicChat, system: 'You are a helpful assistant.' };
+* ```
+*/
+const chatFragments = {
+	basicChat: {
+		temperature: TEMPS.BALANCED,
+		maxOutputTokens: TOKENS.MEDIUM
+	},
+	structured: {
+		temperature: TEMPS.VERY_LOW,
+		maxOutputTokens: TOKENS.LONG
+	},
+	withTools: {
+		temperature: TEMPS.BALANCED,
+		maxOutputTokens: TOKENS.MEDIUM,
+		toolChoice: "auto"
+	}
+};
+
+//#endregion
+export { CachedPromptTemplate, MODEL_PROFILES, PROMPT_FRAGMENTS, PROMPT_TEMPLATES, SYSTEM_PROMPTS, TEMPS, TOKENS, adjustForContextWindow, chatFragments, composeSystemPrompt, createPromptTemplate, extractTemplateVariables, formatPromptForClaude, formatPromptForGPT, formatPromptForGemini, formatPromptForModel, getModelConfig, getModelFormatGuidance, getModelProfile, interpolateTemplate, mergePromptFragments, mergePromptTemplates, optimizeForCost, optimizeForModel, optimizeForStreaming, prompts_exports as t, validatePromptTemplate, validatePromptVariables };
+//# sourceMappingURL=prompts.mjs.map