Built-in pricing functions

Advanced pricing optimization using elasticity analysis, statistical significance testing, and revenue simulation.

Inputs: current price, elasticity, conversion rate. Outputs: computed_price, confidence, alternatives.

Calculate price elasticity of demand from A/B test control and experiment variant metrics.

Inputs: order history with price/quantity pairs. Outputs: elasticity coefficient with confidence interval.

Generate comprehensive pricing recommendations with reasoning, expected impact, and next steps.

Inputs: full product context + objective weights. Outputs: Pareto-optimal price with explanation.

Deterministic variant assignment for A/B pricing experiments with configurable traffic splits.

Inputs: experiment_id, user_id, variants. Outputs: assigned variant. Stable across calls for the same user.

Apply psychological pricing strategies (.99/.95 endings) to optimize conversion rates.

Inputs: candidate price, market segment. Outputs: psychologically-tuned price, supporting heuristic.

AI-assisted protocol translation with hard contracts. Plans a mapping from any merchant schema to the canonical core, then compiles + validates the outbound vendor payload. Powered by @packages/translator.

Inputs: source_schema, source_record, canonical_schema, vendor_contract. Outputs: plan with per-field confidence, compiled payload, validation result, optional review-queue item.

Vendor response normalization. Inverts a Rosetta mapping plan to project a vendor response back into the merchant canonical shape, plus extract Tier 3 passthrough fields.

Inputs: mapping plan, vendor_response. Outputs: canonical record, missing/lossy field reports, Tier 3 passthrough extraction.

Standalone contract validation. Runs the Rosetta validator over a candidate payload (or a compiled mapping output) and returns pass/fail plus structured diagnostics, without invoking the suggester or compiler.

Inputs: candidate payload, vendor_contract (or canonical_schema). Outputs: pass/fail plus structured diagnostics — runs the validator alone, without invoking the suggester or compiler.

Schema-mapping suggestion only. Runs the heuristic / LLM suggester over a source schema and canonical target to draft a mapping plan with per-field confidence — no compilation, no validation. Designed for the Mapping Studio "draft from samples" flow.

Inputs: source_schema (and/or sample records), canonical_schema. Outputs: draft mapping plan with per-field confidence. No compile, no validation — designed for the Mapping Studio 'draft from samples' flow.

Promote a reviewed Rosetta mapping plan to a frozen, hash-pinned adapter. Closes the canonical → suggester → compiler → validator → normalizer → review → freeze lifecycle so production callers can pin a known-good mapping.

Inputs: a reviewed mapping plan. Outputs: a frozen, hash-pinned adapter that production callers can pin against drift.

Autonomous merchant onboarding. One call: fingerprints the payload shape, looks up a frozen adapter by (tenant, fingerprint, canonical_target), and on a cache miss infers the source schema, suggests a mapping, and either auto-freezes (high confidence), translates best-effort and queues a review (medium), or refuses to guess and returns a review_id (low). Drift re-runs the same pipeline.

Inputs: an inbound merchant payload + canonical_target. Outputs: one of (frozen adapter + canonical record, best-effort canonical record + review_id, refusal + review_id). Single autonomous call: fingerprints the payload, looks up a cached frozen adapter, and on a miss runs infer-schema → suggest → compile → validate → high/medium/low-confidence gate. Drift re-runs the same pipeline.

Sequential significance testing for A/B pricing experiments (SPRT and Bayesian posterior). Returns whether the variant difference is significant, the test statistic, and a recommended action (continue / stop-winner / stop-loser).

Inputs: control + variant counters (and optional priors). Outputs: significance verdict, test statistic, recommended action (continue / stop-winner / stop-loser). Supports SPRT and Bayesian modes.

Multi-armed bandit traffic allocation for A/B pricing experiments (Thompson sampling / epsilon-greedy). Returns per-variant traffic weights that adapt to observed reward, replacing fixed splits when you want to minimize regret.

Inputs: variants with observed reward + trials. Outputs: per-variant traffic weights from a multi-armed bandit (Thompson sampling / epsilon-greedy) so allocation adapts as evidence accrues.

Optimize bundle pricing across multiple SKUs. Accounts for cross-elasticities, anchor effects, and component substitution to recommend a bundle price (and optional tiered discounts) that maximize expected revenue.

Inputs: component SKUs with prices, elasticities, and (optional) cross-elasticities. Outputs: recommended bundle price plus optional tiered discount ladder.

Optimize price points across a tiered catalog (e.g. SaaS plan ladder). Solves for tier prices that maximize revenue subject to monotonicity and willingness-to-pay constraints across segments.

Inputs: current tier ladder + per-segment willingness-to-pay. Outputs: optimized tier prices honoring monotonicity, subject to revenue / conversion objectives.