@simonecoelhosfo/optimizely-mcp-server
Version:
Optimizely MCP Server for AI assistants with integrated CLI tools
498 lines (465 loc) • 18.1 kB
JavaScript
/**
* Plugin-Enhanced Workflow Example
* Demonstrates using custom functions in orchestration
*/
export const pluginEnhancedWorkflowComplete = {
id: 'tpl_plugin_enhanced_workflow',
name: 'Smart Personalization with Custom Logic',
description: 'Advanced personalization workflow using plugins for dynamic pricing, validation, and external integrations',
version: '1.0.0',
type: 'user',
platform: 'web',
author: 'orchestration.bible@optimizely.com',
template_format_version: 2,
parameters: {
project_id: {
type: 'string',
required: true,
description: 'Target project ID'
},
base_product_price: {
type: 'number',
required: true,
description: 'Base price for the product',
default: 99.99
},
recommendation_api_key: {
type: 'string',
required: false,
description: 'API key for recommendation service'
},
external_audience_data: {
type: 'array',
required: false,
description: 'External audience definitions to import',
default: []
}
},
steps: [
// Step 1: Transform external audience data
{
id: 'transform_audiences',
type: 'plugin',
name: 'Transform External Audience Data',
plugin: {
code: `
// Transform external audience format to Optimizely format
const externalData = parameters.external_audience_data || [];
const transformedAudiences = [];
console.log(\`Processing \${externalData.length} external audiences\`);
for (const extAud of externalData) {
const conditions = [];
// Transform rules to Optimizely conditions
if (extAud.criteria) {
for (const criterion of extAud.criteria) {
if (criterion.type === 'attribute') {
conditions.push({
type: 'custom_attribute',
name: criterion.name,
match_type: criterion.operator || 'exact',
value: criterion.value
});
} else if (criterion.type === 'behavior') {
conditions.push({
type: 'behavior',
event_name: criterion.event,
match_type: 'exists'
});
}
}
}
if (conditions.length > 0) {
transformedAudiences.push({
key: extAud.id.toLowerCase().replace(/[^a-z0-9_]/g, '_'),
name: extAud.name,
description: \`Imported: \${extAud.description || extAud.name}\`,
conditions: conditions.length > 1 ? { and: conditions } : conditions
});
}
}
console.log(\`Transformed \${transformedAudiences.length} audiences successfully\`);
return {
audiences: transformedAudiences,
count: transformedAudiences.length
};
`,
template_data: {
external_audience_data: '${parameters.external_audience_data}'
},
outputs: ['audiences', 'count']
}
},
// Step 2: Create transformed audiences
{
id: 'create_audiences_loop',
type: 'loop',
name: 'Create Transformed Audiences',
loop: {
over: '${transform_audiences.audiences}',
as: 'audience',
steps: [
{
id: 'create_audience',
type: 'template',
name: 'Create Audience: ${audience.name}',
template: {
entity_type: 'audience',
mode: 'template',
operation: 'create',
template_data: {
project_id: '${project_id}',
name: '${audience.name}',
key: '${audience.key}',
description: '${audience.description}',
conditions: '${audience.conditions}'
}
}
}
]
},
skip_if: '${transform_audiences.count === 0}'
},
// Step 3: Create VIP tiers audience
{
id: 'create_vip_tiers',
type: 'template',
name: 'Create VIP Customer Tiers',
template: {
entity_type: 'audience',
mode: 'template',
operation: 'create',
template_data: {
project_id: '${project_id}',
name: 'Customer Tier Segments',
key: 'customer_tiers',
conditions: {
or: [
{
type: 'custom_attribute',
name: 'customer_tier',
match_type: 'exact',
value: 'vip'
},
{
type: 'custom_attribute',
name: 'customer_tier',
match_type: 'exact',
value: 'gold'
}
]
}
}
}
},
// Step 4: Validate setup before proceeding
{
id: 'validate_setup',
type: 'plugin',
name: 'Validate Configuration',
plugin: {
code: `
const errors = [];
const warnings = [];
// Check if we have audiences
const audiences = await api.listEntities('audience', {
project_id: parameters.project_id
});
if (audiences.total_count === 0) {
errors.push('No audiences found in project');
}
// Check for conversion events
const events = await api.listEntities('event', {
project_id: parameters.project_id
});
const hasConversion = events.entities.some(e => e.category === 'conversion');
if (!hasConversion) {
warnings.push('No conversion events configured');
}
// Check for pages
const pages = await api.listEntities('page', {
project_id: parameters.project_id
});
if (pages.total_count === 0) {
errors.push('No pages configured');
}
const isValid = errors.length === 0;
console.log(\`Validation complete: \${errors.length} errors, \${warnings.length} warnings\`);
if (!isValid) {
console.error('Validation errors:', errors);
}
return {
valid: isValid,
errors: errors,
warnings: warnings,
stats: {
audiences: audiences.total_count,
events: events.total_count,
pages: pages.total_count
}
};
`,
permissions: {
read_entities: true
},
outputs: ['valid', 'errors', 'warnings', 'stats']
}
},
// Step 5: Calculate dynamic pricing tiers
{
id: 'calculate_pricing',
type: 'plugin',
name: 'Calculate Tier-Based Pricing',
plugin: {
code: `
const basePrice = parameters.base_product_price;
// Define tier discounts
const tierDiscounts = {
vip: 0.25, // 25% off
gold: 0.15, // 15% off
silver: 0.10, // 10% off
bronze: 0.05, // 5% off
standard: 0 // No discount
};
const pricingTiers = {};
for (const [tier, discount] of Object.entries(tierDiscounts)) {
const discountAmount = basePrice * discount;
const finalPrice = basePrice - discountAmount;
pricingTiers[tier] = {
tier: tier,
base_price: basePrice,
discount_percentage: discount * 100,
discount_amount: Math.round(discountAmount * 100) / 100,
final_price: Math.round(finalPrice * 100) / 100,
savings_message: discount > 0 ? \`Save \${discount * 100}%!\` : 'Standard pricing'
};
console.log(\`\${tier} tier: $\${finalPrice.toFixed(2)} (\${discount * 100}% off)\`);
}
return {
pricing_tiers: pricingTiers,
tier_count: Object.keys(pricingTiers).length
};
`,
template_data: {
base_product_price: '${parameters.base_product_price}'
},
outputs: ['pricing_tiers', 'tier_count']
}
},
// Step 6: Fetch recommendations if API key provided
{
id: 'fetch_recommendations',
type: 'plugin',
name: 'Get Product Recommendations',
plugin: {
code: `
const apiKey = parameters.recommendation_api_key;
if (!apiKey) {
console.log('No API key provided, using default recommendations');
return {
success: true,
recommendations: [
{ product_id: 'prod_123', name: 'Premium Package', score: 0.95 },
{ product_id: 'prod_456', name: 'Deluxe Bundle', score: 0.87 },
{ product_id: 'prod_789', name: 'Starter Kit', score: 0.75 }
]
};
}
try {
console.log('Fetching personalized recommendations...');
const response = await api.fetch('https://api.example.com/recommendations', {
method: 'GET',
headers: {
'Authorization': \`Bearer \${apiKey}\`,
'Accept': 'application/json'
}
});
if (!response.ok) {
throw new Error(\`API error: \${response.status}\`);
}
const data = JSON.parse(response.data);
return {
success: true,
recommendations: data.recommendations || []
};
} catch (error) {
console.error('Failed to fetch recommendations:', error.message);
return {
success: false,
error: error.message,
recommendations: []
};
}
`,
template_data: {
recommendation_api_key: '${parameters.recommendation_api_key}'
},
outputs: ['success', 'recommendations', 'error'],
permissions: {
external_requests: true
},
timeout_ms: 10000
},
optional: true
},
// Step 7: Create checkout page
{
id: 'create_checkout_page',
type: 'template',
name: 'Create Dynamic Checkout Page',
template: {
entity_type: 'page',
mode: 'template',
operation: 'create',
template_data: {
project_id: '${project_id}',
name: 'Smart Checkout Page',
key: 'smart_checkout',
conditions: [
{
match_type: 'substring',
value: '/checkout'
}
]
}
},
skip_if: '${!validate_setup.valid}'
},
// Step 8: Create campaign
{
id: 'create_campaign',
type: 'template',
name: 'Create Smart Personalization Campaign',
template: {
entity_type: 'campaign',
mode: 'template',
operation: 'create',
template_data: {
project_id: '${project_id}',
name: 'Smart Personalization Campaign',
status: 'active'
}
},
depends_on: ['create_checkout_page']
},
// Step 9: Create personalized pricing experiment
{
id: 'create_pricing_experiment',
type: 'template',
name: 'Create Dynamic Pricing Experience',
template: {
entity_type: 'experiment',
mode: 'template',
operation: 'create',
template_data: {
project_id: '${project_id}',
name: 'VIP Tier Dynamic Pricing',
campaign_id: '${create_campaign.entity_id}',
page_ids: ['${create_checkout_page.entity_id}'],
audience: {
ref: {
id: '${create_vip_tiers.entity_id}'
}
},
variations: [
{
name: 'Personalized Pricing Display',
weight: 10000,
actions: [
{
page_id: '${create_checkout_page.entity_id}',
changes: [
{
type: 'custom_code',
value: `
// Dynamic pricing display based on customer tier
(function() {
const pricingData = ${JSON.stringify('${calculate_pricing.pricing_tiers}')};
const userTier = window.optimizelyUserTier || 'standard';
const pricing = pricingData[userTier] || pricingData.standard;
// Update price display
const priceElement = document.querySelector('.product-price');
if (priceElement) {
priceElement.innerHTML = \`
<div class="dynamic-pricing">
<span class="final-price">$\${pricing.final_price}</span>
\${pricing.discount_percentage > 0 ?
\`<span class="original-price">$\${pricing.base_price}</span>
<span class="savings">\${pricing.savings_message}</span>\` : ''
}
</div>
\`;
}
// Add tier badge
if (userTier !== 'standard') {
const badge = document.createElement('div');
badge.className = 'tier-badge tier-' + userTier;
badge.textContent = userTier.toUpperCase() + ' Member';
document.body.appendChild(badge);
}
})();`
}
]
}
]
}
]
}
},
depends_on: ['create_campaign', 'create_checkout_page', 'create_vip_tiers']
},
// Step 10: Generate summary report
{
id: 'generate_report',
type: 'plugin',
name: 'Generate Execution Summary',
plugin: {
code: `
const report = {
execution_summary: 'Smart Personalization Workflow Complete',
timestamp: new Date().toISOString(),
components_created: {
audiences: outputs.transform_audiences?.count || 0,
validation_passed: outputs.validate_setup?.valid || false,
pricing_tiers_configured: outputs.calculate_pricing?.tier_count || 0,
recommendations_fetched: outputs.fetch_recommendations?.success || false
},
pricing_summary: outputs.calculate_pricing?.pricing_tiers || {},
validation_results: {
errors: outputs.validate_setup?.errors || [],
warnings: outputs.validate_setup?.warnings || [],
stats: outputs.validate_setup?.stats || {}
}
};
console.log('=== EXECUTION REPORT ===');
console.log('Summary:', report.execution_summary);
console.log('Components:', JSON.stringify(report.components_created, null, 2));
return report;
`,
permissions: {
write_state: true
},
outputs: ['execution_summary', 'timestamp', 'components_created', 'pricing_summary', 'validation_results']
}
}
],
outputs: {
campaign_id: {
value: '${create_campaign.entity_id}',
description: 'Created campaign ID'
},
experiment_id: {
value: '${create_pricing_experiment.entity_id}',
description: 'Dynamic pricing experiment ID'
},
execution_report: {
value: '${generate_report}',
description: 'Complete execution summary'
}
},
config: {
parallel_execution: false,
rollback_on_failure: true,
max_execution_time: 600000 // 10 minutes
}
};
//# sourceMappingURL=PluginEnhancedWorkflowExample.js.map