Reported travel guides: countries, towns, sights, trails, events, ski resorts. Cited.
Scored across 20 tools
Each tool has a narrow, explicitly stated role, and descriptions repeatedly route the agent to the correct alternative (e.g., get_place vs get_destination vs get_dispatch, suggest_edit vs confirm_fact, create_plan vs create_itinerary_link). The broad content-retrieval family is large but the page-type and query-type distinctions are clear.
All tool names use snake_case and follow a verb_noun pattern (get_*, list_*, create_*, edit_*, delete_*, suggest_*, confirm_*). Occasional modifiers like my or for_my_day do not break the convention.
Twenty tools is on the heavy side, but the scope is genuinely broad: guide content, search, events, nearby places, plan management, account/preferences, and user contributions. Each tool appears to cover a distinct operation rather than duplicating another.
The set covers the domain lifecycle well: content discovery and retrieval, ranked/best-time/event/nearby views, full plan CRUD, travel preferences/account context, and contribution paths for facts, edits, and new places. No obvious operational gap would force an agent into a dead end for the stated travel-guide and planning purpose.
Tell the Meridian Dispatch desk that a fact on one of its pages still holds, with the current, independent source that shows it (the place's official website, an operator or government page). Use it when the traveller confirms a fact on a page (they were just there, or asked you to check it and the source agrees). If the fact is wrong instead, use suggest_edit. Quote checked_text exactly as the page (or this server's answer) gives it and pass the source; a quote not on the page, or a source on meridiandispatch.com, is refused. A confirmation is recorded as a signal for the desk to review and counted per page; it does not mark the page verified, change its date or reorder any list, and the page itself does not change. The same confirmation sent twice is recorded once. Returns whether it was recorded.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | The meridiandispatch.com page, as returned in source.url. | |
| source_url | Yes | Where you checked it: a current, authoritative page that is not on meridiandispatch.com. | |
| checked_text | Yes | The fact you checked, quoted from the page, e.g. a facts_to_check text. |
| Name | Required | Description |
|---|---|---|
| next | No | |
| page | No | |
| received | No | |
| duplicate | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations (readOnlyHint=false, idempotentHint=true, destructiveHint=false), the description discloses the actual side effect profile: it is recorded as a signal for desk review and counted per page, but 'does not mark the page verified, change its date or reorder any list, and the page itself does not change.' It also explains the refusal conditions and confirms idempotency in plain language ('The same confirmation sent twice is recorded once'), which is exactly the kind of context annotations cannot carry.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The definition is dense and front-loads the core action, then layers trigger, alternative, validation rules, and side effects in a logical order. Most sentences earn their place, though the closing 'Returns whether it was recorded' is partly redundant given the output schema, and the middle clauses pack many constraints into single sentences.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present, the description only needs to name the return ('Returns whether it was recorded'), which it does. Combined with the annotations and full schema coverage, an agent has everything needed: trigger, alternative, validation rules, and the exact (non-)effects of the call.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3; the description still adds meaning by demanding checked_text be quoted 'exactly as the page (or this server's answer) gives it' and by stating the consequences for a non-matching quote or a meridiandispatch.com source. It does not add format or length guidance beyond what the schema already supplies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource ('Tell the Meridian Dispatch desk that a fact on one of its pages still holds') and immediately scopes it with the required evidence ('with the current, independent source that shows it'). It also distinguishes itself from the sibling tool that handles the opposite case ('If the fact is wrong instead, use suggest_edit'), so an agent can route without opening either schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives an explicit trigger ('Use it when the traveller confirms a fact on a page (they were just there, or asked you to check it and the source agrees)') and an explicit alternative for the inverse case ('use suggest_edit'). The preconditions for acceptance are also spelled out (quote must appear on the page, source must not be on meridiandispatch.com), leaving nothing to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generate an itinerary import link: turn a day-by-day travel itinerary into a shareable "Add Itinerary to Meridian Dispatch" link. Use it only when the traveller wants a link to share or open elsewhere. To save a trip to the traveller's own account, privately, use create_plan (or edit_plan for one they have): that needs no link and can be deleted. To draft the plan itself, use get_destination, get_dispatch and get_place first and link places with their meridiandispatch.com URLs; for a trip the traveller will take themselves, read get_travel_preferences first (it needs sign-in) and fit the hotels, pace and routing to it. Opening the link on an iPhone with the Meridian Dispatch app shows the trip and adds it to the Plan tab as a new plan, after the traveller picks the first day; anywhere else it opens a web preview of the days. Days are numbered (day 1, 2, 3) or dated, and every day needs a hotel stay or its own city. A dated link opens on its dates, which the traveller can still move. When the dates are not negotiable (a trip built around a festival, a match, a concert or any event on fixed days), date every day and set fixed_dates: the app then adds the trip on exactly those dates with no date picker, and the link's page tells the traveller so. A place given with its meridiandispatch.com page URL arrives with that page's field record. Each call creates a new, public, permanent link that cannot be deleted (not idempotent). Anyone with it sees the trip's dates, towns, stops and hotel names; booking references, emails and phone numbers are removed. Tell the traveller this before making one. Returns the link, ready-made markdown, counts of days and items, and the places matched and not matched to the guides. An invalid itinerary returns an error listing every problem; too many links in an hour returns a rate-limit error.
| Name | Required | Description | Default |
|---|---|---|---|
| car | No | A rental car the trip needs (a road trip, or days in the countryside). The app adds it as a car rental still to book and draws those days' travel as driving. from_day and to_day are day numbers on both numbered and dated itineraries; to_day may be the morning after the last day. Picked up and returned at airport and airport_home unless pickup or dropoff name other airports. | |
| days | Yes | The days in order, each with what to do. Number every day or date every day, not a mix. Every day needs its own city or a stay (in stays) whose check-in to check-out, inclusive, covers it; the error names each day with neither. | |
| stays | No | Where the traveller sleeps, by hotel name. Optional: a day not between a stay's check-in and check-out (inclusive) must give its own city, which places it in the app until a hotel is added. check_in_day and check_out_day on a numbered itinerary, check_in and check_out (YYYY-MM-DD) on a dated one. | |
| title | Yes | The trip, e.g. "Six days on the Montenegro coast". | |
| airport | No | IATA code of the airport to fly into, e.g. "GDN". The app books the flight in to it on day 1 instead of guessing (a country's busiest airport is often the wrong one: Warsaw for Gdańsk). | |
| summary | No | One short paragraph shown under the title: what the trip is and why it works. | |
| fixed_dates | No | true when the trip only works on its dates, e.g. it is built around an event. Needs a date on every day (not day numbers). The app imports it on those dates and the traveller cannot move them. Leave out for a trip that works any time. | |
| airport_home | No | IATA code of the airport to fly home from, when it differs from airport. | |
| country_code | Yes | ISO 3166 alpha-2 code of the main country, e.g. "ME". |
| Name | Required | Description |
|---|---|---|
| url | No | The link to give the traveller. |
| days | No | |
| dated | No | |
| items | No | |
| opens | No | |
| title | No | |
| markdown | No | |
| link_text | No | |
| fixed_dates | No | |
| unmatched_places | No | Places that matched nothing in the guides; resend with the proper name to attach a location. |
| places_matched_to_guides | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only flag non-readonly, non-idempotent and open-world; the description adds what actually matters: each call makes a new public permanent link that cannot be deleted, what third parties can see (dates, towns, stops, hotel names) versus what is stripped (booking refs, emails, phones), plus per-hour rate limiting and error behavior. It also explains platform-dependent outcomes (iPhone app vs. web preview) and how fixed_dates bypasses the date picker.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with the purpose, then usage, then alternatives, then behavior — a sound ordering with no filler sentences. It is very long, though, and a few clauses (e.g. restating that a dated link can be moved) could be trimmed without losing decision-relevant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a complex 9-parameter, deeply nested tool with an output schema available, the description still covers what the schema cannot: privacy implications, permanence, rate limits, validation-error shape, and platform-specific link behavior. Nothing an agent needs to warn the traveller or to call this correctly is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so nested fields like car, stays, meridian_url and fixed_dates are already fully documented structurally. The description reinforces the day-vs-date consistency rule and the day-number semantics but adds almost no parameter detail the schema does not already carry, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and artifact: "Generate an itinerary import link ... into a shareable 'Add Itinerary to Meridian Dispatch' link." It immediately distinguishes itself from create_plan and edit_plan, so an agent can pick the right sibling without opening schemas.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives explicit when-to-use ("only when the traveller wants a link to share or open elsewhere") and when-not ("To save a trip to the traveller's own account, privately, use create_plan ... edit_plan"), plus prerequisites naming get_destination, get_dispatch, get_place and get_travel_preferences. Alternatives and their selection conditions are all spelled out.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Make a new plan in the traveller's Meridian Dispatch app: a title, a first day and a number of days, optionally with ops to fill it (the same ops as edit_plan). It appears on the website at once and in the app on its next sync. A free account holds one plan; members have as many as they like. Read get_travel_preferences before filling it, so the hotels, pace and routing fit how this traveller travels. Needs sign-in.
| Name | Required | Description | Default |
|---|---|---|---|
| ops | No | Optional: the same ops as edit_plan, applied at once. | |
| days | Yes | How many days. | |
| title | Yes | ||
| start_date | Yes | The first day, YYYY-MM-DD. | |
| country_codes | No | ISO alpha-2 codes, the main country first. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond annotations, it discloses sync behavior (website immediately, app next sync), account quota limits, sign-in requirement, and that ops can be supplied at creation time. These are meaningful operational details for a non-read-only tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The core action and required fields are front-loaded, followed by useful prerequisite, sync, quota, and auth context. Each sentence adds practical value without bloat.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a create tool with no output schema and rich annotations, the description covers creation inputs, optional ops, sync timing, quotas, and auth. It leaves return-value and failure behavior unstated, but the main invocation context is complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is high at 80%, so the schema already carries most parameter meaning. The description reinforces required fields and explains ops as filling the plan using the same ops as edit_plan, but it does not document country_codes or constraints beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: "Make a new plan," and names the required fields (title, first day, number of days) plus optional ops. It also distinguishes creation from edit_plan by calling this a new plan while noting ops are the same as edit_plan.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Clearly frames this as the creation path and gives a concrete prerequisite: read get_travel_preferences before filling the plan. It does not explicitly describe when not to use it or name create_itinerary_link as an alternative, but the create-vs-edit context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Delete a plan from the traveller's account; the app removes it on its next sync. Only when the traveller has asked for it. Needs sign-in.
| Name | Required | Description | Default |
|---|---|---|---|
| plan_id | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations, the description discloses important behavior: the deletion occurs on the app's next sync, it affects the traveller's account, and it requires sign-in. These details add real operational context to the destructive and idempotent hints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three short sentences, front-loaded with the action and delayed-sync behavior, followed by the consent and authentication constraints. Every sentence adds useful information without filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter destructive tool with rich annotations, the description covers timing, account scope, consent, and authentication. The only notable gap is plan_id semantics, which is important but partially mitigated by the parameter's self-explanatory name.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% for the single plan_id parameter, and the description never explains what the plan identifier is, where it comes from, or expected format. It does not compensate for the schema's lack of parameter documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb (Delete) and resource (a plan) and scopes it to the traveller's account. It does not explicitly name or distinguish itself from siblings such as edit_plan or get_plan, but the deletion action is clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives an explicit usage condition ('Only when the traveller has asked for it') and a prerequisite ('Needs sign-in'). It does not name alternative tools or when-not situations beyond the consent condition, so it falls short of the highest tier.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Change a plan with a list of ops (see the ops schema), applied in order, all or nothing; days are named by date (YYYY-MM-DD), set_start_date moves every day and booking, and close_day takes out a day between the first and last and moves every later day one date earlier (bookings keep their dates). base_seq is required: the seq from get_plan, so a plan changed elsewhere since you read it is refused rather than overwritten; on a conflict, read it again and redo the edit. Stop and booking ids come from get_plan. Prefer places from get_destination or get_place (meridian_url), so the map can place them; title each place by its proper name with what the traveller does there in visitNote, give every other real place its lat and lng, and every place a time, in the order of the day, so the app can draw the travel between them (a place without a time is timed after the one before it). Ask the traveller before removing anything. Needs sign-in.
| Name | Required | Description | Default |
|---|---|---|---|
| ops | Yes | ||
| plan_id | Yes | ||
| verbose | No | Return the whole plan. By default the reply shows only the days and bookings the edit touched. | |
| base_seq | Yes | The seq from get_plan or list_my_plans. Required. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Adds substantial context beyond the already-informative annotations: all-or-nothing atomicity, ordered ops application, optimistic concurrency via base_seq with refusal rather than overwrite on conflict, side effects of set_start_date and close_day on later days and bookings, and the sign-in requirement. The destructiveHint annotation is reinforced and given concrete scope, not merely repeated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with the core mechanism, but the entire description is a single run-on paragraph chained with semicolons, mixing atomicity, concurrency, place-authoring conventions, and confirmation policy. The content is largely justified by tool complexity, but it would be far more usable broken into short labeled clauses.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a complex destructive mutation tool with no output schema, the description covers concurrency safety, ordering, side effects of temporal ops, place authoring conventions, and confirmation policy. An agent has everything needed to call this correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 50%, but the nested ops schema is extremely detailed and the description adds cross-parameter meaning: base_seq's conflict behavior, ops ordering, and conventions for meridian_url, visitNote, lat/lng, and time ordering. It doesn't enumerate every op's semantics (set_day, move_stop, add_booking details are left to the schema), which keeps it below 5.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Opens with a specific verb and resource ("Change a plan") and immediately defines the mechanism: a list of ops applied in order, all or nothing. This distinguishes it clearly from create_plan, delete_plan, get_plan, and suggest_edit as a direct, atomic mutation tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives strong prerequisites and workflow: base_seq must come from get_plan, stop/booking ids come from get_plan, places should be sourced from get_destination/get_place, and on conflict the agent should re-read and redo. The removal-confirmation requirement ("Ask the traveller before removing anything") is explicit. It does not explicitly contrast itself with suggest_edit, leaving that inference to the agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get the best time to visit from the Meridian Dispatch guides, in one of two modes. Give destination (a country, town, trail or ski resort) for its best months, good and avoid months, closures and crowds where known, the guide's own best-time line, and the events held there. Or give month for "where to go in March": up to 40 countries, towns, trails, ski resorts and festivals the guides recommend that month, each with its reason, events first. If both are given, destination wins. For festival dates alone use list_events; for a full planning guide use get_destination. Read-only. An unknown destination, an invalid month or neither parameter returns an error message.
| Name | Required | Description | Default |
|---|---|---|---|
| month | No | An English month name ("October", or "oct") or its number, 1 to 12 ("10"). Use this or destination. | |
| region | No | With month: only this part of the world ("where in Asia in February"). Ignored with destination. | |
| destination | No | A country, town, trail or ski resort, by name, e.g. "Kotor" or "Niseko". Use this or month. |
| Name | Required | Description |
|---|---|---|
| note | No | |
| month | No | |
| crowds | No | |
| source | No | How to credit this answer: show cite_as, or link url. |
| closures | No | |
| best_months | No | |
| destination | No | |
| good_months | No | |
| recommended | No | For a month: destinations recommended then. |
| avoid_months | No | |
| events_there | No | |
| in_their_words | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly/idempotent/non-destructive, and the description usefully adds unannotated behavior: precedence between parameters, that region is ignored with destination, the ~40-result ceiling for month mode, ordering (events first), and that unknown destination / invalid month / no params return an error rather than throwing. Only minor repetition of "Read-only" is wasted.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with the two-mode framing and dense but purposeful; every clause adds routing or scope information. The long run-on enumeration of return contents is slightly heavy, but nothing here is filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 3 optional params, no required params, and an output schema handling return shape, the description supplies exactly the missing pieces: mode selection, precedence, exclusions, sibling alternatives, and error behavior. Nothing an agent needs to call it correctly is absent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3, but the description adds cross-parameter semantics the schema does not encode: destination overrides month, and region applies only with month. It does not, however, add format detail for month beyond what the schema already says.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific resource (best-time guidance from Meridian Dispatch guides) and enumerates precisely what each mode returns: best/good/avoid months, closures, crowds, the guide's best-time line, events; or up to 40 places for a month. It is immediately distinguishable from get_destination (full planning guide) and list_events (festival dates alone).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly frames two modes with the input that selects each, resolves the ambiguous case ("If both are given, destination wins"), and routes to two named siblings with the condition that selects them. Error conditions are also stated, so an agent knows the failure envelope.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read the Meridian Dispatch guide to one country or one town, for planning a stay there. Returns: why go, how long to stay, the best months, getting there and around, practical FAQ answers, a structured fact sheet where one exists (nights, months, travel times in minutes, areas to stay, ranked top things, day trips, watch-outs), up to 15 ranked places worth your time with their own guide links, recommended hotels, the town guides of a country, related dispatches and a citation. Use it for "what to do in X", "how many days in X" or "where to stay in X". For a single sight, trail, event or ski resort use get_place; for a long-form dispatch use get_dispatch; to find a destination by theme use search_guides; for towns within reach use list_nearby. Two sizes: detail "summary" (the default) returns a short overview, nights, months, airports, areas to stay and the top 8 places, each with an id to pass to get_place as url; detail "full" returns everything above. Ask for "full" only when the summary lacks what the traveller needs. Matching tries a country first, then a town. A country with town guides but no country guide returns its town guides and dispatches instead. Read-only. An unknown name returns an error message.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | One country or town, by English name, e.g. "Slovenia" or "Bled". Case and accents are ignored. Not a sight or region: use get_place or search_guides for those. | |
| detail | No | "summary" (default): a compact answer of a few thousand characters with place ids to drill into. "full": the whole guide (FAQ answers, full fact sheet, every ranked place, hotels), often over 15,000 characters. | summary |
| country | No | The country of the town, by English name, to tell apart towns that share a name (Granada, Valencia, Mérida). Omit when name is a country or a unique town. |
| Name | Required | Description |
|---|---|---|
| lat | No | |
| lng | No | |
| name | No | |
| note | No | |
| type | No | |
| photo | No | Lead photograph: url, alt text and credit. |
| stays | No | Hotels the guide recommends. |
| detail | No | |
| places | No | The places worth your time, ranked. |
| source | No | How to credit this answer: show cite_as, or link url. |
| country | No | |
| summary | No | |
| verdict | No | |
| overview | No | Opening paragraphs of the guide. |
| planning | No | Short answers: days needed, best time, getting there, getting around, language, money. |
| practical | No | Practical questions and answers not already covered by planning. |
| dispatches | No | Related long-form dispatches. |
| fact_sheet | No | Structured planning data: nights, months, getting_there, where_to_stay, top_things, day_trips, watch-outs. |
| best_months | No | |
| coords_note | No | |
| places_note | No | |
| town_guides | No | For a country: its town guides. |
| places_total | No | |
| country_guide | No | meridiandispatch.com URL. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover read-only, idempotent and closed-world, and the description adds behavior beyond them: country-then-town matching order, the fallback where a country with town guides but no country guide returns town guides and dispatches, and that an unknown name returns an error message. These are exactly the runtime traits an agent needs to predict outcomes.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with purpose and a summary sentence of what is returned, then alternatives, then size semantics. It is dense but every clause carries information; the long comma-separated returns enumeration is the only slightly heavy part.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a three-parameter read tool with full schema coverage and an output schema, nothing an agent needs is missing: purpose, contents, size choice, disambiguation, fallbacks and error behavior are all stated.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3, but the description adds real value: summary places carry ids to pass to get_place as url, "full" returns everything above, and the summary/full size tradeoff is quantified. The matching-order note also informs how the name parameter resolves.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Opens with a specific verb and resource ("Read the Meridian Dispatch guide to one country or one town") and immediately scopes it to stay planning. It then enumerates what the guide contains, so an agent can tell it apart from get_place, get_dispatch and search_guides without opening any schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives concrete trigger phrasings ("what to do in X", "how many days in X", "where to stay in X") and explicit exclusions routing to get_place for sights/trails/events, get_dispatch for long-form, search_guides for themes, list_nearby for nearby towns. It also advises requesting detail "full" only when the summary is insufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read one Meridian Dispatch long-form dispatch or multi-day itinerary. A dispatch is a reported piece on one place: returns its headline, standfirst, opening excerpt, themes, publish date, photo and links to its town and country guides (the full text stays on the page). An itinerary is a country route over several days: returns the bases in order, nights in each, where to stay and every day's activities by part of the day, each linked to its guide. Use it only for these two kinds of page. For a country or town guide use get_destination; for one sight, trail, event or ski resort use get_place; to list dispatches on a theme use search_guides with type "dispatch" or "itinerary". Lookup order: an exact URL, then an exact slug, then the single best keyword match, so a place name returns the one most relevant dispatch. Read-only. No match returns an error message.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | A dispatch or itinerary URL, its slug (e.g. "hallstatt", "montenegro-beach-six-days"), or the place it covers (e.g. "Hallstatt"). |
| Name | Required | Description |
|---|---|---|
| lat | No | |
| lng | No | |
| note | No | |
| type | No | |
| photo | No | Lead photograph: url, alt text and credit. |
| place | No | |
| route | No | For an itinerary: bases, nights and day_by_day activities. |
| source | No | How to credit this answer: show cite_as, or link url. |
| themes | No | |
| excerpt | No | |
| headline | No | |
| published | No | |
| standfirst | No | |
| town_guide | No | meridiandispatch.com URL. |
| country_guide | No | meridiandispatch.com URL. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, non-destructive, and closed-world, so the safety profile is covered. The description still adds real behavioral facts: the URL > slug > keyword resolution order, that full text stays on the page, and that no match returns an error. That is useful, though it is mostly about matching rather than failure modes, permissions, or pagination.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with the core action and resource before branching into content-type detail and routing. It is on the long side, but each sentence—returns for each type, use restrictions, alternatives, lookup order, error behavior—adds distinct information rather than repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists so return values need not be documented, yet the description still previews what each page type returns. Combined with the routing guidance and lookup-order rules, an agent has everything needed to select and invoke this tool correctly against its twelve siblings.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema already documents the single query parameter and its accepted formats. The description goes beyond it by explaining how an ambiguous query is resolved (exact URL, then exact slug, then single best keyword match), which is meaning the schema does not carry.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Opens with a specific verb and resource ('Read one Meridian Dispatch long-form dispatch or multi-day itinerary') and then defines both content types explicitly, so an agent knows exactly what kind of page this fetches. It also distinguishes itself from get_destination, get_place, and search_guides by name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives an explicit when-to-use ('only for these two kinds of page') plus a routing table to the correct sibling for country guides, town guides, single sights/trails/events/resorts, and dispatch listings. Exclusions and alternatives are both stated, leaving nothing to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
The Meridian Dispatch account this connection is signed in to: the name (and email, unless the traveller hid it from Apple), when it was made, whether the app on a phone is signed in to it, its plan titles, and whether travel preferences are saved. Use it to confirm the account before editing, since a traveller can hold two Apple accounts. Needs sign-in.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare read-only, idempotent, closed-world behavior, and the description adds real context on top: an auth requirement and two data caveats (the Apple-hidden email and the possibility of two accounts making the identity ambiguous). It does not cover failure modes or what happens when unauthenticated, keeping it below a 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the resource and its return contents, then the usage and auth requirement. Every clause carries information; nothing is redundant with the title or annotations.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
A parameterless read with no output schema, and the description compensates by enumerating the returned fields and noting where data may be missing. An agent has everything needed to decide to call it and interpret the response.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The description correctly spends no words on inputs.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Names the specific resource (the account this connection is signed in to) and enumerates exactly what it returns: name/email, creation date, phone-app sign-in status, plan titles, and whether travel preferences are saved. That field list makes it unambiguous against siblings like get_travel_preferences or list_my_plans.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives an explicit use case (confirm the account before editing) and a rationale (a traveller can hold two Apple accounts), plus the prerequisite 'Needs sign-in.' It stops short of naming which sibling to use instead for preference or plan data, so it is clear context rather than a full when/when-not routing rule.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read the Meridian Dispatch field record for one place: a sight, museum, beach or park, a trail or scenic drive, an event, or a ski resort. Returns the best time to go, how long it takes, effort, season, access, how to get there and what goes wrong, plus the best months, practical answers, a photo, the town guide link, reviews by travellers who went when there are any (traveller_reviews) and a citation; an event adds its dates and schedule, a trail its route facts. Use it once you know the place. For a whole country or town use get_destination; for a dispatch use get_dispatch; to find a place you cannot name exactly use search_guides; for what else is close use list_nearby. Give url, or name (at least one). A place mentioned on a town guide with no page of its own returns its short write-up and that guide. A URL of a town, country or dispatch page returns that guide instead. Read-only. No match returns an error message.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | The place's meridiandispatch.com page URL, from a search_guides or get_destination result. Takes priority over name. | |
| name | No | The place's name, e.g. "Kotor Old Town" or "Grunas Waterfall". Exact names match first, then names that contain it. | |
| town | No | The town the place is in or visited from, e.g. "Kotor", to narrow a name shared by several places. | |
| country | No | The place's country, by English name, to narrow a name shared by several places. |
| Name | Required | Description |
|---|---|---|
| lat | No | |
| lng | No | |
| why | No | |
| name | No | |
| town | No | |
| type | No | |
| event | No | For an event: dates, best day, when to book, where to stay, schedule. |
| photo | No | Lead photograph: url, alt text and credit. |
| source | No | How to credit this answer: show cite_as, or link url. |
| country | No | |
| summary | No | |
| overview | No | |
| practical | No | Questions travellers ask about the place, each {q, a}, as the page answers them. Where the page can open at its FAQ, each also has a url: cite that link when the answer came from it. |
| town_guide | No | meridiandispatch.com URL. |
| at_a_glance | No | Best time, time needed, effort, season, access. |
| best_months | No | |
| official_tickets | No | The place's own online ticket shop, when it has one. Never a reseller. |
| traveller_reviews | No | Reviews by travellers who went, when there are any: verdict (Worth it to Skip it), rating out of 5, count, and up to five reviews, each {verdict, text, by, visited, countries_visited, published}. Opinions, not the guide. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly/idempotent/non-destructive, and the description adds genuinely non-obvious behavior: a place without its own page returns a short write-up plus its parent guide, a URL belonging to a town/country/dispatch returns that guide instead, and no match returns an error. These fallback semantics materially change how an agent should interpret the result and are not derivable from annotations or schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Purpose and routing alternatives are front-loaded and the edge cases are worth their space, but the return-value enumeration ('how to get there and what goes wrong, plus the best months, practical answers, a photo...') is a dense run-on list that partly duplicates what the output schema already conveys.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given an output schema exists, the description need not explain returns, yet it covers identification inputs, disambiguation inputs, fallback behavior and error behavior. An agent has everything needed to call this correctly or route elsewhere.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3; the description adds a real constraint not encoded in the schema — 'Give url, or name (at least one)' — since zero parameters are marked required. It adds less about town/country narrowing, which the schema already explains.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Read the Meridian Dispatch field record for one place') and enumerates the entity types covered (sight, museum, beach, park, trail, scenic drive, event, ski resort). An agent can distinguish this from get_destination, get_dispatch and search_guides without opening any schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit trigger ('Use it once you know the place') plus four named alternatives with the condition that selects each: get_destination for country/town, get_dispatch for a dispatch, search_guides when the name is imprecise, list_nearby for proximity. Nothing is left to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
One of the signed-in traveller's plans, day by day: each day's date, town and stops (with each stop's id, time, minutes, category, visitNote (what the traveller does there that day), note (the place's advisory), ticketsURL (its booking page) and, for a table, tour or ticket, booked (true held, false still to book; a place with neither is JUST TURN UP, nothing to reserve)); a titleless freeform stop is marked role transfer, note or alternative), its bookings (with booked or still to book, and their details: a flight's airline, number, airports, terminals, seat and times; a hotel's address and check-in/out times; a train's operator and stations; a car rental's desks), and seq, the version to send back with edit_plan as base_seq. Needs sign-in.
| Name | Required | Description | Default |
|---|---|---|---|
| plan_id | Yes | The plan id from list_my_plans. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare read-only, idempotent, non-destructive behavior. The description adds useful context beyond that: sign-in is required, the response is a detailed day-by-day plan, and seq is a version token for edit_plan.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description front-loads purpose but is one very dense sentence with nested parentheses and semicolons. The output detail is useful, especially without an output schema, but the structure is hard to scan and could be organized more clearly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Because there is no output schema, the description carries the burden of explaining return values, and it does so thoroughly for days, stops, bookings and seq. It still omits error/not-found behavior and top-level response framing, but it is largely complete for a read-only lookup.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the single parameter plan_id already says it comes from list_my_plans. The description does not add further meaning about plan_id, so the baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description makes clear that it returns one signed-in traveller's plan day by day, including stops, bookings and seq. It does not open with an explicit verb, but the resource and scope are unambiguous, and it references edit_plan as the related sibling.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied: retrieve a plan before sending seq back to edit_plan, and sign-in is required. There is no explicit guidance on when to use this versus list_my_plans or other plan-related siblings, so the agent must infer the context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
The signed-in traveller's travel preferences, as set in the Meridian Dispatch app (How you like to travel): how much they like each kind of travel (coast, old towns, ancient sites, nature, scenic drives, big cities, hiking, museums, food, nightlife, snow, wellness: love, like, sometimes or not for me), the stays they like, their hotel level (budget, mid-range, luxury, ultra luxury: a level in words, never a price) and where their hotels sit (old town, beach, countryside...), their pace (one base, a few bases, always moving), how far a trip goes (stay put, a region, cover ground) and how they get around (drive, trains, a mix), the shape of their days (packed or unhurried, early or late starts, evenings), how they fly (direct, connecting, stopovers) and in which cabin, the airport they fly from (with its IATA code, the other nearby airports they use, and the city code such as NYC or LON when any airport in that city will do), whether they choose main cities or go deep into a country, whether they want new places or old favourites, and the countries they have been to (ISO codes). Worked out in the app from what they actually did, or set by them. Use it to pick bases and hotels at their level, size a day to their pace, route a trip the way they travel, start and end the flights at their home airport, and tell new countries from ones they know. Needs sign-in.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover readOnly, idempotent, non-destructive and closed-world, so the safety profile needs no restating. The description adds two things annotations cannot: that sign-in is required, and that values are either derived by the app from past behaviour or set explicitly by the user — useful provenance for judging trust in the data. Pagination/absence-of-data behaviour is still unstated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
It is front-loaded with the purpose first, which is good, but the body is effectively one ~200-word run-on sentence packing every preference field into a single enumeration. The content is relevant (there is no output schema, so the return shape has to live somewhere), but the structure makes it hard to scan and some field lists are padded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema and no parameters, the description carries full responsibility for describing the return value, and it does so exhaustively — enumerating preference dimensions, value vocabularies (love/like/sometimes/not for me, budget-to-ultra-luxury, one base/few bases/always moving), and formats such as IATA and ISO codes. It does not say what happens when preferences are unset or when the user is not signed in.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so there is no schema semantics to explain and the baseline is 4. The description correctly offers no argument guidance.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The opening clause states a specific verb and resource — the signed-in traveller's travel preferences as set in the Meridian Dispatch app — and enumerates the preference domains, so the agent knows exactly what comes back. It does not name a sibling (e.g. get_my_account) to disambiguate against, which keeps it from a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The final sentences give concrete downstream uses: pick bases and hotels at their level, size a day to their pace, route a trip, anchor flights at the home airport, distinguish new from known countries. That is clear context for when to reach for it, but no exclusions, prerequisites, or named alternative tools are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List Meridian Dispatch's ranked World's Best places: the 20 best in the world or the 10 best in one country, overall or within one category. Use it for "top things to do in X" or "best beaches in X". For one town's highlights use get_destination; for places near a point use list_nearby; for any other search use search_guides. Returns the list's title, the places in rank order (rank, name, where, a one-line summary, the place's own guide URL where one exists, and a coordinate), the other categories available for that scope, and a citation. Read-only. A country or category with no list returns an error that names the ones that exist.
| Name | Required | Description | Default |
|---|---|---|---|
| country | No | The country to rank, by English name, e.g. "Italy". Omit for the world list. | |
| category | No | One kind of place: landmarks, museums, towns, wilderness, hiking trails, scenic drives, parks, viewpoints, beaches, shopping, wildlife, wellness or ski resorts. Singular and plural both work. Omit for the overall list. |
| Name | Required | Description |
|---|---|---|
| list | No | |
| ranked | No | Best first. |
| source | No | How to credit this answer: show cite_as, or link url. |
| other_categories | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, non-destructive, and non-open-world behavior. The description adds genuinely useful behavioral context beyond them: the error semantics for an empty country/category (an error naming the existing lists) and confirmation of the scoped return contents. It stops short of rich detail but the annotation bar is already met.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Four sentences, all front-loaded: purpose/scope first, then usage triggers and alternatives, then return shape, then error behavior. No filler and no redundancy with the schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With zero required params, a rich output schema, and full annotation coverage, the description supplies exactly the missing pieces: when to choose this tool, the alternates to avoid, and what happens on an empty result. An agent has everything needed to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so both parameters are fully documented in the schema with examples and omission semantics. The description reinforces intended usage through sample phrases but adds no format, syntax, or constraint detail beyond what the schema provides, which is the expected baseline case.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (list) and a well-defined resource (Meridian Dispatch's ranked World's Best places), including scope dimensions (20 world / 10 country, overall or category). It explicitly distinguishes itself from get_destination, list_nearby, and search_guides, so an agent can route without opening sibling schemas.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives concrete trigger phrases ('top things to do in X', 'best beaches in X') plus explicit when-not conditions routing to three named alternatives for town highlights, proximity, and other searches. Nothing is left to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List the festivals and events worth planning a trip around, from the Meridian Dispatch events guide. Returns each event's name, kind, where it is, the current edition's dates (a label plus ISO start and end), the best day to go, when to book, the next edition where announced, a citable URL and a citation line, sorted by start date. With no filter it returns every event; month keeps events with any day in that month; country keeps one country. Use get_place with an event's URL for its full record (schedule, where to stay, tips). For every kind of destination in a month, not just events, use get_best_time. Read-only. Dates are for one edition, so check the page before booking. An invalid month or no match returns an error message.
| Name | Required | Description | Default |
|---|---|---|---|
| month | No | An English month name ("October", or "oct") or its number, 1 to 12 ("10"). Keeps events with any day in that month. Omit for the whole year. | |
| region | No | Only this part of the world. Use it for asks like "festivals in Europe"; country is more precise when the traveller names one. | |
| country | No | Keep events in this country, by English name, e.g. "Mexico". Omit for every country. |
| Name | Required | Description |
|---|---|---|
| note | No | |
| events | No | Events, soonest first. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover read-only/idempotent/openWorld, so the bar is lower, yet the description adds real substance: sorting by start date, the set of returned fields, the error behavior on an invalid month or no match, and a data-currency caveat that dates are for one edition and the page should be checked before booking.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with scope and routing, and each sentence is doing work, but the long enumeration of return fields is partly redundant given an output schema exists. Dense yet not padded; minor trimming opportunity only.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a three-filter list tool with full schema coverage, annotations and an output schema, everything an agent needs is present: filter behavior, sibling routing, error paths, and the edition-freshness warning. Return values need not be re-explained, so nothing material is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and every parameter description already explains the filter behavior (month name or number, region scoping, country by English name). The description restates filter semantics rather than adding new syntax or format detail, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Specific verb+resource+source: "List the festivals and events ... from the Meridian Dispatch events guide." It distinguishes itself from siblings by naming get_place (full record) and get_best_time (all destinations), so an agent can route correctly without opening a schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit when-to-use and when-not: use get_place with an event URL for the full record, and get_best_time for every kind of destination in a month. Filter semantics (no filter = everything, month = any day in that month, country = one country) are stated outright.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
The signed-in traveller's trip plans in the Meridian Dispatch app: id, title, dates, countries, number of days planned (the app makes days as the traveller fills them, so it can be fewer than the dates span), seq (the plan's version), whether the app has taken in the latest version, and when it last changed. Needs the traveller to sign in to Meridian Dispatch the first time (the client is asked to authorise). Use get_plan for one plan's days and places.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds genuinely new behavioral context: first-time sign-in with a client authorization prompt, and that 'days planned' can be fewer than the date span because the app materializes days lazily. It stops short of saying what happens when the traveller is not signed in or whether the list is ever truncated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
It is front-loaded with the resource and keeps to two sentences with no filler. The middle sentence is a long run-on field enumeration, but each parenthetical (days vs. date span, seq as version) carries real information, so little could be cut without loss.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema and zero parameters, the description does the necessary work of describing the return fields, their versioning semantics, and the auth prerequisite. The remaining gap is failure/empty-state behavior and whether the result set is complete or filtered by recency.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes no parameters, so the baseline is 4. The description instead spends its detail on the response fields (id, seq, ingested status, last change), which is the useful place to add meaning given the absence of an output schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific verb and resource ('the signed-in traveller's trip plans') scoped to the Meridian Dispatch app, then enumerates the returned fields, so the agent knows exactly what the tool yields. It also distinguishes itself from get_plan, which returns a single plan's days and places.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly routes the agent to get_plan when a single plan's days and places are needed, which resolves the main ambiguity among the siblings. It gives no explicit when-not guidance for the other plan-related siblings (create_plan, edit_plan, delete_plan), though those are distinguished by obvious mutation semantics.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List the places Meridian Dispatch covers near a place or a coordinate, nearest first, for day trips from a base or what else to see near a sight. From a town with a researched guide, it leads with day_trips: the guide's own picks, with travel mode and how long. Without type it answers a day-trip question: up to 15 towns, each once at its nearest point, with its distance, summary, guide link, best few places and dispatches; a town's own sights are left out (get_destination has them). With type it returns a flat list of up to 20 places of that kind with distances. Distances are straight-line kilometres, not by road. Give place, or lat and lng together. For the sights inside one town use get_destination; to search by theme use search_guides. Read-only. An unknown place or nothing within the radius returns an error message.
| Name | Required | Description | Default |
|---|---|---|---|
| lat | No | Latitude of the starting point in decimal degrees, e.g. 42.42. Give with lng, instead of place. | |
| lng | No | Longitude of the starting point in decimal degrees, e.g. 18.77. Give with lat, instead of place. | |
| type | No | Return a flat list of only this kind of place, e.g. "trail" or "event". Omit for the day-trip view grouped by town. | |
| place | No | The starting point: a place name or meridiandispatch.com URL, e.g. "Kotor". Use this, or lat and lng. | |
| radius_km | No | How far to look, in straight-line kilometres, 1 to 200. Defaults to 40; use 60 to 100 for a day trip by car. |
| Name | Required | Description |
|---|---|---|
| from | No | The starting place's name, or the coordinate given. |
| note | No | |
| towns | No | Without type: towns, nearest first. |
| places | No | With type: places, nearest first. |
| radius_km | No | |
| same_town | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly/idempotent/non-destructive, and the description adds genuinely new behavior: nearest-first ordering, caps (15 towns / 20 places), deduplication by nearest point, exclusion of a town's own sights, straight-line rather than road distances, and the failure mode ('an unknown place or nothing within the radius returns an error message'). This is exactly the context annotations cannot convey.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with purpose and mode selection, then constraints, then alternatives. Information density is high, though it runs long and repeats the schema's place-vs-lat/lng rule verbatim, which is the only real redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists so return values need not be restated, yet the description still gives enough about the two view shapes, limits, distance type and error behavior that an agent can call this correctly without opening the schema. Nothing material is missing for a read-only lookup tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3, and the description earns above that by explaining the effect of omitting type (group-by-town day-trip view vs. flat list), how to combine place or lat+lng, and the distance semantics that govern radius_km. It does not add format or ordering detail for lat/lng beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Specific verb ('List') plus resource ('the places Meridian Dispatch covers') with explicit scope ('near a place or a coordinate, nearest first') and two operating modes (day-trip view vs. typed flat list). It also distinguishes itself from siblings by name, telling the agent what get_destination and search_guides cover instead.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
States when to use each mode ('Without type it answers a day-trip question... With type it returns a flat list'), how to supply the origin, and routes to alternatives explicitly: 'For the sights inside one town use get_destination; to search by theme use search_guides.' Nothing is left to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search every Meridian Dispatch travel guide by keyword: long-form dispatches, multi-day itineraries, country and town guides, venues (sights, museums, beaches, parks), trails and scenic drives, events and ski resorts. Use it first when you do not know the exact page. Once you know the place, read it in full with get_destination (a country or town), get_place (one sight, trail, event or ski resort) or get_dispatch (a dispatch or itinerary); for ranked top-ten lists use list_best_places, for a month use get_best_time. Returns up to limit pages ranked by relevance, each with its type, title, country, town, a one-line summary, a citable URL and when it was last updated. Ranking is keyword-based with travel synonyms; a country or month named in the query is honoured. Read-only. When nothing matches it returns an error message; retry with a broader query or a place name.
| Name | Required | Description | Default |
|---|---|---|---|
| type | No | Return only one kind of page: dispatch (a reported long-form piece), itinerary (a multi-day country route), country or town (destination guides), venue (one sight), trail (a hike or scenic drive), event (a festival), ski_resort or museum (must-see works with their rooms and floors). Omit to search all kinds. | |
| limit | No | Most results to return, 1 to 20. Defaults to 8. | |
| query | Yes | What the traveller wants, in plain words: a place name ("Kotor"), an activity and a place ("glacier hike Iceland") or a theme ("festivals in Japan"). | |
| region | No | Only this part of the world. Use it for asks like "festivals in Europe"; country is more precise when the traveller names one. | |
| country | No | Return only pages in this country, by English name, e.g. "Iceland". Omit to search worldwide. |
| Name | Required | Description |
|---|---|---|
| results | No | Matching pages, best first. |
| attribution | No | The terms for quoting these pages. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare read-only/idempotent/non-destructive, and the description goes further than they do: ranking is keyword-based with travel synonyms, a country or month named in the query is honoured, results are capped at `limit` and ranked by relevance, and a no-match returns an error. That is real behavioral disclosure beyond the structured metadata.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with the core routing rule and alternative-tool mapping in two dense sentences; the return-shape and error-handling sentences earn their place. Slightly long, and "Read-only" restates the annotations, but overall efficient with no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a five-parameter, multi-sibling search tool with full schema coverage and an output schema, the description covers routing, scope, ranking, result shape and failure recovery. An agent has everything needed to select and invoke it without opening the schemas.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the enum values for `type` and `region` and the bounds on `limit` are already fully documented in the schema. The description only adds the ranking nuance (country or month named in the query is honoured) and the limit/ranking behavior, which is marginal over the schema. Baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a precise verb (search) and resource (travel guides), then enumerates the content types covered (dispatches, itineraries, country/town guides, venues, trails, events, ski resorts). It explicitly differentiates from siblings by naming get_destination, get_place, get_dispatch, list_best_places and get_best_time with the conditions that select each.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives an explicit when-to-use rule ("use it first when you do not know the exact page") and routes the agent to the correct sibling once the place is known, per result type. It also handles the failure path: retry with a broader query or a place name when nothing matches.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Send the Meridian Dispatch desk a correction to one of its pages. Use it when the traveller tells you something on a meridiandispatch.com page is wrong or out of date (a place has closed, moved, been renamed, changed its hours or now needs booking). Pass a source_url when the traveller gives one or one supports what they said. Do not use it for opinions, reviews or style. To read a page first, use get_place, get_destination or get_dispatch. Quote current_text exactly as it appears on the page (or in this server's answer about it); a quote that is not found is refused. Nothing changes immediately: the desk verifies every suggestion against its own sources before editing. Returns whether the suggestion was received and its id; the same suggestion sent twice is recorded once. A page that is not on meridiandispatch.com, a quote not on the page, or too many suggestions in an hour (per conversation, per address or per page) returns an error saying which.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | The meridiandispatch.com page to correct, as returned in source.url or canonical_url. | |
| field | No | What kind of fact is wrong: status (closed, reopened), hours, location, access (booking, tickets, transport), dates (an event), name, description, or other. | |
| reason | Yes | Why it is wrong, e.g. "The traveller says it closed in spring 2026" or "The official site lists new hours". | |
| source_url | No | Optional: a page that supports the correction, ideally the place's own website. It speeds review. | |
| current_text | Yes | The wrong text, quoted exactly from the page or from this server's answer about it. | |
| proposed_text | Yes | What it should say instead, as plain text. Facts only, no prices. |
| Name | Required | Description |
|---|---|---|
| id | No | |
| next | No | What happens to the suggestion now. |
| page | No | |
| received | No | |
| duplicate | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Adds substantial behavior beyond the annotations: nothing changes immediately and the desk verifies against its own sources, exact-quote matching is enforced and refused if not found, duplicate suggestions are recorded once, and specific error conditions are enumerated (off-domain page, unmatched quote, per-conversation/address/page hourly rate limits). The dedup statement sits in mild tension with idempotentHint=false, but since the description also establishes that repeat sends can produce errors, this reads as nuance rather than a direct contradiction of the declared safety profile.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Nine sentences is long, but each earns its place: eligibility, exclusions, alternatives, quote rule, verification model, return value, error semantics. The critical routing information (what it is, when to use, when not to) is front-loaded before the mechanics.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists and the description still summarizes the return (received flag plus id), and it covers the failure modes an agent must anticipate. For a 6-parameter, 4-required mutation with no destructive risk, nothing needed for correct invocation is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3, but the description adds enforcement semantics the schema does not carry: current_text must be quoted 'exactly as it appears on the page (or in this server's answer about it)' and a quote that is not found is refused, plus guidance on when to supply source_url. That meaningfully extends the parameter documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Send the Meridian Dispatch desk a correction to one of its pages') and immediately distinguishes itself from the sibling suggest_place by naming the target organization and the correction workflow. An agent can tell what this does without opening the schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit trigger ('when the traveller tells you something on a meridiandispatch.com page is wrong or out of date') with concrete examples, an explicit exclusion ('Do not use it for opinions, reviews or style'), and named alternatives for reading first ('use get_place, get_destination or get_dispatch'). This is exactly the when/when-not/alternative pattern.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
What to do on one day of the signed-in traveller's plan: places near that day's hotel (or its town, when the hotel cannot be placed), ranked for THIS traveller the way the app's For You list ranks them: their travel preferences, how full the day already is for their pace, what the rest of the trip already holds (no fourth museum in a row), what they have planned on past trips, and how famous and how well travellers rate each place. Each place comes with why (the reason it is on the list for them, in the app's words), must_see, distance_miles from the anchor, its description, and its Meridian Dispatch page when it has one. Places already on the plan are left out. The ranking draws only on the Meridian Dispatch guides, so a thin town gives a short list; notes says what the ranking could not know (it cannot see the traveller's photo journal, so a place they have been can still appear). Pass day as the day number from the plan's first date (1 is the first day), or date. Use get_plan first if you need the plan id or the day. Needs sign-in.
| Name | Required | Description | Default |
|---|---|---|---|
| day | No | Which day, counted from the plan's first date: 1 is the first day. Default 1. | |
| date | No | Or the day's date, YYYY-MM-DD, instead of day. | |
| limit | No | How many places, 10 by default. | |
| plan_id | Yes | The plan id from list_my_plans. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only cover read-only/idempotent safety, and the description goes far beyond them: it discloses the ranking inputs, that already-planned places are excluded, that the pool is limited to Meridian Dispatch guides so thin towns yield short lists, and what the ranking cannot know. That is exactly the behavioural context an agent needs to interpret results.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Purpose is front-loaded, but the body is one long run-on paragraph packing ranking factors, return fields and caveats into dense clauses. Much of it earns its place, yet it would read far better split into short sentences or bullets.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description supplies the return shape (why, must_see, distance_miles, description, Meridian Dispatch page), the exclusion rule, and the notes caveat. Nothing an agent needs to call or interpret this tool is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description restates day-vs-date semantics that the schema already documents and never mentions the limit parameter or its default, so it adds little beyond structured data.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Opens with a specific verb and resource: suggesting places for one day of a signed-in traveller's plan, anchored to that day's hotel. It is clearly distinguishable from siblings like suggest_place or list_nearby because it is day-scoped, plan-scoped and personally ranked.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
"Use get_plan first if you need the plan id or the day" and "Needs sign-in" give concrete prerequisites, and it explains when to pass day vs date. It never explicitly contrasts itself with sibling tools (suggest_place, list_nearby), which keeps it below a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Suggest a town, sight, walk, museum, event, ski resort, food area or hotel that Meridian Dispatch has no page for, so the desk can research and add it to this free, shared travel reference. Use it only when the traveller asks you to, or agrees when you offer, for somewhere the guides do not cover (search_guides or get_destination found nothing) that is real and open. Do not call it on your own for places you recommend or put in a plan. Single restaurants, bars and shops are not listed; a food street, market or bar district is. source_url is required: the place's official website or another current page showing it exists. A place already covered returns its page instead of a suggestion. Nothing is published straight away: the desk researches every suggestion first. The same place suggested twice is recorded once. Returns whether it was received.
| Name | Required | Description | Default |
|---|---|---|---|
| lat | No | Latitude, if known. | |
| lng | No | Longitude, if known. | |
| why | Yes | One or two sentences: what it is and why a traveller would go. Facts only, no prices. | |
| kind | No | What it is. stay is a hotel worth the trip in itself. | |
| name | Yes | The place's proper name, e.g. "Lake Bohinj". | |
| town | No | The nearest town, when the place is not a town itself. | |
| country | Yes | English country name, e.g. "Slovenia". | |
| source_url | Yes | The place's official website, or another current page showing it exists and is open. |
| Name | Required | Description |
|---|---|---|
| id | No | |
| next | No | |
| received | No | |
| duplicate | No | |
| already_covered | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Goes well beyond the annotations: says nothing is published immediately, the desk researches every suggestion, an already-covered place returns its page instead of a suggestion, and duplicate suggestions are recorded once. These are exactly the side-effect details annotations (readOnlyHint=false, destructiveHint=false) cannot convey. Minor tension with idempotentHint=false is explainable by same-place-not-same-args, so not a contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with purpose and the routing condition, then the constraints. It is dense but slightly long, with the duplicate-recording and desk-research points repeated in spirit; still, nearly every sentence carries actionable information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 8 parameters, an output schema, and mutation-style submission semantics, the description covers eligibility, evidence requirements, side effects, and duplicate handling. Nothing an agent needs to decide whether and how to call it is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3; the description adds real meaning by stressing that source_url must be the official site or another current page proving the place exists and is open, and by defining which place types are eligible. It does not deepen 'why', 'kind' or the lat/lng optionality beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource (suggest a place Meridian Dispatch has no page for) and enumerates the kinds of place in scope. It is clearly distinguishable from siblings like search_guides, get_destination and get_place, which it names directly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit when-to-use: only on traveller request or agreement, and only after search_guides or get_destination found nothing. Explicit when-not: not for the agent's own recommendations or plan entries. Also carves out exclusions (single restaurants, bars, shops vs. food streets/markets).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
suggest_for_my_dayedit_plan1 field changedInput schema / properties / ops / items / anyOfPrevious value: -[
- {
- "additionalProperties": false,
- "properties": {
- "op": {
- "const": "set_title"
- },
- "title": {
- "maxLength": 200,
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "op",
- "title"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "op": {
- "const": "set_start_date"
- },
- "startDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- }
- },
- "required": [
- "op",
- "startDate"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "op": {
- "const": "add_day"
- }
- },
- "required": [
- "op",
- "date"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "force": {
- "description": "Required when the day holds stops or a booking starting that day: removes the day and its stops (bookings are kept). Without it such a day is refused, naming what it holds. Ask the traveller first.",
- "type": "boolean"
- },
- "op": {
- "const": "remove_day"
- }
- },
- "required": [
- "op",
- "date"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "op": {
- "const": "set_day"
- },
- "summary": {
- "type": [
- "string",
- "null"
- ]
- },
- "town": {
- "type": [
- "string",
- "null"
- ]
- }
- },
- "required": [
- "op",
- "date"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "op": {
- "const": "add_stop"
- },
- "position": {
- "minimum": 0,
- "type": "integer"
- },
- "stop": {
- "properties": {
- "booked": {
- "description": "For a restaurant, a tour or a ticketed sight: true once the traveller holds the table or ticket, false while it still needs booking (it then shows in the app's Still to book, with BOOK opening ticketsURL). Leave it out for a place that needs nothing.",
- "type": "boolean"
- },
- "category": {
- "maxLength": 60,
- "type": "string"
- },
- "lat": {
- "description": "Latitude of a real place with no meridian_url, to about 100 m: the app draws the travel line between two stops only when both have a location and a time. Give lat and lng together; they are checked against the stop's town.",
- "maximum": 90,
- "minimum": -90,
- "type": "number"
- },
- "lng": {
- "description": "Longitude, with lat.",
- "maximum": 180,
- "minimum": -180,
- "type": "number"
- },
- "meridian_url": {
- "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title, town and location from the guide, so the stop lands on the map.",
- "type": "string"
- },
- "minutes": {
- "maximum": 1440,
- "minimum": 1,
- "type": "integer"
- },
- "note": {
- "description": "A standing advisory about the place itself (closed Mondays, cash only, book weeks ahead): the app's Know before you go, replaced by the guide's own where a page exists. Not for what the traveller does there; that is visitNote.",
- "maxLength": 2000,
- "type": "string"
- },
- "prose": {
- "maxLength": 2000,
- "type": "string"
- },
- "ticketsURL": {
- "description": "https only. The official page to book this stop: a sight's own ticket shop, or for a restaurant its reservation page (its own site, or the booking service it uses: OpenTable, Resy, SevenRooms, TheFork, Tock). Still to book's BOOK opens it; without one the row shows no BOOK. Never a reseller or a search page.",
- "format": "uri",
- "type": "string"
- },
- "time": {
- "description": "HH:mm, 24-hour.",
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "title": {
- "maxLength": 200,
- "type": "string"
- },
- "town": {
- "maxLength": 100,
- "type": "string"
- },
- "type": {
- "description": "freeform for a transfer or a note.",
- "enum": [
- "activity",
- "restaurant",
- "freeform"
- ],
- "type": "string"
- },
- "visitNote": {
- "description": "ONE sentence (the day page shows only the first) on what the traveller does here on this day (\"Camel trek out for sunset on the dunes, then back to camp for dinner\"). Shown under the stop's name. Put the doing here and keep title the place's proper name (\"Erg Chebbi\", not \"Camel trek into Erg Chebbi\").",
- "maxLength": 240,
- "type": "string"
- }
- },
- "type": "object"
- }
- },
- "required": [
- "op",
- "date",
- "stop"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "fields": {
- "description": "null on a field clears it.",
- "properties": {
- "booked": {
- "description": "For a restaurant, a tour or a ticketed sight: true once the traveller holds the table or ticket, false while it still needs booking (it then shows in the app's Still to book, with BOOK opening ticketsURL). Leave it out for a place that needs nothing.",
- "type": "boolean"
- },
- "category": {
- "maxLength": 60,
- "type": "string"
- },
- "lat": {
- "description": "Latitude of a real place with no meridian_url, to about 100 m: the app draws the travel line between two stops only when both have a location and a time. Give lat and lng together; they are checked against the stop's town.",
- "maximum": 90,
- "minimum": -90,
- "type": "number"
- },
- "lng": {
- "description": "Longitude, with lat.",
- "maximum": 180,
- "minimum": -180,
- "type": "number"
- },
- "meridian_url": {
- "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title, town and location from the guide, so the stop lands on the map.",
- "type": "string"
- },
- "minutes": {
- "maximum": 1440,
- "minimum": 1,
- "type": "integer"
- },
- "note": {
- "description": "A standing advisory about the place itself (closed Mondays, cash only, book weeks ahead): the app's Know before you go, replaced by the guide's own where a page exists. Not for what the traveller does there; that is visitNote.",
- "maxLength": 2000,
- "type": "string"
- },
- "prose": {
- "maxLength": 2000,
- "type": "string"
- },
- "ticketsURL": {
- "description": "https only. The official page to book this stop: a sight's own ticket shop, or for a restaurant its reservation page (its own site, or the booking service it uses: OpenTable, Resy, SevenRooms, TheFork, Tock). Still to book's BOOK opens it; without one the row shows no BOOK. Never a reseller or a search page.",
- "format": "uri",
- "type": "string"
- },
- "time": {
- "description": "HH:mm, 24-hour.",
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "title": {
- "maxLength": 200,
- "type": "string"
- },
- "town": {
- "maxLength": 100,
- "type": "string"
- },
- "type": {
- "description": "freeform for a transfer or a note.",
- "enum": [
- "activity",
- "restaurant",
- "freeform"
- ],
- "type": "string"
- },
- "visitNote": {
- "description": "ONE sentence (the day page shows only the first) on what the traveller does here on this day (\"Camel trek out for sunset on the dunes, then back to camp for dinner\"). Shown under the stop's name. Put the doing here and keep title the place's proper name (\"Erg Chebbi\", not \"Camel trek into Erg Chebbi\").",
- "maxLength": 240,
- "type": "string"
- }
- },
- "type": "object"
- },
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "update_stop"
- }
- },
- "required": [
- "op",
- "id",
- "fields"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "move_stop"
- },
- "position": {
- "minimum": 0,
- "type": "integer"
- }
- },
- "required": [
- "op",
- "id",
- "date"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "remove_stop"
- }
- },
- "required": [
- "op",
- "id"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "booking": {
- "properties": {
- "booked": {
- "type": "boolean"
- },
- "city": {
- "maxLength": 100,
- "type": "string"
- },
- "countryCode": {
- "pattern": "^[A-Za-z]{2}$",
- "type": "string"
- },
- "details": {
- "additionalProperties": {
- "type": "string"
- },
- "description": "The booking's particulars, in these keys only (any other is dropped). Fill every one you know: the app draws the booking from them, not from the title. A flight: airline, flightNumber, originCode and destinationCode (IATA), originAirport and destinationAirport (the airports' names), originCity and destinationCity, departureTerminal, arrivalTerminal, cabin, seat; startDate/startTime is the departure and endDate/endTime the arrival, local times. Prefer one booking per leg; a round trip already held as one booking carries returnAirline, returnFlightNumber, returnOriginCode, returnDestinationCode, returnDepartureDate, returnDepartureTime, returnArrivalDate, returnArrivalTime, returnSeat, with outboundArrivalDate/Time for the first leg. A hotel: address, website, roomType, nights (check-in and check-out times go in startTime and endTime). A restaurant: address, website, partySize (its stop's ticketsURL is the reservation page). A tour or activity: company (the operator), address (the meeting point), website. A train: operator, trainNumber, carriage, seat, originStation, destinationStation, originCity, destinationCity. A car rental: company, vehicleClass, pickupLocation, dropoffLocation. Never the name on the booking.",
- "properties": {
- "address": {
- "type": "string"
- },
- "airline": {
- "type": "string"
- },
- "arrivalTerminal": {
- "type": "string"
- },
- "cabin": {
- "type": "string"
- },
- "carriage": {
- "type": "string"
- },
- "company": {
- "type": "string"
- },
- "departureTerminal": {
- "type": "string"
- },
- "destinationAirport": {
- "type": "string"
- },
- "destinationCity": {
- "type": "string"
- },
- "destinationCode": {
- "pattern": "^[A-Z]{3}$",
- "type": "string"
- },
- "destinationStation": {
- "type": "string"
- },
- "dropoffLocation": {
- "type": "string"
- },
- "flightNumber": {
- "description": "e.g. OS36",
- "type": "string"
- },
- "nights": {
- "type": "string"
- },
- "operator": {
- "type": "string"
- },
- "originAirport": {
- "type": "string"
- },
- "originCity": {
- "type": "string"
- },
- "originCode": {
- "pattern": "^[A-Z]{3}$",
- "type": "string"
- },
- "originStation": {
- "type": "string"
- },
- "outboundArrivalDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "outboundArrivalTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "outboundDepartureDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "outboundDepartureTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "partySize": {
- "type": "string"
- },
- "pickupLocation": {
- "type": "string"
- },
- "returnAirline": {
- "type": "string"
- },
- "returnArrivalDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "returnArrivalTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "returnDepartureDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "returnDepartureTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "returnDestinationCode": {
- "pattern": "^[A-Z]{3}$",
- "type": "string"
- },
- "returnFlightNumber": {
- "type": "string"
- },
- "returnOriginCode": {
- "pattern": "^[A-Z]{3}$",
- "type": "string"
- },
- "returnSeat": {
- "type": "string"
- },
- "roomType": {
- "type": "string"
- },
- "seat": {
- "type": "string"
- },
- "trainNumber": {
- "type": "string"
- },
- "vehicleClass": {
- "type": "string"
- },
- "website": {
- "format": "uri",
- "type": "string"
- }
- },
- "type": "object"
- },
- "endDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "endTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "startDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "startTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "subtitle": {
- "maxLength": 200,
- "type": "string"
- },
- "title": {
- "maxLength": 200,
- "type": "string"
- },
- "type": {
- "enum": [
- "hotel",
- "flight",
- "train",
- "carRental",
- "restaurant",
- "activity",
- "other"
- ],
- "type": "string"
- }
- },
- "required": [
- "type",
- "title"
- ],
- "type": "object"
- },
- "op": {
- "const": "add_booking"
- }
- },
- "required": [
- "op",
- "booking"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "fields": {
- "properties": {
- "booked": {
- "type": "boolean"
- },
- "city": {
- "maxLength": 100,
- "type": "string"
- },
- "countryCode": {
- "pattern": "^[A-Za-z]{2}$",
- "type": "string"
- },
- "details": {
- "additionalProperties": {
- "type": "string"
- },
- "description": "The booking's particulars, in these keys only (any other is dropped). Fill every one you know: the app draws the booking from them, not from the title. A flight: airline, flightNumber, originCode and destinationCode (IATA), originAirport and destinationAirport (the airports' names), originCity and destinationCity, departureTerminal, arrivalTerminal, cabin, seat; startDate/startTime is the departure and endDate/endTime the arrival, local times. Prefer one booking per leg; a round trip already held as one booking carries returnAirline, returnFlightNumber, returnOriginCode, returnDestinationCode, returnDepartureDate, returnDepartureTime, returnArrivalDate, returnArrivalTime, returnSeat, with outboundArrivalDate/Time for the first leg. A hotel: address, website, roomType, nights (check-in and check-out times go in startTime and endTime). A restaurant: address, website, partySize (its stop's ticketsURL is the reservation page). A tour or activity: company (the operator), address (the meeting point), website. A train: operator, trainNumber, carriage, seat, originStation, destinationStation, originCity, destinationCity. A car rental: company, vehicleClass, pickupLocation, dropoffLocation. Never the name on the booking.",
- "properties": {
- "address": {
- "type": "string"
- },
- "airline": {
- "type": "string"
- },
- "arrivalTerminal": {
- "type": "string"
- },
- "cabin": {
- "type": "string"
- },
- "carriage": {
- "type": "string"
- },
- "company": {
- "type": "string"
- },
- "departureTerminal": {
- "type": "string"
- },
- "destinationAirport": {
- "type": "string"
- },
- "destinationCity": {
- "type": "string"
- },
- "destinationCode": {
- "pattern": "^[A-Z]{3}$",
- "type": "string"
- },
- "destinationStation": {
- "type": "string"
- },
- "dropoffLocation": {
- "type": "string"
- },
- "flightNumber": {
- "description": "e.g. OS36",
- "type": "string"
- },
- "nights": {
- "type": "string"
- },
- "operator": {
- "type": "string"
- },
- "originAirport": {
- "type": "string"
- },
- "originCity": {
- "type": "string"
- },
- "originCode": {
- "pattern": "^[A-Z]{3}$",
- "type": "string"
- },
- "originStation": {
- "type": "string"
- },
- "outboundArrivalDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "outboundArrivalTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "outboundDepartureDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "outboundDepartureTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "partySize": {
- "type": "string"
- },
- "pickupLocation": {
- "type": "string"
- },
- "returnAirline": {
- "type": "string"
- },
- "returnArrivalDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "returnArrivalTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "returnDepartureDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "returnDepartureTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "returnDestinationCode": {
- "pattern": "^[A-Z]{3}$",
- "type": "string"
- },
- "returnFlightNumber": {
- "type": "string"
- },
- "returnOriginCode": {
- "pattern": "^[A-Z]{3}$",
- "type": "string"
- },
- "returnSeat": {
- "type": "string"
- },
- "roomType": {
- "type": "string"
- },
- "seat": {
- "type": "string"
- },
- "trainNumber": {
- "type": "string"
- },
- "vehicleClass": {
- "type": "string"
- },
- "website": {
- "format": "uri",
- "type": "string"
- }
- },
- "type": "object"
- },
- "endDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "endTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "startDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "startTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "subtitle": {
- "maxLength": 200,
- "type": "string"
- },
- "title": {
- "maxLength": 200,
- "type": "string"
- },
- "type": {
- "enum": [
- "hotel",
- "flight",
- "train",
- "carRental",
- "restaurant",
- "activity",
- "other"
- ],
- "type": "string"
- }
- },
- "type": "object"
- },
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "update_booking"
- }
- },
- "required": [
- "op",
- "id",
- "fields"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "remove_booking"
- }
- },
- "required": [
- "op",
- "id"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "additionalProperties": false,
+ "properties": {
+ "op": {
+ "const": "set_title"
+ },
+ "title": {
+ "maxLength": 200,
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "op",
+ "title"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "op": {
+ "const": "set_start_date"
+ },
+ "startDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ }
+ },
+ "required": [
+ "op",
+ "startDate"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "op": {
+ "const": "add_day"
+ }
+ },
+ "required": [
+ "op",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "force": {
+ "description": "Required when the day holds stops or a booking starting that day: removes the day and its stops (bookings are kept). Without it such a day is refused, naming what it holds. Ask the traveller first.",
+ "type": "boolean"
+ },
+ "op": {
+ "const": "remove_day"
+ }
+ },
+ "required": [
+ "op",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "force": {
+ "description": "Required when the day holds stops: they are removed (its notes move to the day before). Ask the traveller first.",
+ "type": "boolean"
+ },
+ "op": {
+ "const": "close_day"
+ }
+ },
+ "required": [
+ "op",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "op": {
+ "const": "set_day"
+ },
+ "summary": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "town": {
+ "type": [
+ "string",
+ "null"
+ ]
+ }
+ },
+ "required": [
+ "op",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "op": {
+ "const": "add_stop"
+ },
+ "position": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "stop": {
+ "properties": {
+ "booked": {
+ "description": "For a restaurant, a tour or a ticketed sight: true once the traveller holds the table or ticket, false while it still needs booking (it then shows in the app's Still to book, with BOOK opening ticketsURL). Leave it out for a place that needs nothing.",
+ "type": "boolean"
+ },
+ "category": {
+ "maxLength": 60,
+ "type": "string"
+ },
+ "lat": {
+ "description": "Latitude of a real place with no meridian_url, to about 100 m: the app draws the travel line between two stops only when both have a location and a time. Give lat and lng together; they are checked against the stop's town.",
+ "maximum": 90,
+ "minimum": -90,
+ "type": "number"
+ },
+ "lng": {
+ "description": "Longitude, with lat.",
+ "maximum": 180,
+ "minimum": -180,
+ "type": "number"
+ },
+ "meridian_url": {
+ "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title, town and location from the guide, so the stop lands on the map.",
+ "type": "string"
+ },
+ "minutes": {
+ "maximum": 1440,
+ "minimum": 1,
+ "type": "integer"
+ },
+ "note": {
+ "description": "A standing advisory about the place itself (closed Mondays, cash only, book weeks ahead): the app's Know before you go, replaced by the guide's own where a page exists. Not for what the traveller does there; that is visitNote.",
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "prose": {
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "ticketsURL": {
+ "description": "https only. The official page to book this stop: a sight's own ticket shop, or for a restaurant its reservation page (its own site, or the booking service it uses: OpenTable, Resy, SevenRooms, TheFork, Tock). Still to book's BOOK opens it; without one the row shows no BOOK. Never a reseller or a search page.",
+ "format": "uri",
+ "type": "string"
+ },
+ "time": {
+ "description": "HH:mm, 24-hour.",
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "town": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "type": {
+ "description": "freeform for a transfer or a note.",
+ "enum": [
+ "activity",
+ "restaurant",
+ "freeform"
+ ],
+ "type": "string"
+ },
+ "visitNote": {
+ "description": "ONE sentence (the day page shows only the first) on what the traveller does here on this day (\"Camel trek out for sunset on the dunes, then back to camp for dinner\"). Shown under the stop's name. Put the doing here and keep title the place's proper name (\"Erg Chebbi\", not \"Camel trek into Erg Chebbi\").",
+ "maxLength": 240,
+ "type": "string"
+ }
+ },
+ "type": "object"
+ }
+ },
+ "required": [
+ "op",
+ "date",
+ "stop"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "fields": {
+ "description": "null on a field clears it.",
+ "properties": {
+ "booked": {
+ "description": "For a restaurant, a tour or a ticketed sight: true once the traveller holds the table or ticket, false while it still needs booking (it then shows in the app's Still to book, with BOOK opening ticketsURL). Leave it out for a place that needs nothing.",
+ "type": "boolean"
+ },
+ "category": {
+ "maxLength": 60,
+ "type": "string"
+ },
+ "lat": {
+ "description": "Latitude of a real place with no meridian_url, to about 100 m: the app draws the travel line between two stops only when both have a location and a time. Give lat and lng together; they are checked against the stop's town.",
+ "maximum": 90,
+ "minimum": -90,
+ "type": "number"
+ },
+ "lng": {
+ "description": "Longitude, with lat.",
+ "maximum": 180,
+ "minimum": -180,
+ "type": "number"
+ },
+ "meridian_url": {
+ "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title, town and location from the guide, so the stop lands on the map.",
+ "type": "string"
+ },
+ "minutes": {
+ "maximum": 1440,
+ "minimum": 1,
+ "type": "integer"
+ },
+ "note": {
+ "description": "A standing advisory about the place itself (closed Mondays, cash only, book weeks ahead): the app's Know before you go, replaced by the guide's own where a page exists. Not for what the traveller does there; that is visitNote.",
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "prose": {
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "ticketsURL": {
+ "description": "https only. The official page to book this stop: a sight's own ticket shop, or for a restaurant its reservation page (its own site, or the booking service it uses: OpenTable, Resy, SevenRooms, TheFork, Tock). Still to book's BOOK opens it; without one the row shows no BOOK. Never a reseller or a search page.",
+ "format": "uri",
+ "type": "string"
+ },
+ "time": {
+ "description": "HH:mm, 24-hour.",
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "town": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "type": {
+ "description": "freeform for a transfer or a note.",
+ "enum": [
+ "activity",
+ "restaurant",
+ "freeform"
+ ],
+ "type": "string"
+ },
+ "visitNote": {
+ "description": "ONE sentence (the day page shows only the first) on what the traveller does here on this day (\"Camel trek out for sunset on the dunes, then back to camp for dinner\"). Shown under the stop's name. Put the doing here and keep title the place's proper name (\"Erg Chebbi\", not \"Camel trek into Erg Chebbi\").",
+ "maxLength": 240,
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "update_stop"
+ }
+ },
+ "required": [
+ "op",
+ "id",
+ "fields"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "move_stop"
+ },
+ "position": {
+ "minimum": 0,
+ "type": "integer"
+ }
+ },
+ "required": [
+ "op",
+ "id",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "remove_stop"
+ }
+ },
+ "required": [
+ "op",
+ "id"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "booking": {
+ "properties": {
+ "booked": {
+ "type": "boolean"
+ },
+ "city": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "countryCode": {
+ "pattern": "^[A-Za-z]{2}$",
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {
+ "type": "string"
+ },
+ "description": "The booking's particulars, in these keys only (any other is dropped). Fill every one you know: the app draws the booking from them, not from the title. A flight: airline, flightNumber, originCode and destinationCode (IATA), originAirport and destinationAirport (the airports' names), originCity and destinationCity, departureTerminal, arrivalTerminal, cabin, seat; startDate/startTime is the departure and endDate/endTime the arrival, local times. Prefer one booking per leg; a round trip already held as one booking carries returnAirline, returnFlightNumber, returnOriginCode, returnDestinationCode, returnDepartureDate, returnDepartureTime, returnArrivalDate, returnArrivalTime, returnSeat, with outboundArrivalDate/Time for the first leg. A hotel: address, website, roomType, nights (check-in and check-out times go in startTime and endTime). A restaurant: address, website, partySize (its stop's ticketsURL is the reservation page). A tour or activity: company (the operator), address (the meeting point), website. A train: operator, trainNumber, carriage, seat, originStation, destinationStation, originCity, destinationCity. A car rental: company, vehicleClass, pickupLocation, dropoffLocation. Never the name on the booking.",
+ "properties": {
+ "address": {
+ "type": "string"
+ },
+ "airline": {
+ "type": "string"
+ },
+ "arrivalTerminal": {
+ "type": "string"
+ },
+ "cabin": {
+ "type": "string"
+ },
+ "carriage": {
+ "type": "string"
+ },
+ "company": {
+ "type": "string"
+ },
+ "departureTerminal": {
+ "type": "string"
+ },
+ "destinationAirport": {
+ "type": "string"
+ },
+ "destinationCity": {
+ "type": "string"
+ },
+ "destinationCode": {
+ "pattern": "^[A-Z]{3}$",
+ "type": "string"
+ },
+ "destinationStation": {
+ "type": "string"
+ },
+ "dropoffLocation": {
+ "type": "string"
+ },
+ "flightNumber": {
+ "description": "e.g. OS36",
+ "type": "string"
+ },
+ "nights": {
+ "type": "string"
+ },
+ "operator": {
+ "type": "string"
+ },
+ "originAirport": {
+ "type": "string"
+ },
+ "originCity": {
+ "type": "string"
+ },
+ "originCode": {
+ "pattern": "^[A-Z]{3}$",
+ "type": "string"
+ },
+ "originStation": {
+ "type": "string"
+ },
+ "outboundArrivalDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "outboundArrivalTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "outboundDepartureDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "outboundDepartureTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "partySize": {
+ "type": "string"
+ },
+ "pickupLocation": {
+ "type": "string"
+ },
+ "returnAirline": {
+ "type": "string"
+ },
+ "returnArrivalDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "returnArrivalTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "returnDepartureDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "returnDepartureTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "returnDestinationCode": {
+ "pattern": "^[A-Z]{3}$",
+ "type": "string"
+ },
+ "returnFlightNumber": {
+ "type": "string"
+ },
+ "returnOriginCode": {
+ "pattern": "^[A-Z]{3}$",
+ "type": "string"
+ },
+ "returnSeat": {
+ "type": "string"
+ },
+ "roomType": {
+ "type": "string"
+ },
+ "seat": {
+ "type": "string"
+ },
+ "trainNumber": {
+ "type": "string"
+ },
+ "vehicleClass": {
+ "type": "string"
+ },
+ "website": {
+ "format": "uri",
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "endDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "endTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "startDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "startTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "subtitle": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "type": {
+ "enum": [
+ "hotel",
+ "flight",
+ "train",
+ "carRental",
+ "restaurant",
+ "activity",
+ "other"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "type",
+ "title"
+ ],
+ "type": "object"
+ },
+ "op": {
+ "const": "add_booking"
+ }
+ },
+ "required": [
+ "op",
+ "booking"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "fields": {
+ "properties": {
+ "booked": {
+ "type": "boolean"
+ },
+ "city": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "countryCode": {
+ "pattern": "^[A-Za-z]{2}$",
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {
+ "type": "string"
+ },
+ "description": "The booking's particulars, in these keys only (any other is dropped). Fill every one you know: the app draws the booking from them, not from the title. A flight: airline, flightNumber, originCode and destinationCode (IATA), originAirport and destinationAirport (the airports' names), originCity and destinationCity, departureTerminal, arrivalTerminal, cabin, seat; startDate/startTime is the departure and endDate/endTime the arrival, local times. Prefer one booking per leg; a round trip already held as one booking carries returnAirline, returnFlightNumber, returnOriginCode, returnDestinationCode, returnDepartureDate, returnDepartureTime, returnArrivalDate, returnArrivalTime, returnSeat, with outboundArrivalDate/Time for the first leg. A hotel: address, website, roomType, nights (check-in and check-out times go in startTime and endTime). A restaurant: address, website, partySize (its stop's ticketsURL is the reservation page). A tour or activity: company (the operator), address (the meeting point), website. A train: operator, trainNumber, carriage, seat, originStation, destinationStation, originCity, destinationCity. A car rental: company, vehicleClass, pickupLocation, dropoffLocation. Never the name on the booking.",
+ "properties": {
+ "address": {
+ "type": "string"
+ },
+ "airline": {
+ "type": "string"
+ },
+ "arrivalTerminal": {
+ "type": "string"
+ },
+ "cabin": {
+ "type": "string"
+ },
+ "carriage": {
+ "type": "string"
+ },
+ "company": {
+ "type": "string"
+ },
+ "departureTerminal": {
+ "type": "string"
+ },
+ "destinationAirport": {
+ "type": "string"
+ },
+ "destinationCity": {
+ "type": "string"
+ },
+ "destinationCode": {
+ "pattern": "^[A-Z]{3}$",
+ "type": "string"
+ },
+ "destinationStation": {
+ "type": "string"
+ },
+ "dropoffLocation": {
+ "type": "string"
+ },
+ "flightNumber": {
+ "description": "e.g. OS36",
+ "type": "string"
+ },
+ "nights": {
+ "type": "string"
+ },
+ "operator": {
+ "type": "string"
+ },
+ "originAirport": {
+ "type": "string"
+ },
+ "originCity": {
+ "type": "string"
+ },
+ "originCode": {
+ "pattern": "^[A-Z]{3}$",
+ "type": "string"
+ },
+ "originStation": {
+ "type": "string"
+ },
+ "outboundArrivalDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "outboundArrivalTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "outboundDepartureDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "outboundDepartureTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "partySize": {
+ "type": "string"
+ },
+ "pickupLocation": {
+ "type": "string"
+ },
+ "returnAirline": {
+ "type": "string"
+ },
+ "returnArrivalDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "returnArrivalTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "returnDepartureDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "returnDepartureTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "returnDestinationCode": {
+ "pattern": "^[A-Z]{3}$",
+ "type": "string"
+ },
+ "returnFlightNumber": {
+ "type": "string"
+ },
+ "returnOriginCode": {
+ "pattern": "^[A-Z]{3}$",
+ "type": "string"
+ },
+ "returnSeat": {
+ "type": "string"
+ },
+ "roomType": {
+ "type": "string"
+ },
+ "seat": {
+ "type": "string"
+ },
+ "trainNumber": {
+ "type": "string"
+ },
+ "vehicleClass": {
+ "type": "string"
+ },
+ "website": {
+ "format": "uri",
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "endDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "endTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "startDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "startTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "subtitle": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "type": {
+ "enum": [
+ "hotel",
+ "flight",
+ "train",
+ "carRental",
+ "restaurant",
+ "activity",
+ "other"
+ ],
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "update_booking"
+ }
+ },
+ "required": [
+ "op",
+ "id",
+ "fields"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "remove_booking"
+ }
+ },
+ "required": [
+ "op",
+ "id"
+ ],
+ "type": "object"
+ }
+]edit_plan1 field changedInput schema / properties / ops / items / anyOfPrevious value: -[
- {
- "additionalProperties": false,
- "properties": {
- "op": {
- "const": "set_title"
- },
- "title": {
- "maxLength": 200,
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "op",
- "title"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "op": {
- "const": "set_start_date"
- },
- "startDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- }
- },
- "required": [
- "op",
- "startDate"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "op": {
- "const": "add_day"
- }
- },
- "required": [
- "op",
- "date"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "force": {
- "description": "Required when the day holds stops or a booking starting that day: removes the day and its stops (bookings are kept). Without it such a day is refused, naming what it holds. Ask the traveller first.",
- "type": "boolean"
- },
- "op": {
- "const": "remove_day"
- }
- },
- "required": [
- "op",
- "date"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "op": {
- "const": "set_day"
- },
- "summary": {
- "type": [
- "string",
- "null"
- ]
- },
- "town": {
- "type": [
- "string",
- "null"
- ]
- }
- },
- "required": [
- "op",
- "date"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "op": {
- "const": "add_stop"
- },
- "position": {
- "minimum": 0,
- "type": "integer"
- },
- "stop": {
- "properties": {
- "category": {
- "maxLength": 60,
- "type": "string"
- },
- "lat": {
- "description": "Latitude of a real place with no meridian_url, to about 100 m: the app draws the travel line between two stops only when both have a location and a time. Give lat and lng together; they are checked against the stop's town.",
- "maximum": 90,
- "minimum": -90,
- "type": "number"
- },
- "lng": {
- "description": "Longitude, with lat.",
- "maximum": 180,
- "minimum": -180,
- "type": "number"
- },
- "meridian_url": {
- "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title, town and location from the guide, so the stop lands on the map.",
- "type": "string"
- },
- "minutes": {
- "maximum": 1440,
- "minimum": 1,
- "type": "integer"
- },
- "note": {
- "description": "A standing advisory about the place itself (closed Mondays, cash only, book weeks ahead): the app's Know before you go, replaced by the guide's own where a page exists. Not for what the traveller does there; that is visitNote.",
- "maxLength": 2000,
- "type": "string"
- },
- "prose": {
- "maxLength": 2000,
- "type": "string"
- },
- "ticketsURL": {
- "format": "uri",
- "type": "string"
- },
- "time": {
- "description": "HH:mm, 24-hour.",
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "title": {
- "maxLength": 200,
- "type": "string"
- },
- "town": {
- "maxLength": 100,
- "type": "string"
- },
- "type": {
- "description": "freeform for a transfer or a note.",
- "enum": [
- "activity",
- "restaurant",
- "freeform"
- ],
- "type": "string"
- },
- "visitNote": {
- "description": "ONE sentence (the day page shows only the first) on what the traveller does here on this day (\"Camel trek out for sunset on the dunes, then back to camp for dinner\"). Shown under the stop's name. Put the doing here and keep title the place's proper name (\"Erg Chebbi\", not \"Camel trek into Erg Chebbi\").",
- "maxLength": 240,
- "type": "string"
- }
- },
- "type": "object"
- }
- },
- "required": [
- "op",
- "date",
- "stop"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "fields": {
- "description": "null on a field clears it.",
- "properties": {
- "category": {
- "maxLength": 60,
- "type": "string"
- },
- "lat": {
- "description": "Latitude of a real place with no meridian_url, to about 100 m: the app draws the travel line between two stops only when both have a location and a time. Give lat and lng together; they are checked against the stop's town.",
- "maximum": 90,
- "minimum": -90,
- "type": "number"
- },
- "lng": {
- "description": "Longitude, with lat.",
- "maximum": 180,
- "minimum": -180,
- "type": "number"
- },
- "meridian_url": {
- "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title, town and location from the guide, so the stop lands on the map.",
- "type": "string"
- },
- "minutes": {
- "maximum": 1440,
- "minimum": 1,
- "type": "integer"
- },
- "note": {
- "description": "A standing advisory about the place itself (closed Mondays, cash only, book weeks ahead): the app's Know before you go, replaced by the guide's own where a page exists. Not for what the traveller does there; that is visitNote.",
- "maxLength": 2000,
- "type": "string"
- },
- "prose": {
- "maxLength": 2000,
- "type": "string"
- },
- "ticketsURL": {
- "format": "uri",
- "type": "string"
- },
- "time": {
- "description": "HH:mm, 24-hour.",
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "title": {
- "maxLength": 200,
- "type": "string"
- },
- "town": {
- "maxLength": 100,
- "type": "string"
- },
- "type": {
- "description": "freeform for a transfer or a note.",
- "enum": [
- "activity",
- "restaurant",
- "freeform"
- ],
- "type": "string"
- },
- "visitNote": {
- "description": "ONE sentence (the day page shows only the first) on what the traveller does here on this day (\"Camel trek out for sunset on the dunes, then back to camp for dinner\"). Shown under the stop's name. Put the doing here and keep title the place's proper name (\"Erg Chebbi\", not \"Camel trek into Erg Chebbi\").",
- "maxLength": 240,
- "type": "string"
- }
- },
- "type": "object"
- },
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "update_stop"
- }
- },
- "required": [
- "op",
- "id",
- "fields"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "move_stop"
- },
- "position": {
- "minimum": 0,
- "type": "integer"
- }
- },
- "required": [
- "op",
- "id",
- "date"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "remove_stop"
- }
- },
- "required": [
- "op",
- "id"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "booking": {
- "properties": {
- "booked": {
- "type": "boolean"
- },
- "city": {
- "maxLength": 100,
- "type": "string"
- },
- "countryCode": {
- "pattern": "^[A-Za-z]{2}$",
- "type": "string"
- },
- "details": {
- "additionalProperties": {
- "type": "string"
- },
- "type": "object"
- },
- "endDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "endTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "startDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "startTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "subtitle": {
- "maxLength": 200,
- "type": "string"
- },
- "title": {
- "maxLength": 200,
- "type": "string"
- },
- "type": {
- "enum": [
- "hotel",
- "flight",
- "train",
- "carRental",
- "restaurant",
- "activity",
- "other"
- ],
- "type": "string"
- }
- },
- "required": [
- "type",
- "title"
- ],
- "type": "object"
- },
- "op": {
- "const": "add_booking"
- }
- },
- "required": [
- "op",
- "booking"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "fields": {
- "properties": {
- "booked": {
- "type": "boolean"
- },
- "city": {
- "maxLength": 100,
- "type": "string"
- },
- "countryCode": {
- "pattern": "^[A-Za-z]{2}$",
- "type": "string"
- },
- "details": {
- "additionalProperties": {
- "type": "string"
- },
- "type": "object"
- },
- "endDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "endTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "startDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "startTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "subtitle": {
- "maxLength": 200,
- "type": "string"
- },
- "title": {
- "maxLength": 200,
- "type": "string"
- },
- "type": {
- "enum": [
- "hotel",
- "flight",
- "train",
- "carRental",
- "restaurant",
- "activity",
- "other"
- ],
- "type": "string"
- }
- },
- "type": "object"
- },
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "update_booking"
- }
- },
- "required": [
- "op",
- "id",
- "fields"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "remove_booking"
- }
- },
- "required": [
- "op",
- "id"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "additionalProperties": false,
+ "properties": {
+ "op": {
+ "const": "set_title"
+ },
+ "title": {
+ "maxLength": 200,
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "op",
+ "title"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "op": {
+ "const": "set_start_date"
+ },
+ "startDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ }
+ },
+ "required": [
+ "op",
+ "startDate"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "op": {
+ "const": "add_day"
+ }
+ },
+ "required": [
+ "op",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "force": {
+ "description": "Required when the day holds stops or a booking starting that day: removes the day and its stops (bookings are kept). Without it such a day is refused, naming what it holds. Ask the traveller first.",
+ "type": "boolean"
+ },
+ "op": {
+ "const": "remove_day"
+ }
+ },
+ "required": [
+ "op",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "op": {
+ "const": "set_day"
+ },
+ "summary": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "town": {
+ "type": [
+ "string",
+ "null"
+ ]
+ }
+ },
+ "required": [
+ "op",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "op": {
+ "const": "add_stop"
+ },
+ "position": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "stop": {
+ "properties": {
+ "booked": {
+ "description": "For a restaurant, a tour or a ticketed sight: true once the traveller holds the table or ticket, false while it still needs booking (it then shows in the app's Still to book, with BOOK opening ticketsURL). Leave it out for a place that needs nothing.",
+ "type": "boolean"
+ },
+ "category": {
+ "maxLength": 60,
+ "type": "string"
+ },
+ "lat": {
+ "description": "Latitude of a real place with no meridian_url, to about 100 m: the app draws the travel line between two stops only when both have a location and a time. Give lat and lng together; they are checked against the stop's town.",
+ "maximum": 90,
+ "minimum": -90,
+ "type": "number"
+ },
+ "lng": {
+ "description": "Longitude, with lat.",
+ "maximum": 180,
+ "minimum": -180,
+ "type": "number"
+ },
+ "meridian_url": {
+ "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title, town and location from the guide, so the stop lands on the map.",
+ "type": "string"
+ },
+ "minutes": {
+ "maximum": 1440,
+ "minimum": 1,
+ "type": "integer"
+ },
+ "note": {
+ "description": "A standing advisory about the place itself (closed Mondays, cash only, book weeks ahead): the app's Know before you go, replaced by the guide's own where a page exists. Not for what the traveller does there; that is visitNote.",
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "prose": {
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "ticketsURL": {
+ "description": "https only. The official page to book this stop: a sight's own ticket shop, or for a restaurant its reservation page (its own site, or the booking service it uses: OpenTable, Resy, SevenRooms, TheFork, Tock). Still to book's BOOK opens it; without one the row shows no BOOK. Never a reseller or a search page.",
+ "format": "uri",
+ "type": "string"
+ },
+ "time": {
+ "description": "HH:mm, 24-hour.",
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "town": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "type": {
+ "description": "freeform for a transfer or a note.",
+ "enum": [
+ "activity",
+ "restaurant",
+ "freeform"
+ ],
+ "type": "string"
+ },
+ "visitNote": {
+ "description": "ONE sentence (the day page shows only the first) on what the traveller does here on this day (\"Camel trek out for sunset on the dunes, then back to camp for dinner\"). Shown under the stop's name. Put the doing here and keep title the place's proper name (\"Erg Chebbi\", not \"Camel trek into Erg Chebbi\").",
+ "maxLength": 240,
+ "type": "string"
+ }
+ },
+ "type": "object"
+ }
+ },
+ "required": [
+ "op",
+ "date",
+ "stop"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "fields": {
+ "description": "null on a field clears it.",
+ "properties": {
+ "booked": {
+ "description": "For a restaurant, a tour or a ticketed sight: true once the traveller holds the table or ticket, false while it still needs booking (it then shows in the app's Still to book, with BOOK opening ticketsURL). Leave it out for a place that needs nothing.",
+ "type": "boolean"
+ },
+ "category": {
+ "maxLength": 60,
+ "type": "string"
+ },
+ "lat": {
+ "description": "Latitude of a real place with no meridian_url, to about 100 m: the app draws the travel line between two stops only when both have a location and a time. Give lat and lng together; they are checked against the stop's town.",
+ "maximum": 90,
+ "minimum": -90,
+ "type": "number"
+ },
+ "lng": {
+ "description": "Longitude, with lat.",
+ "maximum": 180,
+ "minimum": -180,
+ "type": "number"
+ },
+ "meridian_url": {
+ "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title, town and location from the guide, so the stop lands on the map.",
+ "type": "string"
+ },
+ "minutes": {
+ "maximum": 1440,
+ "minimum": 1,
+ "type": "integer"
+ },
+ "note": {
+ "description": "A standing advisory about the place itself (closed Mondays, cash only, book weeks ahead): the app's Know before you go, replaced by the guide's own where a page exists. Not for what the traveller does there; that is visitNote.",
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "prose": {
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "ticketsURL": {
+ "description": "https only. The official page to book this stop: a sight's own ticket shop, or for a restaurant its reservation page (its own site, or the booking service it uses: OpenTable, Resy, SevenRooms, TheFork, Tock). Still to book's BOOK opens it; without one the row shows no BOOK. Never a reseller or a search page.",
+ "format": "uri",
+ "type": "string"
+ },
+ "time": {
+ "description": "HH:mm, 24-hour.",
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "town": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "type": {
+ "description": "freeform for a transfer or a note.",
+ "enum": [
+ "activity",
+ "restaurant",
+ "freeform"
+ ],
+ "type": "string"
+ },
+ "visitNote": {
+ "description": "ONE sentence (the day page shows only the first) on what the traveller does here on this day (\"Camel trek out for sunset on the dunes, then back to camp for dinner\"). Shown under the stop's name. Put the doing here and keep title the place's proper name (\"Erg Chebbi\", not \"Camel trek into Erg Chebbi\").",
+ "maxLength": 240,
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "update_stop"
+ }
+ },
+ "required": [
+ "op",
+ "id",
+ "fields"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "move_stop"
+ },
+ "position": {
+ "minimum": 0,
+ "type": "integer"
+ }
+ },
+ "required": [
+ "op",
+ "id",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "remove_stop"
+ }
+ },
+ "required": [
+ "op",
+ "id"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "booking": {
+ "properties": {
+ "booked": {
+ "type": "boolean"
+ },
+ "city": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "countryCode": {
+ "pattern": "^[A-Za-z]{2}$",
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {
+ "type": "string"
+ },
+ "description": "The booking's particulars, in these keys only (any other is dropped). Fill every one you know: the app draws the booking from them, not from the title. A flight: airline, flightNumber, originCode and destinationCode (IATA), originAirport and destinationAirport (the airports' names), originCity and destinationCity, departureTerminal, arrivalTerminal, cabin, seat; startDate/startTime is the departure and endDate/endTime the arrival, local times. Prefer one booking per leg; a round trip already held as one booking carries returnAirline, returnFlightNumber, returnOriginCode, returnDestinationCode, returnDepartureDate, returnDepartureTime, returnArrivalDate, returnArrivalTime, returnSeat, with outboundArrivalDate/Time for the first leg. A hotel: address, website, roomType, nights (check-in and check-out times go in startTime and endTime). A restaurant: address, website, partySize (its stop's ticketsURL is the reservation page). A tour or activity: company (the operator), address (the meeting point), website. A train: operator, trainNumber, carriage, seat, originStation, destinationStation, originCity, destinationCity. A car rental: company, vehicleClass, pickupLocation, dropoffLocation. Never the name on the booking.",
+ "properties": {
+ "address": {
+ "type": "string"
+ },
+ "airline": {
+ "type": "string"
+ },
+ "arrivalTerminal": {
+ "type": "string"
+ },
+ "cabin": {
+ "type": "string"
+ },
+ "carriage": {
+ "type": "string"
+ },
+ "company": {
+ "type": "string"
+ },
+ "departureTerminal": {
+ "type": "string"
+ },
+ "destinationAirport": {
+ "type": "string"
+ },
+ "destinationCity": {
+ "type": "string"
+ },
+ "destinationCode": {
+ "pattern": "^[A-Z]{3}$",
+ "type": "string"
+ },
+ "destinationStation": {
+ "type": "string"
+ },
+ "dropoffLocation": {
+ "type": "string"
+ },
+ "flightNumber": {
+ "description": "e.g. OS36",
+ "type": "string"
+ },
+ "nights": {
+ "type": "string"
+ },
+ "operator": {
+ "type": "string"
+ },
+ "originAirport": {
+ "type": "string"
+ },
+ "originCity": {
+ "type": "string"
+ },
+ "originCode": {
+ "pattern": "^[A-Z]{3}$",
+ "type": "string"
+ },
+ "originStation": {
+ "type": "string"
+ },
+ "outboundArrivalDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "outboundArrivalTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "outboundDepartureDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "outboundDepartureTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "partySize": {
+ "type": "string"
+ },
+ "pickupLocation": {
+ "type": "string"
+ },
+ "returnAirline": {
+ "type": "string"
+ },
+ "returnArrivalDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "returnArrivalTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "returnDepartureDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "returnDepartureTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "returnDestinationCode": {
+ "pattern": "^[A-Z]{3}$",
+ "type": "string"
+ },
+ "returnFlightNumber": {
+ "type": "string"
+ },
+ "returnOriginCode": {
+ "pattern": "^[A-Z]{3}$",
+ "type": "string"
+ },
+ "returnSeat": {
+ "type": "string"
+ },
+ "roomType": {
+ "type": "string"
+ },
+ "seat": {
+ "type": "string"
+ },
+ "trainNumber": {
+ "type": "string"
+ },
+ "vehicleClass": {
+ "type": "string"
+ },
+ "website": {
+ "format": "uri",
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "endDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "endTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "startDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "startTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "subtitle": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "type": {
+ "enum": [
+ "hotel",
+ "flight",
+ "train",
+ "carRental",
+ "restaurant",
+ "activity",
+ "other"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "type",
+ "title"
+ ],
+ "type": "object"
+ },
+ "op": {
+ "const": "add_booking"
+ }
+ },
+ "required": [
+ "op",
+ "booking"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "fields": {
+ "properties": {
+ "booked": {
+ "type": "boolean"
+ },
+ "city": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "countryCode": {
+ "pattern": "^[A-Za-z]{2}$",
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {
+ "type": "string"
+ },
+ "description": "The booking's particulars, in these keys only (any other is dropped). Fill every one you know: the app draws the booking from them, not from the title. A flight: airline, flightNumber, originCode and destinationCode (IATA), originAirport and destinationAirport (the airports' names), originCity and destinationCity, departureTerminal, arrivalTerminal, cabin, seat; startDate/startTime is the departure and endDate/endTime the arrival, local times. Prefer one booking per leg; a round trip already held as one booking carries returnAirline, returnFlightNumber, returnOriginCode, returnDestinationCode, returnDepartureDate, returnDepartureTime, returnArrivalDate, returnArrivalTime, returnSeat, with outboundArrivalDate/Time for the first leg. A hotel: address, website, roomType, nights (check-in and check-out times go in startTime and endTime). A restaurant: address, website, partySize (its stop's ticketsURL is the reservation page). A tour or activity: company (the operator), address (the meeting point), website. A train: operator, trainNumber, carriage, seat, originStation, destinationStation, originCity, destinationCity. A car rental: company, vehicleClass, pickupLocation, dropoffLocation. Never the name on the booking.",
+ "properties": {
+ "address": {
+ "type": "string"
+ },
+ "airline": {
+ "type": "string"
+ },
+ "arrivalTerminal": {
+ "type": "string"
+ },
+ "cabin": {
+ "type": "string"
+ },
+ "carriage": {
+ "type": "string"
+ },
+ "company": {
+ "type": "string"
+ },
+ "departureTerminal": {
+ "type": "string"
+ },
+ "destinationAirport": {
+ "type": "string"
+ },
+ "destinationCity": {
+ "type": "string"
+ },
+ "destinationCode": {
+ "pattern": "^[A-Z]{3}$",
+ "type": "string"
+ },
+ "destinationStation": {
+ "type": "string"
+ },
+ "dropoffLocation": {
+ "type": "string"
+ },
+ "flightNumber": {
+ "description": "e.g. OS36",
+ "type": "string"
+ },
+ "nights": {
+ "type": "string"
+ },
+ "operator": {
+ "type": "string"
+ },
+ "originAirport": {
+ "type": "string"
+ },
+ "originCity": {
+ "type": "string"
+ },
+ "originCode": {
+ "pattern": "^[A-Z]{3}$",
+ "type": "string"
+ },
+ "originStation": {
+ "type": "string"
+ },
+ "outboundArrivalDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "outboundArrivalTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "outboundDepartureDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "outboundDepartureTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "partySize": {
+ "type": "string"
+ },
+ "pickupLocation": {
+ "type": "string"
+ },
+ "returnAirline": {
+ "type": "string"
+ },
+ "returnArrivalDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "returnArrivalTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "returnDepartureDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "returnDepartureTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "returnDestinationCode": {
+ "pattern": "^[A-Z]{3}$",
+ "type": "string"
+ },
+ "returnFlightNumber": {
+ "type": "string"
+ },
+ "returnOriginCode": {
+ "pattern": "^[A-Z]{3}$",
+ "type": "string"
+ },
+ "returnSeat": {
+ "type": "string"
+ },
+ "roomType": {
+ "type": "string"
+ },
+ "seat": {
+ "type": "string"
+ },
+ "trainNumber": {
+ "type": "string"
+ },
+ "vehicleClass": {
+ "type": "string"
+ },
+ "website": {
+ "format": "uri",
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "endDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "endTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "startDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "startTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "subtitle": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "type": {
+ "enum": [
+ "hotel",
+ "flight",
+ "train",
+ "carRental",
+ "restaurant",
+ "activity",
+ "other"
+ ],
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "update_booking"
+ }
+ },
+ "required": [
+ "op",
+ "id",
+ "fields"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "remove_booking"
+ }
+ },
+ "required": [
+ "op",
+ "id"
+ ],
+ "type": "object"
+ }
+]create_itinerary_link2 fields changedInput schema / properties / airportAdded value: +{
+ "description": "IATA code of the airport to fly into, e.g. \"GDN\". The app books the flight in to it on day 1 instead of guessing (a country's busiest airport is often the wrong one: Warsaw for Gdańsk).",
+ "pattern": "^[A-Za-z]{3}$",
+ "type": "string"
+}Input schema / properties / airport_homeAdded value: +{
+ "description": "IATA code of the airport to fly home from, when it differs from airport.",
+ "pattern": "^[A-Za-z]{3}$",
+ "type": "string"
+}create_itinerary_link1 field changedInput schema / properties / days / items / properties / items / items / properties / imageAdded value: +{
+ "description": "A photograph of this stop from a Meridian Dispatch page (https://www.meridiandispatch.com/images/...), for a stop with no photo of its own: an event page's picture of the street fair, say. Any other host is refused.",
+ "type": "string"
+}get_place1 field changedOutput schema / properties / traveller_reviewsAdded value: +{
+ "description": "Reviews by travellers who went, when there are any: verdict (Worth it to Skip it), rating out of 5, count, and up to five reviews, each {verdict, text, by, visited, countries_visited, published}. Opinions, not the guide.",
+ "type": "object"
+}create_itinerary_link2 fields changedInput schema / properties / fixed_datesAdded value: +{
+ "description": "true when the trip only works on its dates, e.g. it is built around an event. Needs a date on every day (not day numbers). The app imports it on those dates and the traveller cannot move them. Leave out for a trip that works any time.",
+ "type": "boolean"
+}Output schema / properties / fixed_datesAdded value: +{}edit_plan1 field changedInput schema / properties / ops / items / anyOfPrevious value: -[
- {
- "additionalProperties": false,
- "properties": {
- "op": {
- "const": "set_title"
- },
- "title": {
- "maxLength": 200,
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "op",
- "title"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "op": {
- "const": "set_start_date"
- },
- "startDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- }
- },
- "required": [
- "op",
- "startDate"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "op": {
- "const": "add_day"
- }
- },
- "required": [
- "op",
- "date"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "force": {
- "description": "Required when the day holds stops or a booking starting that day: removes the day and its stops (bookings are kept). Without it such a day is refused, naming what it holds. Ask the traveller first.",
- "type": "boolean"
- },
- "op": {
- "const": "remove_day"
- }
- },
- "required": [
- "op",
- "date"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "op": {
- "const": "set_day"
- },
- "summary": {
- "type": [
- "string",
- "null"
- ]
- },
- "town": {
- "type": [
- "string",
- "null"
- ]
- }
- },
- "required": [
- "op",
- "date"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "op": {
- "const": "add_stop"
- },
- "position": {
- "minimum": 0,
- "type": "integer"
- },
- "stop": {
- "properties": {
- "category": {
- "maxLength": 60,
- "type": "string"
- },
- "lat": {
- "description": "Latitude of a real place with no meridian_url, to about 100 m: the app draws the travel line between two stops only when both have a location and a time. Give lat and lng together; they are checked against the stop's town.",
- "maximum": 90,
- "minimum": -90,
- "type": "number"
- },
- "lng": {
- "description": "Longitude, with lat.",
- "maximum": 180,
- "minimum": -180,
- "type": "number"
- },
- "meridian_url": {
- "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title, town and location from the guide, so the stop lands on the map.",
- "type": "string"
- },
- "minutes": {
- "maximum": 1440,
- "minimum": 1,
- "type": "integer"
- },
- "note": {
- "description": "A standing advisory about the place itself (closed Mondays, cash only, book weeks ahead): the app's Know before you go, replaced by the guide's own where a page exists. Not for what the traveller does there; that is visitNote.",
- "maxLength": 2000,
- "type": "string"
- },
- "prose": {
- "maxLength": 2000,
- "type": "string"
- },
- "ticketsURL": {
- "format": "uri",
- "type": "string"
- },
- "time": {
- "description": "HH:mm, 24-hour.",
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "title": {
- "maxLength": 200,
- "type": "string"
- },
- "town": {
- "maxLength": 100,
- "type": "string"
- },
- "type": {
- "description": "freeform for a transfer or a note.",
- "enum": [
- "activity",
- "restaurant",
- "freeform"
- ],
- "type": "string"
- },
- "visitNote": {
- "description": "One sentence on what the traveller does here on this day (\"Camel trek out for sunset on the dunes, then back to camp for dinner\"). Shown under the stop's name. Put the doing here and keep title the place's proper name (\"Erg Chebbi\", not \"Camel trek into Erg Chebbi\").",
- "maxLength": 500,
- "type": "string"
- }
- },
- "type": "object"
- }
- },
- "required": [
- "op",
- "date",
- "stop"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "fields": {
- "description": "null on a field clears it.",
- "properties": {
- "category": {
- "maxLength": 60,
- "type": "string"
- },
- "lat": {
- "description": "Latitude of a real place with no meridian_url, to about 100 m: the app draws the travel line between two stops only when both have a location and a time. Give lat and lng together; they are checked against the stop's town.",
- "maximum": 90,
- "minimum": -90,
- "type": "number"
- },
- "lng": {
- "description": "Longitude, with lat.",
- "maximum": 180,
- "minimum": -180,
- "type": "number"
- },
- "meridian_url": {
- "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title, town and location from the guide, so the stop lands on the map.",
- "type": "string"
- },
- "minutes": {
- "maximum": 1440,
- "minimum": 1,
- "type": "integer"
- },
- "note": {
- "description": "A standing advisory about the place itself (closed Mondays, cash only, book weeks ahead): the app's Know before you go, replaced by the guide's own where a page exists. Not for what the traveller does there; that is visitNote.",
- "maxLength": 2000,
- "type": "string"
- },
- "prose": {
- "maxLength": 2000,
- "type": "string"
- },
- "ticketsURL": {
- "format": "uri",
- "type": "string"
- },
- "time": {
- "description": "HH:mm, 24-hour.",
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "title": {
- "maxLength": 200,
- "type": "string"
- },
- "town": {
- "maxLength": 100,
- "type": "string"
- },
- "type": {
- "description": "freeform for a transfer or a note.",
- "enum": [
- "activity",
- "restaurant",
- "freeform"
- ],
- "type": "string"
- },
- "visitNote": {
- "description": "One sentence on what the traveller does here on this day (\"Camel trek out for sunset on the dunes, then back to camp for dinner\"). Shown under the stop's name. Put the doing here and keep title the place's proper name (\"Erg Chebbi\", not \"Camel trek into Erg Chebbi\").",
- "maxLength": 500,
- "type": "string"
- }
- },
- "type": "object"
- },
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "update_stop"
- }
- },
- "required": [
- "op",
- "id",
- "fields"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "move_stop"
- },
- "position": {
- "minimum": 0,
- "type": "integer"
- }
- },
- "required": [
- "op",
- "id",
- "date"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "remove_stop"
- }
- },
- "required": [
- "op",
- "id"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "booking": {
- "properties": {
- "booked": {
- "type": "boolean"
- },
- "city": {
- "maxLength": 100,
- "type": "string"
- },
- "countryCode": {
- "pattern": "^[A-Za-z]{2}$",
- "type": "string"
- },
- "details": {
- "additionalProperties": {
- "type": "string"
- },
- "type": "object"
- },
- "endDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "endTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "startDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "startTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "subtitle": {
- "maxLength": 200,
- "type": "string"
- },
- "title": {
- "maxLength": 200,
- "type": "string"
- },
- "type": {
- "enum": [
- "hotel",
- "flight",
- "train",
- "carRental",
- "restaurant",
- "activity",
- "other"
- ],
- "type": "string"
- }
- },
- "required": [
- "type",
- "title"
- ],
- "type": "object"
- },
- "op": {
- "const": "add_booking"
- }
- },
- "required": [
- "op",
- "booking"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "fields": {
- "properties": {
- "booked": {
- "type": "boolean"
- },
- "city": {
- "maxLength": 100,
- "type": "string"
- },
- "countryCode": {
- "pattern": "^[A-Za-z]{2}$",
- "type": "string"
- },
- "details": {
- "additionalProperties": {
- "type": "string"
- },
- "type": "object"
- },
- "endDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "endTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "startDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "startTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "subtitle": {
- "maxLength": 200,
- "type": "string"
- },
- "title": {
- "maxLength": 200,
- "type": "string"
- },
- "type": {
- "enum": [
- "hotel",
- "flight",
- "train",
- "carRental",
- "restaurant",
- "activity",
- "other"
- ],
- "type": "string"
- }
- },
- "type": "object"
- },
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "update_booking"
- }
- },
- "required": [
- "op",
- "id",
- "fields"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "remove_booking"
- }
- },
- "required": [
- "op",
- "id"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "additionalProperties": false,
+ "properties": {
+ "op": {
+ "const": "set_title"
+ },
+ "title": {
+ "maxLength": 200,
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "op",
+ "title"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "op": {
+ "const": "set_start_date"
+ },
+ "startDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ }
+ },
+ "required": [
+ "op",
+ "startDate"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "op": {
+ "const": "add_day"
+ }
+ },
+ "required": [
+ "op",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "force": {
+ "description": "Required when the day holds stops or a booking starting that day: removes the day and its stops (bookings are kept). Without it such a day is refused, naming what it holds. Ask the traveller first.",
+ "type": "boolean"
+ },
+ "op": {
+ "const": "remove_day"
+ }
+ },
+ "required": [
+ "op",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "op": {
+ "const": "set_day"
+ },
+ "summary": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "town": {
+ "type": [
+ "string",
+ "null"
+ ]
+ }
+ },
+ "required": [
+ "op",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "op": {
+ "const": "add_stop"
+ },
+ "position": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "stop": {
+ "properties": {
+ "category": {
+ "maxLength": 60,
+ "type": "string"
+ },
+ "lat": {
+ "description": "Latitude of a real place with no meridian_url, to about 100 m: the app draws the travel line between two stops only when both have a location and a time. Give lat and lng together; they are checked against the stop's town.",
+ "maximum": 90,
+ "minimum": -90,
+ "type": "number"
+ },
+ "lng": {
+ "description": "Longitude, with lat.",
+ "maximum": 180,
+ "minimum": -180,
+ "type": "number"
+ },
+ "meridian_url": {
+ "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title, town and location from the guide, so the stop lands on the map.",
+ "type": "string"
+ },
+ "minutes": {
+ "maximum": 1440,
+ "minimum": 1,
+ "type": "integer"
+ },
+ "note": {
+ "description": "A standing advisory about the place itself (closed Mondays, cash only, book weeks ahead): the app's Know before you go, replaced by the guide's own where a page exists. Not for what the traveller does there; that is visitNote.",
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "prose": {
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "ticketsURL": {
+ "format": "uri",
+ "type": "string"
+ },
+ "time": {
+ "description": "HH:mm, 24-hour.",
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "town": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "type": {
+ "description": "freeform for a transfer or a note.",
+ "enum": [
+ "activity",
+ "restaurant",
+ "freeform"
+ ],
+ "type": "string"
+ },
+ "visitNote": {
+ "description": "ONE sentence (the day page shows only the first) on what the traveller does here on this day (\"Camel trek out for sunset on the dunes, then back to camp for dinner\"). Shown under the stop's name. Put the doing here and keep title the place's proper name (\"Erg Chebbi\", not \"Camel trek into Erg Chebbi\").",
+ "maxLength": 240,
+ "type": "string"
+ }
+ },
+ "type": "object"
+ }
+ },
+ "required": [
+ "op",
+ "date",
+ "stop"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "fields": {
+ "description": "null on a field clears it.",
+ "properties": {
+ "category": {
+ "maxLength": 60,
+ "type": "string"
+ },
+ "lat": {
+ "description": "Latitude of a real place with no meridian_url, to about 100 m: the app draws the travel line between two stops only when both have a location and a time. Give lat and lng together; they are checked against the stop's town.",
+ "maximum": 90,
+ "minimum": -90,
+ "type": "number"
+ },
+ "lng": {
+ "description": "Longitude, with lat.",
+ "maximum": 180,
+ "minimum": -180,
+ "type": "number"
+ },
+ "meridian_url": {
+ "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title, town and location from the guide, so the stop lands on the map.",
+ "type": "string"
+ },
+ "minutes": {
+ "maximum": 1440,
+ "minimum": 1,
+ "type": "integer"
+ },
+ "note": {
+ "description": "A standing advisory about the place itself (closed Mondays, cash only, book weeks ahead): the app's Know before you go, replaced by the guide's own where a page exists. Not for what the traveller does there; that is visitNote.",
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "prose": {
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "ticketsURL": {
+ "format": "uri",
+ "type": "string"
+ },
+ "time": {
+ "description": "HH:mm, 24-hour.",
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "town": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "type": {
+ "description": "freeform for a transfer or a note.",
+ "enum": [
+ "activity",
+ "restaurant",
+ "freeform"
+ ],
+ "type": "string"
+ },
+ "visitNote": {
+ "description": "ONE sentence (the day page shows only the first) on what the traveller does here on this day (\"Camel trek out for sunset on the dunes, then back to camp for dinner\"). Shown under the stop's name. Put the doing here and keep title the place's proper name (\"Erg Chebbi\", not \"Camel trek into Erg Chebbi\").",
+ "maxLength": 240,
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "update_stop"
+ }
+ },
+ "required": [
+ "op",
+ "id",
+ "fields"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "move_stop"
+ },
+ "position": {
+ "minimum": 0,
+ "type": "integer"
+ }
+ },
+ "required": [
+ "op",
+ "id",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "remove_stop"
+ }
+ },
+ "required": [
+ "op",
+ "id"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "booking": {
+ "properties": {
+ "booked": {
+ "type": "boolean"
+ },
+ "city": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "countryCode": {
+ "pattern": "^[A-Za-z]{2}$",
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {
+ "type": "string"
+ },
+ "type": "object"
+ },
+ "endDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "endTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "startDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "startTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "subtitle": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "type": {
+ "enum": [
+ "hotel",
+ "flight",
+ "train",
+ "carRental",
+ "restaurant",
+ "activity",
+ "other"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "type",
+ "title"
+ ],
+ "type": "object"
+ },
+ "op": {
+ "const": "add_booking"
+ }
+ },
+ "required": [
+ "op",
+ "booking"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "fields": {
+ "properties": {
+ "booked": {
+ "type": "boolean"
+ },
+ "city": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "countryCode": {
+ "pattern": "^[A-Za-z]{2}$",
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {
+ "type": "string"
+ },
+ "type": "object"
+ },
+ "endDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "endTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "startDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "startTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "subtitle": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "type": {
+ "enum": [
+ "hotel",
+ "flight",
+ "train",
+ "carRental",
+ "restaurant",
+ "activity",
+ "other"
+ ],
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "update_booking"
+ }
+ },
+ "required": [
+ "op",
+ "id",
+ "fields"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "remove_booking"
+ }
+ },
+ "required": [
+ "op",
+ "id"
+ ],
+ "type": "object"
+ }
+]edit_plan1 field changedInput schema / properties / ops / items / anyOfPrevious value: -[
- {
- "additionalProperties": false,
- "properties": {
- "op": {
- "const": "set_title"
- },
- "title": {
- "maxLength": 200,
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "op",
- "title"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "op": {
- "const": "set_start_date"
- },
- "startDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- }
- },
- "required": [
- "op",
- "startDate"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "op": {
- "const": "add_day"
- }
- },
- "required": [
- "op",
- "date"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "force": {
- "description": "Required when the day holds stops or a booking starting that day: removes the day and its stops (bookings are kept). Without it such a day is refused, naming what it holds. Ask the traveller first.",
- "type": "boolean"
- },
- "op": {
- "const": "remove_day"
- }
- },
- "required": [
- "op",
- "date"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "op": {
- "const": "set_day"
- },
- "summary": {
- "type": [
- "string",
- "null"
- ]
- },
- "town": {
- "type": [
- "string",
- "null"
- ]
- }
- },
- "required": [
- "op",
- "date"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "op": {
- "const": "add_stop"
- },
- "position": {
- "minimum": 0,
- "type": "integer"
- },
- "stop": {
- "properties": {
- "category": {
- "maxLength": 60,
- "type": "string"
- },
- "lat": {
- "description": "Latitude of a real place with no meridian_url, to about 100 m: the app draws the travel line between two stops only when both have a location and a time. Give lat and lng together; they are checked against the stop's town.",
- "maximum": 90,
- "minimum": -90,
- "type": "number"
- },
- "lng": {
- "description": "Longitude, with lat.",
- "maximum": 180,
- "minimum": -180,
- "type": "number"
- },
- "meridian_url": {
- "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title, town and location from the guide, so the stop lands on the map.",
- "type": "string"
- },
- "minutes": {
- "maximum": 1440,
- "minimum": 1,
- "type": "integer"
- },
- "note": {
- "maxLength": 2000,
- "type": "string"
- },
- "prose": {
- "maxLength": 2000,
- "type": "string"
- },
- "ticketsURL": {
- "format": "uri",
- "type": "string"
- },
- "time": {
- "description": "HH:mm, 24-hour.",
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "title": {
- "maxLength": 200,
- "type": "string"
- },
- "town": {
- "maxLength": 100,
- "type": "string"
- },
- "type": {
- "description": "freeform for a transfer or a note.",
- "enum": [
- "activity",
- "restaurant",
- "freeform"
- ],
- "type": "string"
- }
- },
- "type": "object"
- }
- },
- "required": [
- "op",
- "date",
- "stop"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "fields": {
- "description": "null on a field clears it.",
- "properties": {
- "category": {
- "maxLength": 60,
- "type": "string"
- },
- "lat": {
- "description": "Latitude of a real place with no meridian_url, to about 100 m: the app draws the travel line between two stops only when both have a location and a time. Give lat and lng together; they are checked against the stop's town.",
- "maximum": 90,
- "minimum": -90,
- "type": "number"
- },
- "lng": {
- "description": "Longitude, with lat.",
- "maximum": 180,
- "minimum": -180,
- "type": "number"
- },
- "meridian_url": {
- "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title, town and location from the guide, so the stop lands on the map.",
- "type": "string"
- },
- "minutes": {
- "maximum": 1440,
- "minimum": 1,
- "type": "integer"
- },
- "note": {
- "maxLength": 2000,
- "type": "string"
- },
- "prose": {
- "maxLength": 2000,
- "type": "string"
- },
- "ticketsURL": {
- "format": "uri",
- "type": "string"
- },
- "time": {
- "description": "HH:mm, 24-hour.",
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "title": {
- "maxLength": 200,
- "type": "string"
- },
- "town": {
- "maxLength": 100,
- "type": "string"
- },
- "type": {
- "description": "freeform for a transfer or a note.",
- "enum": [
- "activity",
- "restaurant",
- "freeform"
- ],
- "type": "string"
- }
- },
- "type": "object"
- },
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "update_stop"
- }
- },
- "required": [
- "op",
- "id",
- "fields"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "move_stop"
- },
- "position": {
- "minimum": 0,
- "type": "integer"
- }
- },
- "required": [
- "op",
- "id",
- "date"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "remove_stop"
- }
- },
- "required": [
- "op",
- "id"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "booking": {
- "properties": {
- "booked": {
- "type": "boolean"
- },
- "city": {
- "maxLength": 100,
- "type": "string"
- },
- "countryCode": {
- "pattern": "^[A-Za-z]{2}$",
- "type": "string"
- },
- "details": {
- "additionalProperties": {
- "type": "string"
- },
- "type": "object"
- },
- "endDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "endTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "startDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "startTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "subtitle": {
- "maxLength": 200,
- "type": "string"
- },
- "title": {
- "maxLength": 200,
- "type": "string"
- },
- "type": {
- "enum": [
- "hotel",
- "flight",
- "train",
- "carRental",
- "restaurant",
- "activity",
- "other"
- ],
- "type": "string"
- }
- },
- "required": [
- "type",
- "title"
- ],
- "type": "object"
- },
- "op": {
- "const": "add_booking"
- }
- },
- "required": [
- "op",
- "booking"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "fields": {
- "properties": {
- "booked": {
- "type": "boolean"
- },
- "city": {
- "maxLength": 100,
- "type": "string"
- },
- "countryCode": {
- "pattern": "^[A-Za-z]{2}$",
- "type": "string"
- },
- "details": {
- "additionalProperties": {
- "type": "string"
- },
- "type": "object"
- },
- "endDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "endTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "startDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "startTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "subtitle": {
- "maxLength": 200,
- "type": "string"
- },
- "title": {
- "maxLength": 200,
- "type": "string"
- },
- "type": {
- "enum": [
- "hotel",
- "flight",
- "train",
- "carRental",
- "restaurant",
- "activity",
- "other"
- ],
- "type": "string"
- }
- },
- "type": "object"
- },
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "update_booking"
- }
- },
- "required": [
- "op",
- "id",
- "fields"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "remove_booking"
- }
- },
- "required": [
- "op",
- "id"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "additionalProperties": false,
+ "properties": {
+ "op": {
+ "const": "set_title"
+ },
+ "title": {
+ "maxLength": 200,
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "op",
+ "title"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "op": {
+ "const": "set_start_date"
+ },
+ "startDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ }
+ },
+ "required": [
+ "op",
+ "startDate"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "op": {
+ "const": "add_day"
+ }
+ },
+ "required": [
+ "op",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "force": {
+ "description": "Required when the day holds stops or a booking starting that day: removes the day and its stops (bookings are kept). Without it such a day is refused, naming what it holds. Ask the traveller first.",
+ "type": "boolean"
+ },
+ "op": {
+ "const": "remove_day"
+ }
+ },
+ "required": [
+ "op",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "op": {
+ "const": "set_day"
+ },
+ "summary": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "town": {
+ "type": [
+ "string",
+ "null"
+ ]
+ }
+ },
+ "required": [
+ "op",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "op": {
+ "const": "add_stop"
+ },
+ "position": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "stop": {
+ "properties": {
+ "category": {
+ "maxLength": 60,
+ "type": "string"
+ },
+ "lat": {
+ "description": "Latitude of a real place with no meridian_url, to about 100 m: the app draws the travel line between two stops only when both have a location and a time. Give lat and lng together; they are checked against the stop's town.",
+ "maximum": 90,
+ "minimum": -90,
+ "type": "number"
+ },
+ "lng": {
+ "description": "Longitude, with lat.",
+ "maximum": 180,
+ "minimum": -180,
+ "type": "number"
+ },
+ "meridian_url": {
+ "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title, town and location from the guide, so the stop lands on the map.",
+ "type": "string"
+ },
+ "minutes": {
+ "maximum": 1440,
+ "minimum": 1,
+ "type": "integer"
+ },
+ "note": {
+ "description": "A standing advisory about the place itself (closed Mondays, cash only, book weeks ahead): the app's Know before you go, replaced by the guide's own where a page exists. Not for what the traveller does there; that is visitNote.",
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "prose": {
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "ticketsURL": {
+ "format": "uri",
+ "type": "string"
+ },
+ "time": {
+ "description": "HH:mm, 24-hour.",
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "town": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "type": {
+ "description": "freeform for a transfer or a note.",
+ "enum": [
+ "activity",
+ "restaurant",
+ "freeform"
+ ],
+ "type": "string"
+ },
+ "visitNote": {
+ "description": "One sentence on what the traveller does here on this day (\"Camel trek out for sunset on the dunes, then back to camp for dinner\"). Shown under the stop's name. Put the doing here and keep title the place's proper name (\"Erg Chebbi\", not \"Camel trek into Erg Chebbi\").",
+ "maxLength": 500,
+ "type": "string"
+ }
+ },
+ "type": "object"
+ }
+ },
+ "required": [
+ "op",
+ "date",
+ "stop"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "fields": {
+ "description": "null on a field clears it.",
+ "properties": {
+ "category": {
+ "maxLength": 60,
+ "type": "string"
+ },
+ "lat": {
+ "description": "Latitude of a real place with no meridian_url, to about 100 m: the app draws the travel line between two stops only when both have a location and a time. Give lat and lng together; they are checked against the stop's town.",
+ "maximum": 90,
+ "minimum": -90,
+ "type": "number"
+ },
+ "lng": {
+ "description": "Longitude, with lat.",
+ "maximum": 180,
+ "minimum": -180,
+ "type": "number"
+ },
+ "meridian_url": {
+ "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title, town and location from the guide, so the stop lands on the map.",
+ "type": "string"
+ },
+ "minutes": {
+ "maximum": 1440,
+ "minimum": 1,
+ "type": "integer"
+ },
+ "note": {
+ "description": "A standing advisory about the place itself (closed Mondays, cash only, book weeks ahead): the app's Know before you go, replaced by the guide's own where a page exists. Not for what the traveller does there; that is visitNote.",
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "prose": {
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "ticketsURL": {
+ "format": "uri",
+ "type": "string"
+ },
+ "time": {
+ "description": "HH:mm, 24-hour.",
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "town": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "type": {
+ "description": "freeform for a transfer or a note.",
+ "enum": [
+ "activity",
+ "restaurant",
+ "freeform"
+ ],
+ "type": "string"
+ },
+ "visitNote": {
+ "description": "One sentence on what the traveller does here on this day (\"Camel trek out for sunset on the dunes, then back to camp for dinner\"). Shown under the stop's name. Put the doing here and keep title the place's proper name (\"Erg Chebbi\", not \"Camel trek into Erg Chebbi\").",
+ "maxLength": 500,
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "update_stop"
+ }
+ },
+ "required": [
+ "op",
+ "id",
+ "fields"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "move_stop"
+ },
+ "position": {
+ "minimum": 0,
+ "type": "integer"
+ }
+ },
+ "required": [
+ "op",
+ "id",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "remove_stop"
+ }
+ },
+ "required": [
+ "op",
+ "id"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "booking": {
+ "properties": {
+ "booked": {
+ "type": "boolean"
+ },
+ "city": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "countryCode": {
+ "pattern": "^[A-Za-z]{2}$",
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {
+ "type": "string"
+ },
+ "type": "object"
+ },
+ "endDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "endTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "startDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "startTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "subtitle": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "type": {
+ "enum": [
+ "hotel",
+ "flight",
+ "train",
+ "carRental",
+ "restaurant",
+ "activity",
+ "other"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "type",
+ "title"
+ ],
+ "type": "object"
+ },
+ "op": {
+ "const": "add_booking"
+ }
+ },
+ "required": [
+ "op",
+ "booking"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "fields": {
+ "properties": {
+ "booked": {
+ "type": "boolean"
+ },
+ "city": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "countryCode": {
+ "pattern": "^[A-Za-z]{2}$",
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {
+ "type": "string"
+ },
+ "type": "object"
+ },
+ "endDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "endTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "startDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "startTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "subtitle": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "type": {
+ "enum": [
+ "hotel",
+ "flight",
+ "train",
+ "carRental",
+ "restaurant",
+ "activity",
+ "other"
+ ],
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "update_booking"
+ }
+ },
+ "required": [
+ "op",
+ "id",
+ "fields"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "remove_booking"
+ }
+ },
+ "required": [
+ "op",
+ "id"
+ ],
+ "type": "object"
+ }
+]create_itinerary_link3 fields changedInput schema / properties / days / descriptionPrevious value: -"The days in order, each with what to do. Number every day or date every day, not a mix."New value: +"The days in order, each with what to do. Number every day or date every day, not a mix. Every day needs its own city or a stay (in stays) whose check-in to check-out, inclusive, covers it; the error names each day with neither."Input schema / properties / days / items / descriptionAdded value: +"One day. Give city unless a stay covers this day."Input schema / properties / days / items / properties / city / descriptionPrevious value: -"Where the traveller is that day, e.g. \"Kotor\"."New value: +"Where the traveller is that day, e.g. \"Kotor\". Required unless a stay in stays covers this day."create_plan5 fields changedInput schema / properties / ops / descriptionPrevious value: -"Optional edits to apply at once; see edit_plan."New value: +"Optional: the same ops as edit_plan, applied at once."Input schema / properties / ops / items / anyOfRemoved value: -[
- {
- "additionalProperties": false,
- "properties": {
- "op": {
- "const": "set_title"
- },
- "title": {
- "maxLength": 200,
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "op",
- "title"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "op": {
- "const": "set_start_date"
- },
- "startDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- }
- },
- "required": [
- "op",
- "startDate"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "op": {
- "const": "add_day"
- }
- },
- "required": [
- "op",
- "date"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "op": {
- "const": "remove_day"
- }
- },
- "required": [
- "op",
- "date"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "op": {
- "const": "set_day"
- },
- "summary": {
- "type": [
- "string",
- "null"
- ]
- },
- "town": {
- "type": [
- "string",
- "null"
- ]
- }
- },
- "required": [
- "op",
- "date"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "op": {
- "const": "add_stop"
- },
- "position": {
- "minimum": 0,
- "type": "integer"
- },
- "stop": {
- "properties": {
- "category": {
- "maxLength": 60,
- "type": "string"
- },
- "meridian_url": {
- "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title and town from the guide, so the stop lands on the map.",
- "type": "string"
- },
- "minutes": {
- "maximum": 1440,
- "minimum": 1,
- "type": "integer"
- },
- "note": {
- "maxLength": 2000,
- "type": "string"
- },
- "prose": {
- "maxLength": 2000,
- "type": "string"
- },
- "ticketsURL": {
- "format": "uri",
- "type": "string"
- },
- "time": {
- "description": "HH:mm, 24-hour.",
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "title": {
- "maxLength": 200,
- "type": "string"
- },
- "town": {
- "maxLength": 100,
- "type": "string"
- },
- "type": {
- "description": "freeform for a transfer or a note.",
- "enum": [
- "activity",
- "restaurant",
- "freeform"
- ],
- "type": "string"
- }
- },
- "type": "object"
- }
- },
- "required": [
- "op",
- "date",
- "stop"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "fields": {
- "description": "null on a field clears it.",
- "properties": {
- "category": {
- "maxLength": 60,
- "type": "string"
- },
- "meridian_url": {
- "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title and town from the guide, so the stop lands on the map.",
- "type": "string"
- },
- "minutes": {
- "maximum": 1440,
- "minimum": 1,
- "type": "integer"
- },
- "note": {
- "maxLength": 2000,
- "type": "string"
- },
- "prose": {
- "maxLength": 2000,
- "type": "string"
- },
- "ticketsURL": {
- "format": "uri",
- "type": "string"
- },
- "time": {
- "description": "HH:mm, 24-hour.",
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "title": {
- "maxLength": 200,
- "type": "string"
- },
- "town": {
- "maxLength": 100,
- "type": "string"
- },
- "type": {
- "description": "freeform for a transfer or a note.",
- "enum": [
- "activity",
- "restaurant",
- "freeform"
- ],
- "type": "string"
- }
- },
- "type": "object"
- },
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "update_stop"
- }
- },
- "required": [
- "op",
- "id",
- "fields"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "move_stop"
- },
- "position": {
- "minimum": 0,
- "type": "integer"
- }
- },
- "required": [
- "op",
- "id",
- "date"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "remove_stop"
- }
- },
- "required": [
- "op",
- "id"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "booking": {
- "properties": {
- "booked": {
- "type": "boolean"
- },
- "city": {
- "maxLength": 100,
- "type": "string"
- },
- "countryCode": {
- "pattern": "^[A-Za-z]{2}$",
- "type": "string"
- },
- "details": {
- "additionalProperties": {
- "type": "string"
- },
- "type": "object"
- },
- "endDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "endTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "startDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "startTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "subtitle": {
- "maxLength": 200,
- "type": "string"
- },
- "title": {
- "maxLength": 200,
- "type": "string"
- },
- "type": {
- "enum": [
- "hotel",
- "flight",
- "train",
- "carRental",
- "restaurant",
- "activity",
- "other"
- ],
- "type": "string"
- }
- },
- "required": [
- "type",
- "title"
- ],
- "type": "object"
- },
- "op": {
- "const": "add_booking"
- }
- },
- "required": [
- "op",
- "booking"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "fields": {
- "properties": {
- "booked": {
- "type": "boolean"
- },
- "city": {
- "maxLength": 100,
- "type": "string"
- },
- "countryCode": {
- "pattern": "^[A-Za-z]{2}$",
- "type": "string"
- },
- "details": {
- "additionalProperties": {
- "type": "string"
- },
- "type": "object"
- },
- "endDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "endTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "startDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "startTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "subtitle": {
- "maxLength": 200,
- "type": "string"
- },
- "title": {
- "maxLength": 200,
- "type": "string"
- },
- "type": {
- "enum": [
- "hotel",
- "flight",
- "train",
- "carRental",
- "restaurant",
- "activity",
- "other"
- ],
- "type": "string"
- }
- },
- "type": "object"
- },
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "update_booking"
- }
- },
- "required": [
- "op",
- "id",
- "fields"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "remove_booking"
- }
- },
- "required": [
- "op",
- "id"
- ],
- "type": "object"
- }
-]Input schema / properties / ops / items / propertiesAdded value: +{
+ "op": {
+ "type": "string"
+ }
+}Input schema / properties / ops / items / requiredAdded value: +[
+ "op"
+]Input schema / properties / ops / items / typeAdded value: +"object"edit_plan3 fields changedInput schema / properties / base_seq / descriptionPrevious value: -"The seq from get_plan or list_my_plans."New value: +"The seq from get_plan or list_my_plans. Required."Input schema / properties / ops / items / anyOfPrevious value: -[
- {
- "additionalProperties": false,
- "properties": {
- "op": {
- "const": "set_title"
- },
- "title": {
- "maxLength": 200,
- "minLength": 1,
- "type": "string"
- }
- },
- "required": [
- "op",
- "title"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "op": {
- "const": "set_start_date"
- },
- "startDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- }
- },
- "required": [
- "op",
- "startDate"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "op": {
- "const": "add_day"
- }
- },
- "required": [
- "op",
- "date"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "op": {
- "const": "remove_day"
- }
- },
- "required": [
- "op",
- "date"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "op": {
- "const": "set_day"
- },
- "summary": {
- "type": [
- "string",
- "null"
- ]
- },
- "town": {
- "type": [
- "string",
- "null"
- ]
- }
- },
- "required": [
- "op",
- "date"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "op": {
- "const": "add_stop"
- },
- "position": {
- "minimum": 0,
- "type": "integer"
- },
- "stop": {
- "properties": {
- "category": {
- "maxLength": 60,
- "type": "string"
- },
- "meridian_url": {
- "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title and town from the guide, so the stop lands on the map.",
- "type": "string"
- },
- "minutes": {
- "maximum": 1440,
- "minimum": 1,
- "type": "integer"
- },
- "note": {
- "maxLength": 2000,
- "type": "string"
- },
- "prose": {
- "maxLength": 2000,
- "type": "string"
- },
- "ticketsURL": {
- "format": "uri",
- "type": "string"
- },
- "time": {
- "description": "HH:mm, 24-hour.",
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "title": {
- "maxLength": 200,
- "type": "string"
- },
- "town": {
- "maxLength": 100,
- "type": "string"
- },
- "type": {
- "description": "freeform for a transfer or a note.",
- "enum": [
- "activity",
- "restaurant",
- "freeform"
- ],
- "type": "string"
- }
- },
- "type": "object"
- }
- },
- "required": [
- "op",
- "date",
- "stop"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "fields": {
- "description": "null on a field clears it.",
- "properties": {
- "category": {
- "maxLength": 60,
- "type": "string"
- },
- "meridian_url": {
- "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title and town from the guide, so the stop lands on the map.",
- "type": "string"
- },
- "minutes": {
- "maximum": 1440,
- "minimum": 1,
- "type": "integer"
- },
- "note": {
- "maxLength": 2000,
- "type": "string"
- },
- "prose": {
- "maxLength": 2000,
- "type": "string"
- },
- "ticketsURL": {
- "format": "uri",
- "type": "string"
- },
- "time": {
- "description": "HH:mm, 24-hour.",
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "title": {
- "maxLength": 200,
- "type": "string"
- },
- "town": {
- "maxLength": 100,
- "type": "string"
- },
- "type": {
- "description": "freeform for a transfer or a note.",
- "enum": [
- "activity",
- "restaurant",
- "freeform"
- ],
- "type": "string"
- }
- },
- "type": "object"
- },
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "update_stop"
- }
- },
- "required": [
- "op",
- "id",
- "fields"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "date": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "move_stop"
- },
- "position": {
- "minimum": 0,
- "type": "integer"
- }
- },
- "required": [
- "op",
- "id",
- "date"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "remove_stop"
- }
- },
- "required": [
- "op",
- "id"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "booking": {
- "properties": {
- "booked": {
- "type": "boolean"
- },
- "city": {
- "maxLength": 100,
- "type": "string"
- },
- "countryCode": {
- "pattern": "^[A-Za-z]{2}$",
- "type": "string"
- },
- "details": {
- "additionalProperties": {
- "type": "string"
- },
- "type": "object"
- },
- "endDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "endTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "startDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "startTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "subtitle": {
- "maxLength": 200,
- "type": "string"
- },
- "title": {
- "maxLength": 200,
- "type": "string"
- },
- "type": {
- "enum": [
- "hotel",
- "flight",
- "train",
- "carRental",
- "restaurant",
- "activity",
- "other"
- ],
- "type": "string"
- }
- },
- "required": [
- "type",
- "title"
- ],
- "type": "object"
- },
- "op": {
- "const": "add_booking"
- }
- },
- "required": [
- "op",
- "booking"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "fields": {
- "properties": {
- "booked": {
- "type": "boolean"
- },
- "city": {
- "maxLength": 100,
- "type": "string"
- },
- "countryCode": {
- "pattern": "^[A-Za-z]{2}$",
- "type": "string"
- },
- "details": {
- "additionalProperties": {
- "type": "string"
- },
- "type": "object"
- },
- "endDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "endTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "startDate": {
- "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
- "type": "string"
- },
- "startTime": {
- "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
- "type": "string"
- },
- "subtitle": {
- "maxLength": 200,
- "type": "string"
- },
- "title": {
- "maxLength": 200,
- "type": "string"
- },
- "type": {
- "enum": [
- "hotel",
- "flight",
- "train",
- "carRental",
- "restaurant",
- "activity",
- "other"
- ],
- "type": "string"
- }
- },
- "type": "object"
- },
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "update_booking"
- }
- },
- "required": [
- "op",
- "id",
- "fields"
- ],
- "type": "object"
- },
- {
- "additionalProperties": false,
- "properties": {
- "id": {
- "description": "A stop or booking id from get_plan.",
- "type": "string"
- },
- "op": {
- "const": "remove_booking"
- }
- },
- "required": [
- "op",
- "id"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "additionalProperties": false,
+ "properties": {
+ "op": {
+ "const": "set_title"
+ },
+ "title": {
+ "maxLength": 200,
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "op",
+ "title"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "op": {
+ "const": "set_start_date"
+ },
+ "startDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ }
+ },
+ "required": [
+ "op",
+ "startDate"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "op": {
+ "const": "add_day"
+ }
+ },
+ "required": [
+ "op",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "force": {
+ "description": "Required when the day holds stops or a booking starting that day: removes the day and its stops (bookings are kept). Without it such a day is refused, naming what it holds. Ask the traveller first.",
+ "type": "boolean"
+ },
+ "op": {
+ "const": "remove_day"
+ }
+ },
+ "required": [
+ "op",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "op": {
+ "const": "set_day"
+ },
+ "summary": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "town": {
+ "type": [
+ "string",
+ "null"
+ ]
+ }
+ },
+ "required": [
+ "op",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "op": {
+ "const": "add_stop"
+ },
+ "position": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "stop": {
+ "properties": {
+ "category": {
+ "maxLength": 60,
+ "type": "string"
+ },
+ "lat": {
+ "description": "Latitude of a real place with no meridian_url, to about 100 m: the app draws the travel line between two stops only when both have a location and a time. Give lat and lng together; they are checked against the stop's town.",
+ "maximum": 90,
+ "minimum": -90,
+ "type": "number"
+ },
+ "lng": {
+ "description": "Longitude, with lat.",
+ "maximum": 180,
+ "minimum": -180,
+ "type": "number"
+ },
+ "meridian_url": {
+ "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title, town and location from the guide, so the stop lands on the map.",
+ "type": "string"
+ },
+ "minutes": {
+ "maximum": 1440,
+ "minimum": 1,
+ "type": "integer"
+ },
+ "note": {
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "prose": {
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "ticketsURL": {
+ "format": "uri",
+ "type": "string"
+ },
+ "time": {
+ "description": "HH:mm, 24-hour.",
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "town": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "type": {
+ "description": "freeform for a transfer or a note.",
+ "enum": [
+ "activity",
+ "restaurant",
+ "freeform"
+ ],
+ "type": "string"
+ }
+ },
+ "type": "object"
+ }
+ },
+ "required": [
+ "op",
+ "date",
+ "stop"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "fields": {
+ "description": "null on a field clears it.",
+ "properties": {
+ "category": {
+ "maxLength": 60,
+ "type": "string"
+ },
+ "lat": {
+ "description": "Latitude of a real place with no meridian_url, to about 100 m: the app draws the travel line between two stops only when both have a location and a time. Give lat and lng together; they are checked against the stop's town.",
+ "maximum": 90,
+ "minimum": -90,
+ "type": "number"
+ },
+ "lng": {
+ "description": "Longitude, with lat.",
+ "maximum": 180,
+ "minimum": -180,
+ "type": "number"
+ },
+ "meridian_url": {
+ "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title, town and location from the guide, so the stop lands on the map.",
+ "type": "string"
+ },
+ "minutes": {
+ "maximum": 1440,
+ "minimum": 1,
+ "type": "integer"
+ },
+ "note": {
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "prose": {
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "ticketsURL": {
+ "format": "uri",
+ "type": "string"
+ },
+ "time": {
+ "description": "HH:mm, 24-hour.",
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "town": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "type": {
+ "description": "freeform for a transfer or a note.",
+ "enum": [
+ "activity",
+ "restaurant",
+ "freeform"
+ ],
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "update_stop"
+ }
+ },
+ "required": [
+ "op",
+ "id",
+ "fields"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "move_stop"
+ },
+ "position": {
+ "minimum": 0,
+ "type": "integer"
+ }
+ },
+ "required": [
+ "op",
+ "id",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "remove_stop"
+ }
+ },
+ "required": [
+ "op",
+ "id"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "booking": {
+ "properties": {
+ "booked": {
+ "type": "boolean"
+ },
+ "city": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "countryCode": {
+ "pattern": "^[A-Za-z]{2}$",
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {
+ "type": "string"
+ },
+ "type": "object"
+ },
+ "endDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "endTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "startDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "startTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "subtitle": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "type": {
+ "enum": [
+ "hotel",
+ "flight",
+ "train",
+ "carRental",
+ "restaurant",
+ "activity",
+ "other"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "type",
+ "title"
+ ],
+ "type": "object"
+ },
+ "op": {
+ "const": "add_booking"
+ }
+ },
+ "required": [
+ "op",
+ "booking"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "fields": {
+ "properties": {
+ "booked": {
+ "type": "boolean"
+ },
+ "city": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "countryCode": {
+ "pattern": "^[A-Za-z]{2}$",
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {
+ "type": "string"
+ },
+ "type": "object"
+ },
+ "endDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "endTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "startDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "startTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "subtitle": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "type": {
+ "enum": [
+ "hotel",
+ "flight",
+ "train",
+ "carRental",
+ "restaurant",
+ "activity",
+ "other"
+ ],
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "update_booking"
+ }
+ },
+ "required": [
+ "op",
+ "id",
+ "fields"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "remove_booking"
+ }
+ },
+ "required": [
+ "op",
+ "id"
+ ],
+ "type": "object"
+ }
+]Input schema / requiredPrevious value: -[
- "plan_id",
- "ops"
-]New value: +[
+ "plan_id",
+ "base_seq",
+ "ops"
+]get_best_time3 fields changedOutput schema / properties / recommended / items / properties / best_time_lineAdded value: +{
+ "description": "When there is no why_now: the guide's best-time line for the whole year.",
+ "type": "string"
+}Output schema / properties / recommended / items / properties / regionAdded value: +{
+ "type": "string"
+}Output schema / properties / recommended / items / properties / why_now / descriptionAdded value: +"Why go this month, from the guide."create_plan2 fields changedInput schema / properties / ops / itemsAdded value: +{
+ "anyOf": [
+ {
+ "additionalProperties": false,
+ "properties": {
+ "op": {
+ "const": "set_title"
+ },
+ "title": {
+ "maxLength": 200,
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "op",
+ "title"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "op": {
+ "const": "set_start_date"
+ },
+ "startDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ }
+ },
+ "required": [
+ "op",
+ "startDate"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "op": {
+ "const": "add_day"
+ }
+ },
+ "required": [
+ "op",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "op": {
+ "const": "remove_day"
+ }
+ },
+ "required": [
+ "op",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "op": {
+ "const": "set_day"
+ },
+ "summary": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "town": {
+ "type": [
+ "string",
+ "null"
+ ]
+ }
+ },
+ "required": [
+ "op",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "op": {
+ "const": "add_stop"
+ },
+ "position": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "stop": {
+ "properties": {
+ "category": {
+ "maxLength": 60,
+ "type": "string"
+ },
+ "meridian_url": {
+ "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title and town from the guide, so the stop lands on the map.",
+ "type": "string"
+ },
+ "minutes": {
+ "maximum": 1440,
+ "minimum": 1,
+ "type": "integer"
+ },
+ "note": {
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "prose": {
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "ticketsURL": {
+ "format": "uri",
+ "type": "string"
+ },
+ "time": {
+ "description": "HH:mm, 24-hour.",
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "town": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "type": {
+ "description": "freeform for a transfer or a note.",
+ "enum": [
+ "activity",
+ "restaurant",
+ "freeform"
+ ],
+ "type": "string"
+ }
+ },
+ "type": "object"
+ }
+ },
+ "required": [
+ "op",
+ "date",
+ "stop"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "fields": {
+ "description": "null on a field clears it.",
+ "properties": {
+ "category": {
+ "maxLength": 60,
+ "type": "string"
+ },
+ "meridian_url": {
+ "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title and town from the guide, so the stop lands on the map.",
+ "type": "string"
+ },
+ "minutes": {
+ "maximum": 1440,
+ "minimum": 1,
+ "type": "integer"
+ },
+ "note": {
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "prose": {
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "ticketsURL": {
+ "format": "uri",
+ "type": "string"
+ },
+ "time": {
+ "description": "HH:mm, 24-hour.",
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "town": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "type": {
+ "description": "freeform for a transfer or a note.",
+ "enum": [
+ "activity",
+ "restaurant",
+ "freeform"
+ ],
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "update_stop"
+ }
+ },
+ "required": [
+ "op",
+ "id",
+ "fields"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "move_stop"
+ },
+ "position": {
+ "minimum": 0,
+ "type": "integer"
+ }
+ },
+ "required": [
+ "op",
+ "id",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "remove_stop"
+ }
+ },
+ "required": [
+ "op",
+ "id"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "booking": {
+ "properties": {
+ "booked": {
+ "type": "boolean"
+ },
+ "city": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "countryCode": {
+ "pattern": "^[A-Za-z]{2}$",
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {
+ "type": "string"
+ },
+ "type": "object"
+ },
+ "endDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "endTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "startDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "startTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "subtitle": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "type": {
+ "enum": [
+ "hotel",
+ "flight",
+ "train",
+ "carRental",
+ "restaurant",
+ "activity",
+ "other"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "type",
+ "title"
+ ],
+ "type": "object"
+ },
+ "op": {
+ "const": "add_booking"
+ }
+ },
+ "required": [
+ "op",
+ "booking"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "fields": {
+ "properties": {
+ "booked": {
+ "type": "boolean"
+ },
+ "city": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "countryCode": {
+ "pattern": "^[A-Za-z]{2}$",
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {
+ "type": "string"
+ },
+ "type": "object"
+ },
+ "endDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "endTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "startDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "startTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "subtitle": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "type": {
+ "enum": [
+ "hotel",
+ "flight",
+ "train",
+ "carRental",
+ "restaurant",
+ "activity",
+ "other"
+ ],
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "update_booking"
+ }
+ },
+ "required": [
+ "op",
+ "id",
+ "fields"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "remove_booking"
+ }
+ },
+ "required": [
+ "op",
+ "id"
+ ],
+ "type": "object"
+ }
+ ]
+}Input schema / properties / ops / maxItemsAdded value: +100edit_plan5 fields changedInput schema / properties / ops / items / anyOfAdded value: +[
+ {
+ "additionalProperties": false,
+ "properties": {
+ "op": {
+ "const": "set_title"
+ },
+ "title": {
+ "maxLength": 200,
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "op",
+ "title"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "op": {
+ "const": "set_start_date"
+ },
+ "startDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ }
+ },
+ "required": [
+ "op",
+ "startDate"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "op": {
+ "const": "add_day"
+ }
+ },
+ "required": [
+ "op",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "op": {
+ "const": "remove_day"
+ }
+ },
+ "required": [
+ "op",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "op": {
+ "const": "set_day"
+ },
+ "summary": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "town": {
+ "type": [
+ "string",
+ "null"
+ ]
+ }
+ },
+ "required": [
+ "op",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "op": {
+ "const": "add_stop"
+ },
+ "position": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "stop": {
+ "properties": {
+ "category": {
+ "maxLength": 60,
+ "type": "string"
+ },
+ "meridian_url": {
+ "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title and town from the guide, so the stop lands on the map.",
+ "type": "string"
+ },
+ "minutes": {
+ "maximum": 1440,
+ "minimum": 1,
+ "type": "integer"
+ },
+ "note": {
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "prose": {
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "ticketsURL": {
+ "format": "uri",
+ "type": "string"
+ },
+ "time": {
+ "description": "HH:mm, 24-hour.",
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "town": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "type": {
+ "description": "freeform for a transfer or a note.",
+ "enum": [
+ "activity",
+ "restaurant",
+ "freeform"
+ ],
+ "type": "string"
+ }
+ },
+ "type": "object"
+ }
+ },
+ "required": [
+ "op",
+ "date",
+ "stop"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "fields": {
+ "description": "null on a field clears it.",
+ "properties": {
+ "category": {
+ "maxLength": 60,
+ "type": "string"
+ },
+ "meridian_url": {
+ "description": "The url of a Meridian Dispatch place (from get_place, get_destination or search_guides). Sets the title and town from the guide, so the stop lands on the map.",
+ "type": "string"
+ },
+ "minutes": {
+ "maximum": 1440,
+ "minimum": 1,
+ "type": "integer"
+ },
+ "note": {
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "prose": {
+ "maxLength": 2000,
+ "type": "string"
+ },
+ "ticketsURL": {
+ "format": "uri",
+ "type": "string"
+ },
+ "time": {
+ "description": "HH:mm, 24-hour.",
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "town": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "type": {
+ "description": "freeform for a transfer or a note.",
+ "enum": [
+ "activity",
+ "restaurant",
+ "freeform"
+ ],
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "update_stop"
+ }
+ },
+ "required": [
+ "op",
+ "id",
+ "fields"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "date": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "move_stop"
+ },
+ "position": {
+ "minimum": 0,
+ "type": "integer"
+ }
+ },
+ "required": [
+ "op",
+ "id",
+ "date"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "remove_stop"
+ }
+ },
+ "required": [
+ "op",
+ "id"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "booking": {
+ "properties": {
+ "booked": {
+ "type": "boolean"
+ },
+ "city": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "countryCode": {
+ "pattern": "^[A-Za-z]{2}$",
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {
+ "type": "string"
+ },
+ "type": "object"
+ },
+ "endDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "endTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "startDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "startTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "subtitle": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "type": {
+ "enum": [
+ "hotel",
+ "flight",
+ "train",
+ "carRental",
+ "restaurant",
+ "activity",
+ "other"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "type",
+ "title"
+ ],
+ "type": "object"
+ },
+ "op": {
+ "const": "add_booking"
+ }
+ },
+ "required": [
+ "op",
+ "booking"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "fields": {
+ "properties": {
+ "booked": {
+ "type": "boolean"
+ },
+ "city": {
+ "maxLength": 100,
+ "type": "string"
+ },
+ "countryCode": {
+ "pattern": "^[A-Za-z]{2}$",
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {
+ "type": "string"
+ },
+ "type": "object"
+ },
+ "endDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "endTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "startDate": {
+ "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
+ "type": "string"
+ },
+ "startTime": {
+ "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
+ "type": "string"
+ },
+ "subtitle": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "title": {
+ "maxLength": 200,
+ "type": "string"
+ },
+ "type": {
+ "enum": [
+ "hotel",
+ "flight",
+ "train",
+ "carRental",
+ "restaurant",
+ "activity",
+ "other"
+ ],
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "update_booking"
+ }
+ },
+ "required": [
+ "op",
+ "id",
+ "fields"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "id": {
+ "description": "A stop or booking id from get_plan.",
+ "type": "string"
+ },
+ "op": {
+ "const": "remove_booking"
+ }
+ },
+ "required": [
+ "op",
+ "id"
+ ],
+ "type": "object"
+ }
+]Input schema / properties / ops / items / propertiesRemoved value: -{
- "op": {
- "enum": [
- "set_title",
- "set_start_date",
- "add_day",
- "remove_day",
- "set_day",
- "add_stop",
- "update_stop",
- "move_stop",
- "remove_stop",
- "add_booking",
- "update_booking",
- "remove_booking"
- ],
- "type": "string"
- }
-}Input schema / properties / ops / items / requiredRemoved value: -[
- "op"
-]Input schema / properties / ops / items / typeRemoved value: -"object"Input schema / properties / verboseAdded value: +{
+ "description": "Return the whole plan. By default the reply shows only the days and bookings the edit touched.",
+ "type": "boolean"
+}get_my_accountget_travel_preferencescreate_plandelete_planedit_planget_planlist_my_planscreate_itinerary_link3 fields changedInput schema / properties / stays / descriptionPrevious value: -"Where the traveller sleeps, by hotel name. Required: every day must fall between a stay's check-in and check-out (inclusive), or the app shows that day without its places. check_in_day and check_out_day on a numbered itinerary, check_in and check_out (YYYY-MM-DD) on a dated one."New value: +"Where the traveller sleeps, by hotel name. Optional: a day not between a stay's check-in and check-out (inclusive) must give its own city, which places it in the app until a hotel is added. check_in_day and check_out_day on a numbered itinerary, check_in and check_out (YYYY-MM-DD) on a dated one."Input schema / properties / stays / minItemsRemoved value: -1Input schema / requiredPrevious value: -[
- "title",
- "country_code",
- "days",
- "stays"
-]New value: +[
+ "title",
+ "country_code",
+ "days"
+]confirm_fact2 fields changedInput schema / properties / url / descriptionPrevious value: -"The meridiandispatch.com page, as returned by list_pages_to_verify or in source.url."New value: +"The meridiandispatch.com page, as returned in source.url."Output schema / properties / duplicateAdded value: +{
+ "type": "boolean"
+}get_destination4 fields changedInput schema / properties / detailAdded value: +{
+ "default": "summary",
+ "description": "\"summary\" (default): a compact answer of a few thousand characters with place ids to drill into. \"full\": the whole guide (FAQ answers, full fact sheet, every ranked place, hotels), often over 15,000 characters.",
+ "enum": [
+ "summary",
+ "full"
+ ],
+ "type": "string"
+}Output schema / properties / detailAdded value: +{
+ "enum": [
+ "summary",
+ "full"
+ ],
+ "type": "string"
+}Output schema / properties / places / items / properties / idAdded value: +{
+ "description": "The place page, to pass to get_place as url.",
+ "type": "string"
+}Output schema / properties / verdictAdded value: +{
+ "type": "string"
+}list_pages_to_verifysuggest_edit3 fields changedInput schema / properties / basisRemoved value: -{
- "default": "traveller",
- "description": "Who found the error: \"traveller\" (they told you) or \"own_research\" (a source you read contradicts the page; source_url is then required).",
- "enum": [
- "traveller",
- "own_research"
- ],
- "type": "string"
-}Input schema / properties / source_url / descriptionPrevious value: -"A page that supports the correction, ideally the place's own website. Required when basis is \"own_research\"; otherwise optional but it speeds review."New value: +"Optional: a page that supports the correction, ideally the place's own website. It speeds review."Output schema / properties / duplicateAdded value: +{
+ "type": "boolean"
+}suggest_place1 field changedOutput schema / properties / duplicateAdded value: +{
+ "type": "boolean"
+}Free snow reports, forecasts and season history for ~400 US and Canada ski resorts, with citations.
European mountain routes, huts, access and forecasts with sources and explicit unknowns.
Ski resort conditions, forecasts, avalanche danger, sun, routes and snow history for 5,000+ resorts.
Multilingual travel guides, gear picks and booking links for AI travel agents.
Add one secure layer between your agents and this server.
