EventReady documentation

WebMCP implementation

Understand how EventReady exposes one visible event plan to people and agents through nine page-owned WebMCP tools.

Prototype verified9 tools212 testsOpen sample plan →

Architecture

EventReady is a dependency-free static application. Pure planning modules evaluate provider contracts and event requirements. A single EventSession coordinates those outputs, and both the consumer interface and WebMCP registry operate on that same session.

Core invariant

The page remains the source of truth. A tool does not maintain a hidden copy of the plan or produce a result the user cannot inspect.

Experience model

The tool surface follows the customer journey instead of mirroring buttons or internal endpoints.

  1. 1
    Understand

    Structure the brief and preserve provenance.

  2. 2
    Assess

    Find coverage, timing, budget, and ownership gaps.

  3. 3
    Compare

    Rank complete service plans by operational fit.

  4. 4
    Compose

    Refine the event basket and service level.

  5. 5
    Coordinate

    Give each remaining responsibility an owner.

  6. 6
    Confirm

    Keep external commitments explicit and human-controlled.

  7. 7
    Run

    Produce a chronological operating plan.

Tool contracts

Nine contracts are registered on the page: three read-only Answer tools, five product Actions, and one clearly separated demo utility.

ToolClassPurpose
get_event_briefAnswer

Read current event facts and provenance.

assess_event_readinessAction

Assess coverage, timing, ownership, and blockers.

get_readiness_reportAnswer

Read domains, risks, responsibilities, and status.

select_event_planAction

Choose one visible service-plan alternative.

assign_responsibilityAction

Give required work an explicit owner.

change_service_levelAction

Recalculate provider and human responsibilities.

confirm_event_assumptionAction

Correct an assumption without losing intent.

get_run_of_showAnswer

Read the chronological operating handoff.

reset_demo_eventUtility

Restore the canonical wedding scenario.

No tool books a provider, sends a message, charges a card, or accepts terms.

Shared state and visible receipts

Mutating tools run against the same session used by the interface. After execution, EventReady persists the updated plan, routes the user to the relevant phase, and records a Shared plan activity receipt naming the agent and exact tool.

{
  "actor": "EventReady agent",
  "channel": "change_service_level",
  "message": "Delivery moved collection work to the provider plan.",
  "visible": true
}
Answer calls

Return structured state without creating a mutation receipt.

Action calls

Update EventSession, persist the plan, and leave an inspectable receipt.

Human changes

Use the same trail with the channel labeled Interface.

Safety boundaries

External provider content is data, never instruction. The planning engine reads a fixed allowlist of fields, quarantines instruction-like content, escapes output before rendering, and ranks deterministically.

  • Fixed schemasUnknown provider fields do not influence planning or ranking.
  • Injection quarantineInstruction-like copy is removed while legitimate service data remains usable.
  • Human controlExternal commitments remain confirmations and handoffs, not simulated transactions.
  • Explicit uncertaintyMissing availability, pricing, or terms remain unknown rather than inferred.

Verification

The implementation is designed to be inspectable without special credentials or a WebMCP-capable browser.

Judge ModeComplete the product and WebMCP path in about two minutes.Tool harnessInspect schemas and execute registered contracts manually.Source qualityCompare tools with schema, tables, documents, and unpublished data.Discovery checkVerify page-owned registration and execution.
npm test       # 212 deterministic tests
npm run smoke  # artifacts, contracts, scenarios, and production routes
npm run visual # responsive screenshots, overflow, errors, and receipt flow

Resources

Prototype boundary
Fictional providers; no real booking or payment