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.

Price from a declared unit cost and target margin, or from a supplied price band, for callers with no existing price to price against. Refuses rather than inventing a price when given no basis.

Evaluate a caller-supplied competitor offer against a stated match or undercut goal and a cost, margin or minimum-price floor. Requests missing inputs rather than inventing them.

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.

Stateless two-arm price split for a single call. Hashes the user and experiment ids to control (the current price) or experiment (the current price raised 10% with a charm ending), always half and half, and records nothing. For a tracked experiment with your own prices, weights and results, use the Experiments API.

Inputs: current_price, plus metadata.user_id and metadata.experiment_id. Outputs: a price, the current one for the control half of users and a 10% rise for the other half, stable for the same user. Records nothing and takes no variants or weights; to run a tracked A/B test, use the Experiments API.

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.

Bayesian significance test for A/B pricing experiments. Call POST /api/compute/significance with each variant's trials and conversions: it returns each variant's chance of being best, expected loss and 95% credible interval, and a verdict of winner, equivalent or continue; with two variants it adds Wald's sequential probability ratio test.

Inputs: 2 to 10 variants (id, trials, conversions), optional prior, win_probability (default 0.95) and loss_threshold (default 0.001). Its own endpoint, not POST /api/compute/price, since it returns no price.

Thompson-sampling traffic allocation for A/B pricing experiments. Call POST /api/compute/allocation with each variant's trials and conversions: it returns each variant's share of traffic (its chance of being best, with a minimum floor so none is starved), computed exactly or by seeded Monte Carlo.

Inputs: 2 to 10 variants (id, trials, conversions), optional prior, min_weight (default 0.01), and mode exact or monte_carlo with draws and seed. Its own endpoint, not POST /api/compute/price, since it returns no price.

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.