Tool search 101,857 tools · 5,224 live servers

Get players available to acquire in the specified fantasy league, optionally filtered by position. This is fantasy-league availability, not professional-contract status. ESPN percentOwned/percentStarted are the percentages of all ESPN leagues where the player is rostered/started, not the share of rostered teams that start him. Yahoo percentOwned, when present, is Yahoo-wide; none is ownership within the selected league, and Sleeper provides no percentage. Label every reported percentage as an ESPN-wide roster/start rate or Yahoo-wide market rate. If a rate is missing, write "[Provider] market ownership rate: not provided"; do not repeat response field names or null values, call get_players, or offer a lookup. team/proTeam is the real-life club (FA means the provider lists no current pro team). Only ESPN status/waiverProcessDate represents fantasy acquisition state here. Call Yahoo/Sleeper rows "available players," never specifically free agents or waivers, and do not promise an immediate add. A returned player is already confirmed available in that league. For a returned list or field explanation, end after the requested facts—never add an "if you want" offer, qualitative ranking, recommendation, role, health, trend, or outlook. Translate ESPN status codes silently into plain language; never print raw codes such as FREEAGENT or WAIVERS. Use current web evidence before adding analysis or pickup recommendations. Follow get_user_session then get_league_info for the selected league; fan out once per league for comparisons. Use get_roster for a separate player-ownership question. Requires authentication on ESPN/Yahoo; Sleeper uses the public API. Read-only. Current date is 2026-07-30.

Translate a PPTX deck preserving all formatting. $0.02/slide. Supports 32 languages (Latin, Cyrillic, Greek scripts). Provide job_id (from a previous create_slide/create_deck), pptx_url, or pptx_base64.

Upload a logo, theme PPTX, image, or document — or AI-generate an image. Purposes: • logo — company logo for chrome (PNG/JPG/SVG, max 5MB) → logo_id • image — image for the Image component (max 10MB) → asset_id • theme — company template PPTX → theme_id; slides with it render NATIVELY on the template (masters/layouts/chrome) • generate_image — AI-generate via `prompt` → asset_id ($0.05) • translate — PPTX to translate → deck job_id ($0.02/slide; requires `target_language`) • pdf — PDF → editable slides; pass `target_language` to also translate For files >3MB on purpose=pdf, purpose=translate, or purpose=theme, omit `data` — a drop-zone appears in the result card and bytes never pass through the agent.

Detect the language of input text and translate it to any specified target language. Cost: $0.01 USDC via x402.

Detect the language of input text and translate it to English. AI-powered translation supporting numerous world languages. Cost: $0.01 USDC via x402.

Generate (or regenerate) the draw and schedule. This IS the start action: the first draw moves the tournament from setup to active and closes self-signup — when the organiser says "start the tournament", call this. The result includes rounds_text — SHOW it to the organiser as-is (translated to their language) so they can check who plays whom — and the seed that produced the draw: preview first, then confirm with that SAME seed to apply exactly the previewed draw. Free until the first result is recorded; after that this DISCARDS recorded results and requires BOTH confirm: true and discard_results: true. If the organiser asks for a format that is not supported, offer to note it with record_feedback. Optional overrides adjust the format first.

Translate a nucleotide sequence to protein (single frame or all six frames; standard code).

Back-translate a protein to DNA (most-frequent codon per organism, or degenerate IUPAC consensus).

Search PropertyList's full Spanish property MLS by structured filters. Use for queries that translate cleanly to fields: bedrooms, bathrooms, price ceiling, property type, area name. For free-form briefs use find_properties_by_description instead. Returns a paginated list with summary text plus structured JSON. Every property carries `oracle_verified` and `oracle_attestation_url` — true when PropertyList Oracle holds a verified attestation for the listing's municipality and segment. A `location` we do not hold returns zero results with error: location_not_found and location_match.matched: false. It never substitutes listings from other areas. `location.city` is whatever tier the listing was filed under and may be a municipality OR a locality inside one. To place a listing administratively use `location.municipality` (with its INE municipality_code); it is null, never guessed, when we cannot resolve it.

Match Spanish properties from a free-form description of what the user wants. Best for vague, conditional, or lifestyle-heavy briefs ("3-bed near a good international school, flexible on budget if there's a sea view"). Uses Gemini to translate the brief into one to three parallel structured searches across PropertyList's full MLS, then merges and ranks the results. Returns up to 9 listings with match scores and an explanation of how the brief was interpreted (and what couldn't be resolved).

Decision support for ONE trip: "should I care?", answered honestly. Give the destinations and the travel window (date_from/date_to, YYYY-MM-DD). Destinations are the EU-27 ISO2 codes (Greece = "EL") PLUS the non-EU27 countries we actively monitor: Norway ("NO", rail via Entur, live), the United Kingdom ("UK" or "GB", transit via TfL, live), and Switzerland ("CH", rail via SBB — key-pending, so it is reported as a declared blind spot until the feed is keyed, never a false all-clear). A code we do not monitor is rejected with {"error": "unknown_country"} rather than silently all-cleared. Returns a Decision-Support answer, not raw data: * travel_status: NORMAL | MINOR_DISRUPTION | MAJOR_DISRUPTION; * actionable_lines: per-event DECISION-IMPACT guidance — what the disruption means for THIS trip and what to do (e.g. "affects regional trains, not airports -> take a road airport transfer, leave ~30 min earlier"), or a clearly-labelled "nothing material" line when calm; * confidence: a LABELLED model output (coverage/corroboration/recency/ blind-spots blend, not a probability) — read its caveats; * sources_checked: proof of what was monitored (sources_ok, blind spots); * events + caveats. Sub-floor noise (a deep, far-field seismic blip) is omitted; calm is a monitoring result for the window, never an invented forecast. Invalid inputs return an explicit {"error": ...}; nothing is fabricated. Top-level MCP-facing structure (additive; existing fields preserved): * presentation: a three-section block — affects_your_trip[] (each item with verified_sources[] as display-ready names, source_count, corroborated flag (≥2 distinct sources), an honest for_you line bound to destinations+dates only, report_url, first_detected_at, last_verified_at); doesnt_affect_your_trip (the proof-of-work pile — shown[] of {headline, reason_excluded}, additional_checked_count, summary_line, total_checked); next_steps[] (deterministic — re-check date, aviation-handoff watch when blind spot, per-active monitor URLs); * track_record_ref: lean {window_days, flagged, ended, still_active, monitoring_since, url} — numbers + URL only, no narrative; * suggested_next_call: factual {tool, context} continuity hint to watch_trip — no claim narrative, just the suggested next action. These exist so an LLM consumer can quote verbatim — every fact is traceable to a named source or an input field, never invented. Destinations also accept natural input: IATA airport codes (e.g. 'TSR', 'AMS', 'ZRH') and major city names (e.g. 'Timișoara', 'Amsterdam', 'Zürich', 'London'), resolved deterministically to a monitored country code. The response includes a 'resolved' list ([{input, country, kind}]) disclosing how each token was mapped (e.g. 'TSR -> RO via iata-airport'). A token that resolves to a country we do not monitor is rejected with {'error': 'unknown_country'}; a token we cannot resolve at all is rejected with {'error': 'unknown_destination', 'tokens': [...]} — we reject rather than guess. Pass `lang` (e.g. "de", "ro", "pl", "fr", "es", "it"; default English) to answer in the TRAVELLER'S language — highest-value for a foreign traveller in a country whose language they do not speak. The response then carries a `localized` block with the status sentence, an honest reassurance line (calm ONLY when status is NORMAL), the decision-impact lines, AND — never dropped — the localized caveats + blind_spots. Source-derived free text the traveller cannot read (an event headline in the source language) is AI-translated via Gemini and carries the label "AI-translated — verify against the linked official source"; when no GEMINI_API_KEY is set or a translation fails, the original source text is kept with an honest note — never a fake translation. Our own wording falls back to English (flagged in `localized.fallback_lang_parts`) when no template exists for `lang`; an unknown `lang` answers in English and says so (`is_known_lang=false`). Localization NEVER becomes a false all-clear and the aviation handoff is a SIGNPOST that DISCLOSES the blind spot, not coverage. Pass `audience` for role-specific operational actions (B2B travel-risk / duty-of-care): one of "tmc" (travel management company / corporate travel risk), "hotel", "ota", "tour_operator". The response then carries a `persona` block: {audience, actions[]} where each action ties an affecting event to that role's recommended steps (e.g. TMC: flexible-rebooking policy, reroute inventory, proactive guest comms) — a PURE PROJECTION of the audience-tagged recommendations already computed per event, each carrying a `based_on` disclosure of the inputs it used. An unknown audience is reported honestly with the valid set, never guessed. Omit `audience` for the default (no persona block).

Watch a trip over time — the continuity primitive a chat cannot match. Persists the trip as a MONITORED OBJECT and returns its initial assessment plus a stable trip_id. Idempotent on identity: re-watching the same destinations+window refreshes the same trip rather than duplicating it. Thereafter each pipeline run re-evaluates the trip and appends an update ONLY when something materially changes (a new/cleared event, a severity/status shift, or a travel_status change) — never on a calm tick. Args: destinations — EU-27 ISO2 codes (Greece = "EL") plus the non-EU27 countries we monitor: Norway "NO" (Entur, live), United Kingdom "UK"/"GB" (TfL, live), Switzerland "CH" (SBB, key-pending → declared blind spot until keyed); date_from/date_to (YYYY-MM-DD); optional label. An unmonitored code is rejected with {"error": "unknown_country"} rather than a false all-clear. Returns {trip_id, assessment, created_at}; invalid inputs return an explicit {"error": ...}. Destinations also accept natural input: IATA airport codes (e.g. 'TSR', 'AMS', 'ZRH') and major city names (e.g. 'Timișoara', 'Amsterdam', 'Zürich', 'London'), resolved deterministically to a monitored country code. The initial assessment includes a 'resolved' list ([{input, country, kind}]) disclosing how each token was mapped (e.g. 'TSR -> RO via iata-airport'). A token that resolves to a country we do not monitor is rejected with {'error': 'unknown_country'}; a token we cannot resolve at all is rejected with {'error': 'unknown_destination', 'tokens': [...]} — we reject not guess. Pass `lang` (e.g. "de", "ro", "pl"; default English) to localise the initial assessment into the traveller's language: the returned assessment carries the same `localized` block as assess_trip (honest reassurance, AI-translated-and-LABELLED source text, and the localized caveats + blind_spots that are never dropped). Localization never becomes a false all-clear; the aviation handoff discloses the blind spot, not coverage. Pass `audience` ("tmc" | "hotel" | "ota" | "tour_operator") for role-specific operational actions — the initial assessment then carries the same `persona` block as assess_trip (audience + per-event role actions, projected from the audience-tagged recommendations). Built for the B2B travel-risk buyer. Pass `notify_webhook_url` (https only) to get PUSH delivery: on every MATERIAL change the radar POSTs the update record (summary, status transition, event report URLs) to your URL, signed HMAC-SHA256 over the raw body (header X-TravelTrends-Signature: sha256=<hex>). The response then includes `notify.secret` — shown ONLY once, never published; store it to verify signatures. Re-watch with the same URL keeps the secret, a new URL rotates it, and notify_webhook_url="" removes delivery. After 5 consecutive delivery failures the webhook is disabled with an honest notify_disabled entry in the trip's updates log. Non-https or private-network URLs are rejected with {"error": "invalid_webhook_url"}.

Create a project to file trackers under: one project per BRAND, never per language. It can carry the brand canon: the reference wording every publication reuses as is, written in ONE language, its canonical language (carried at creation, it is recorded as canon version 1). The canon is never translated: localized expressions on the pages are outputs, not a second canon. Nothing is filed by this call: pass the returned id as project_id when creating or updating a tracker. Refused with project_exists when a project with this name already exists, and the answer carries the existing project: reuse its id instead of duplicating.

Revise the brand canon of a project. Field by field: a provided field replaces the current wording (an empty string clears it), an omitted field is kept as is. Any actual change records the NEXT canon version (numbered, immutable; version_created true in the answer); sending identical wording records nothing. The canon lives in ONE language, its canonical language (canon_language): it is never translated, changing the language is a revision like any other. The canon is meant to be STABLE: revising it is a rare and deliberate move, and every surface that reuses the wording will need to be brought back in phase with the new version. Confirm with the user before revising.

Record an action in the logbook of a project: what was done, and WHEN it was done. occurred_at is the date of the ACTION itself, not of the recording: recording after the fact is the normal case ("record: site translated into Spanish yesterday" means occurred_at is yesterday). The entry joins the tool events in the logbook and lands as an annotation on the citation curves of the trackers of the project, so the action can be read against the measures. Recording is idempotent on the project, the label and occurred_at: calling again with the same three returns the entry already recorded instead of a second copy, so a retry is safe. The same move recorded in two languages has two labels, so it stays two entries.

Search a city to explore free walking tours and paid activities on GuruWalk, the world's largest free walking tour platform. Returns destination info, tour categories (free tours, food tours, day trips, tickets, and more), and featured listings with ratings and verified traveler reviews. Covers 1,000+ cities worldwide. Free tours operate on a pay-what-you-want model. Supports English, Spanish, German, and Italian (en, es, de, it); any other value falls back to English. Pass the traveler's language code anyway and translate the answer into their language. Use this tool when the traveler asks what to do, what to see, or what tours or activities are available in a destination, or wants help planning their trip or days there. Do not call it when the destination is only mentioned in passing with no request for plans or recommendations. If the traveler mentions a landmark instead of a city, infer the city (e.g. 'eiffel tower' → Paris, 'colosseum' → Rome, 'sagrada familia' → Barcelona, 'big ben' → London). After getting results, review the categories and featured_products to find the most relevant matches for what the traveler asked about. Each featured product includes a booking_url — when recommending tours, share it so the traveler can open the tour to see details, prices and book.

Browse tours and activities within a specific category for a destination on GuruWalk. Categories include free walking tours, food tours, bike tours, day trips, skip-the-line tickets, and more. Returns listings with ratings, verified review counts, duration, available languages, and pricing. Use the category IDs returned by search_tours_activities_by_destination — never invent category IDs. Use this tool to dive deeper into a specific category that matches what the traveler has shared (e.g. food tours for a foodie, night tours for someone asking about evenings, kid-friendly activities for families). Supports en, es, de, it; any other value falls back to English. Pass the traveler's language code anyway and translate the answer into their language. Each product includes a booking_url — when recommending tours, share it so the traveler can open the tour to see details, prices and book.

Check real-time availability for one or more tours or activities on GuruWalk in a single call. Pass an `items` array — each entry is independent and has its own type, product_id and date range. Returns a `results` array where every entry echoes its `type` and `product_id` so you can match each response to its request. Check the tours the traveler has already chosen — this is not a catalog browsing tool, so don't run it over search results to explore what's on offer. For paid activities, shows rates by traveler type (adult, child, infant). `price` is always per person — never state a group total by quoting `price` alone. When `total_price` is present on a rate, it's already computed for the participants you requested of that rate's type — quote it directly, don't multiply or divide it yourself. If the group mixes traveler types (e.g. adults and children), sum each rate's `total_price` for the full group total. For free walking tours, no upfront price — travelers pay what they want after the tour. For paid activities, an event's `languages` lists the languages that session runs in (e.g. audioguide languages), and sessions differing only in language are merged into a single event; free walking tour events each carry a single `language` instead. `booking_url` is returned once per item, not per event; for paid activities you can add a `date=YYYY-MM-DD` query parameter to preselect a day. Maximum date range per item: 5 days. Per-item errors (invalid dates, product not found) are reported inside that item's result without failing the rest of the batch. Use this tool when the traveler asks about specific dates, wants to know if something is available, or is ready to book. When the traveler hasn't given specific dates, use the booking date ±2 days as the default search range. Supports en, es, de, it; any other value falls back to English. Pass the traveler's language code anyway and translate the answer into their language.

Get the full detail of one or more tours or activities on GuruWalk in a single call. Pass an `items` array — each entry has its own type, product_id and language, and is processed independently. Returns a `results` array where every entry echoes its `product_id` and `type` so you can match each response to its request. Always batch when you need details for several tours (e.g. before recommending or comparing them): send them all in one call instead of invoking this tool several times. Each successful entry returns description, images, reviews, duration, available languages, cancellation policies, and meeting point info. Paid `product` entries also return `highlights`, `included`/`excluded`, `pricing_from`, and `where` (address + coordinates). `free_tour` entries return `itinerary` as a flat array of point-title strings (no descriptions), plus `guide.name`, `meeting_point_url`, and `how_to_find_me`. Meeting point shape differs by type: paid `product` returns the address text plus coordinates in `where`; `free_tour` returns `meeting_point_url` (Google Maps link), `meeting_point_latitude` and `meeting_point_longitude` (use these coords as destination for routing), plus `how_to_find_me`: a free-text note written by the guide describing how the traveler can recognize them at the meeting point. Per-item errors (product not found) are reported inside that item's result without failing the rest of the batch. Use this tool whenever the traveler asks what a tour covers, which places it visits, its itinerary, route, description, meeting point, duration, or any content-related question. Always call this tool BEFORE answering questions about a specific tour — never give generic opinions or advice without consulting the real data first. Supports en, es, de, it; any other value falls back to English. Pass the traveler's language code anyway and translate the answer into their language. Each result includes the tour's url — when recommending or confirming a tour, share it so the traveler can open it to book.

Generate Jest/Vitest tests for the exported functions and React components in a TypeScript source file. Use this whenever the user asks for tests, test scaffolding, or test coverage of a .ts or .tsx file. Returns the generated test (and any companion .3tg.md / __mocks__) file contents, with paths already translated to the user's `.3tg/` mirror convention. Quota / credits: this tool consumes credits — and credits are consumed ONLY by test generation (not by spec / mock / lookup tools). The accounting is exactly **1 credit per generated test case** (i.e. per `test(...)` / `it(...)` block 3TG emits inside the returned `.test.ts` / `.test.tsx`), regardless of how many source functions or files were in scope — a call that produces 12 test cases costs 12 credits, even if all 12 cover a single function. Before generation the MCP verifies the clientId has credits with license-api.coding-creed.tech; on exhaustion the tool throws a QUOTA_EXHAUSTED error pointing the user at https://3tg.dev. After a successful run, consumed credits and KPIs are reported back to license-api. Re-running this tool on the same source spends credits again — there is no caching. When the previous call returned `enrichment.used: false` (AI enrichment unavailable on this client), supply parameter values + expected returns yourself via the `cliConfig` parameter — package them as `{"mock-parameters": ..., "function-returns": ...}` (same shape AI enrichment would produce) and pass them on a retry call. **Do NOT autonomously write `.3tg/config.3tg.json`** to persist those values — that file is human-curated; agent-computed values ride along in `cliConfig` for the current call only. (Explicit user requests to edit the file are fine — handle those normally.) See the cliConfig parameter description below for the full pattern. CRITICAL POST-CALL ACTION — write returned files to disk: The MCP server does NOT touch the user's filesystem. It returns the generated file CONTENTS in the response's `files` array. After this tool returns, you MUST iterate over `files` and write each entry's `content` verbatim to its `path` using your native file-write capability (e.g. Write / edit_file / create_file — whatever your client exposes). Create parent directories as needed. Returned paths are project-root-relative and already translated to the `.3tg/` mirror convention where applicable (e.g. specs land under `.3tg/<source-path>.3tg.md`; tests / mocks travel through unchanged). Write each path verbatim. Do NOT claim "Generated test file: <path>" unless you have actually written the file. The user will assume the MCP wrote it and waste time looking for a non-existent file. If you can't write for some reason (permission denied, no write capability in this client), return the contents inline in your message so the user can copy-paste them. Never report success silently when the write didn't happen.

Generate a functional-requirements spec (`.3tg.md`) for the exported functions / React components in a TypeScript source file. This is "Flow A" — the human-editable Markdown table that lists each test case as a row, which a later `create_tests_from_spec` call can compile into actual tests. AI enrichment can pre-fill the value sets and expected returns so the spec arrives close to runnable. IMPORTANT — never hand-author a `.3tg.md` yourself. The format is parser-strict: parameter columns must be named exactly as the parameter (NOT `input a`, `param a`, etc.), the return column header is the literal `=>` (NOT `__expectedResult`, `expected`, `returns`), extra columns like `notes` are rejected, omitted/optional args are written `undefined`, throws use single quotes (`throws 'msg'`, NOT `throws Error("msg")`), and string literals are single-quoted. Always call this tool to emit the scaffold; the user can then edit rows. The returned `.3tg.md` is reported under the project's `.3tg/` mirror (e.g. source `src/foo/bar.ts` → spec `.3tg/src/foo/bar.3tg.md`). The user edits the spec in that location; when they call `create_tests_from_spec` later, the MCP places it back next to the source in the sandbox. Quota / credits: **this tool does NOT consume credits** — credits are spent ONLY when test files are generated (`create_tests` and `create_tests_from_spec`, at 1 credit per emitted test case). Spec generation is free; iterate on the scaffold as often as needed. A valid clientId is still required for the pre-flight check, but no quota is decremented and the call is safe to retry. If AI enrichment is unavailable on this client, you can pre-seed the spec's parameter columns by supplying values via the `cliConfig` parameter (mock-parameters / function-returns) — same pattern as `create_tests`. **Do NOT autonomously write `.3tg/config.3tg.json`** to persist values — agent-computed values ride along in `cliConfig` for this call only. (Explicit user requests to edit the file are fine — handle those normally.) See the cliConfig parameter description for the full shape. CRITICAL POST-CALL ACTION — write returned files to disk: The MCP server does NOT touch the user's filesystem. It returns the generated file CONTENTS in the response's `files` array. After this tool returns, you MUST iterate over `files` and write each entry's `content` verbatim to its `path` using your native file-write capability (e.g. Write / edit_file / create_file — whatever your client exposes). Create parent directories as needed. Returned paths are project-root-relative and already translated to the `.3tg/` mirror convention where applicable (e.g. specs land under `.3tg/<source-path>.3tg.md`; tests / mocks travel through unchanged). Write each path verbatim. Do NOT claim "Generated test file: <path>" unless you have actually written the file. The user will assume the MCP wrote it and waste time looking for a non-existent file. If you can't write for some reason (permission denied, no write capability in this client), return the contents inline in your message so the user can copy-paste them. Never report success silently when the write didn't happen.

Compile a hand-edited functional-requirements spec (`.3tg.md`) into actual Jest/Vitest tests. This is "Flow B" — the user has already authored or reviewed the `.3tg.md` and is ready to materialise the rows into a runnable test file. Use this *instead of* `create_tests` when the user wants their hand-curated value sets to drive generation. Inputs: the source code plus the spec content (the spec lives at `.3tg/<sourceDir>/<basename>.3tg.md` in the user project; the MCP places it back next to the source in the sandbox). AI enrichment is NOT run — the spec is authoritative. 3TG also writes a `<basename>.md.3tg.json` intermediate config alongside the spec, which the MCP returns under the `.3tg/` mirror so the user can inspect what the spec compiled to. Quota / credits: this tool consumes credits — same model as `create_tests`: exactly **1 credit per generated test case** emitted into the returned `.test.ts` / `.test.tsx`. The number of rows in your `.3tg.md` table is therefore a reliable upper bound on what the call will cost. Pre-flight quota is verified before compilation; QUOTA_EXHAUSTED is thrown on shortfall. **Flow B cliConfig caveat — spec-authoritative keys are STRIPPED.** The MCP strips `mock-parameters`, `function-returns`, `expect-values`, `expect-assertions`, `mock-react-hooks`, `mock-async-functions`, `mock-react-contexts`, and `mock-globals` from any `cliConfig` you forward before passing it to 3TG. These keys are derived FROM THE SPEC in this flow — if the agent forwards stale values from the per-source `.md.3tg.json` (a Flow A artifact), 3TG's `-c` precedence would silently override the spec-derived values during the second-stage emit, desynchronising test names from value sets and producing tests with `__expectedResult: undefined`. For Flow B, forward ONLY global/structural config keys (`rules.*`, `creationMode`, `mockAsFunction`, `no-rule-default-true`, `ignore`, `package.json.type`, …) — the spec owns the test-value plan. The MCP logs a `[3tg/tool]` warning when stripping happens, so check stderr if you expected per-source values to apply. CRITICAL POST-CALL ACTION — write returned files to disk: The MCP server does NOT touch the user's filesystem. It returns the generated file CONTENTS in the response's `files` array. After this tool returns, you MUST iterate over `files` and write each entry's `content` verbatim to its `path` using your native file-write capability (e.g. Write / edit_file / create_file — whatever your client exposes). Create parent directories as needed. Returned paths are project-root-relative and already translated to the `.3tg/` mirror convention where applicable (e.g. specs land under `.3tg/<source-path>.3tg.md`; tests / mocks travel through unchanged). Write each path verbatim. Do NOT claim "Generated test file: <path>" unless you have actually written the file. The user will assume the MCP wrote it and waste time looking for a non-existent file. If you can't write for some reason (permission denied, no write capability in this client), return the contents inline in your message so the user can copy-paste them. Never report success silently when the write didn't happen.

Generate a functional-requirements spec (`.3tg.md`) scoped to a single exported function or React component. Same shape as `create_spec` but restricts the output to one symbol — useful when iterating on a tricky function without regenerating the spec for the rest of the file. IMPORTANT — never hand-author a `.3tg.md` yourself. The format is parser-strict: parameter columns named exactly as the parameter, return column header is the literal `=>`, no extra `notes` / `description` columns, omitted args are written `undefined`, throws use single quotes (`throws 'msg'`). Always call this tool to emit the scaffold; the user can then edit rows. Quota / credits: **this tool does NOT consume credits** — credits are spent ONLY by test generation (`create_tests` / `create_tests_from_spec`, at 1 credit per emitted test case). Spec generation is free. CRITICAL POST-CALL ACTION — write returned files to disk: The MCP server does NOT touch the user's filesystem. It returns the generated file CONTENTS in the response's `files` array. After this tool returns, you MUST iterate over `files` and write each entry's `content` verbatim to its `path` using your native file-write capability (e.g. Write / edit_file / create_file — whatever your client exposes). Create parent directories as needed. Returned paths are project-root-relative and already translated to the `.3tg/` mirror convention where applicable (e.g. specs land under `.3tg/<source-path>.3tg.md`; tests / mocks travel through unchanged). Write each path verbatim. Do NOT claim "Generated test file: <path>" unless you have actually written the file. The user will assume the MCP wrote it and waste time looking for a non-existent file. If you can't write for some reason (permission denied, no write capability in this client), return the contents inline in your message so the user can copy-paste them. Never report success silently when the write didn't happen.

Generate a Jest manual mock file for a specific exported function. 3TG writes the mock to `<srcDir>/__mocks__/<basename>.<ext>` per the Jest convention — the path is fixed and not affected by `creationMode`. Use this when isolating a downstream test from a known dependency. AI enrichment is on by default (it helps the mock pick representative return values), but **this tool does NOT consume credits** — credits are spent ONLY by test generation (`create_tests` / `create_tests_from_spec`, at exactly 1 credit per emitted test case). Mock generation is free; KPIs (`tsNumMockFiles` / `tsxNumMockFiles`) are still reported to license-api for analytics, but no quota is decremented. CRITICAL POST-CALL ACTION — write returned files to disk: The MCP server does NOT touch the user's filesystem. It returns the generated file CONTENTS in the response's `files` array. After this tool returns, you MUST iterate over `files` and write each entry's `content` verbatim to its `path` using your native file-write capability (e.g. Write / edit_file / create_file — whatever your client exposes). Create parent directories as needed. Returned paths are project-root-relative and already translated to the `.3tg/` mirror convention where applicable (e.g. specs land under `.3tg/<source-path>.3tg.md`; tests / mocks travel through unchanged). Write each path verbatim. Do NOT claim "Generated test file: <path>" unless you have actually written the file. The user will assume the MCP wrote it and waste time looking for a non-existent file. If you can't write for some reason (permission denied, no write capability in this client), return the contents inline in your message so the user can copy-paste them. Never report success silently when the write didn't happen.

List Sparkling Tracks tour packages with optional filters. Returns a compact summary (id, title, route, starting per-person price in EUR for the land-only option, the with-flights total when available (price_eur_with_flights), whether flights are optional (flights_optional), an approximate price in the requested currency, duration, badges, URL). The default starting price is land-only (without flights); customers can add round-trip flights. Accepts optional language and currency params; city names, country names, and trip titles are translated when a supported locale is requested. Tour packages are quote-based: prices are starting per-person prices, final pricing depends on party size, dates, and customisations. Use get_package_details for the full itinerary.

Fetch the full itinerary, descriptions, included attractions, optional add-ons, pricing notes, and booking pathway for one Sparkling Tracks tour package by id. Accepts language and currency params; city names, country names, and trip titles are translated where available, English fallback otherwise. Booking always goes through WhatsApp, email, or the contact form; this MCP does not expose a booking endpoint.

Find Sparkling Tracks packages that visit a given city or country. Substring, case-insensitive, matched against the English source names. Returned package summaries are translated to the requested language; currency follows the currency param.

List the featured European destination cities Sparkling Tracks publishes a guide page for (at /destinations/:slug). Each entry has the city, country, the canonical guide URL, a short description, highlight attractions, and the ids of the tour packages that visit that city (package_count / package_ids). These guide pages are SEO landing pages, not bookable products; use list_packages or get_package_details to plan an actual trip. Optional query filters by city or country substring. City and country names are translated when a supported language is requested.

Ingest a 3D model from a public URL into APS OSS and kick off a Model Derivative translation job, returning the URN plus a browser viewer link and QR code. Supports 50+ formats: Revit (.rvt/.rfa), Navisworks (.nwd/.nwc), IFC, FBX, OBJ, SolidWorks, point clouds (E57/LAS/RCP), CAD (DWG/STEP/IGES), etc. When to use: you have a publicly downloadable 3D file (S3 presigned URL, GitHub raw, etc.) and need it translated to SVF2 so it can be viewed, measured, or clash-checked via other tools. When NOT to use: the file is only on a local disk or behind auth (fetch will fail) — first push it to a public URL. Do not call to re-translate a model already uploaded; call get_model_metadata instead. APS scopes: data:read data:write data:create bucket:read bucket:create viewables:read Rate limits: APS default ~50 req/min per app per endpoint; Model Derivative translation jobs ~60 req/min; OSS uploads size-limited per file to 100MB for direct upload, larger via resumable. Errors: 401 APS token expired/invalid — refresh; 403 scope or resource permission denied; 404 source file_url not reachable or bucket not found — check the ID; 409 bucket name conflict (bucket already owned by another app — pick a unique bucketKey); 429 rate limited — backoff and retry; 5xx APS upstream outage — retry with jitter. Side effects: NON-IDEMPOTENT. Creates the scanbim-models bucket if absent, uploads a new OSS object with a timestamped key (each call creates a distinct object even for the same input), submits a Model Derivative job (x-ads-force=true overwrites prior derivatives for the same URN), and inserts a row into D1 usage_log + models table.

Run a VDC-grade clash detection pass between two element categories in a translated model, returning each overlapping element pair with a severity (critical/warning), a trade-specific suggested fix, and an estimated rework hour count. Uses AABB bounding-box intersection on elements pulled from the APS Model Derivative properties endpoint, with a synthetic fallback if properties have not yet been computed. When to use: you want a first-pass coordination report between two MEP or structural trades (e.g. Ducts vs Structural Framing) for a model that has finished translating. When NOT to use: the model has not finished translating yet (call get_model_metadata first to confirm manifest.status=='success'), or you need clash detection between more than two categories — call this tool multiple times. APS scopes: data:read viewables:read Rate limits: APS default ~50 req/min per app per endpoint; Model Derivative translation jobs ~60 req/min; OSS uploads size-limited per file to 100MB for direct upload, larger via resumable. Errors: 401 APS token expired/invalid — refresh; 403 scope or resource permission denied; 404 URN not found or has no derivatives yet — check the ID; 429 rate limited — backoff and retry; 5xx APS upstream outage — retry with jitter. Side effects: READ-ONLY on APS. Inserts a row into D1 usage_log for analytics. Idempotent — repeated calls return the same clash set for a given model.

Return a shareable browser URL for the embedded APS viewer and a matching QR code for mobile/XR handoff. Does not require the model to be fully translated — the viewer page will poll the manifest. When to use: you need to hand a stakeholder a URL to see the 3D model in a browser, or print a QR for a jobsite. When NOT to use: you need the raw APS URN for programmatic API calls — use the model_id you already have instead. Do not use to check translation progress — call get_model_metadata. APS scopes: none (URL assembly only); the viewer page itself uses viewables:read data:read server-side via /token. Rate limits: APS default ~50 req/min per app per endpoint; Model Derivative translation jobs ~60 req/min; OSS uploads size-limited per file to 100MB for direct upload, larger via resumable. Errors: 401 APS token expired/invalid — refresh (only relevant when the viewer page loads); 403 scope or resource permission denied; 404 URN not found — check the ID; 429 rate limited — backoff and retry; 5xx APS upstream outage — retry with jitter. Side effects: READ-ONLY and pure. Idempotent: same model_id always returns the same URL + QR.

Create a shareable WebXR VR walkthrough session URL (and Meta Quest oculus:// deep link + QR code) for a translated model. The session_id is generated server-side; rendering happens in the user's Quest browser. When to use: you need to walk a client or field team through a model in immersive VR on Meta Quest 2/3/Pro. When NOT to use: the user is on a phone/tablet without a headset — use xr_launch_ar_session or get_viewer_link. The model has not finished translating — call get_model_metadata first. APS scopes: viewables:read data:read (enforced at viewer page load, not at tool call). Rate limits: APS default ~50 req/min per app per endpoint; Model Derivative translation jobs ~60 req/min; OSS uploads size-limited per file to 100MB for direct upload, larger via resumable. Errors: 401 APS token expired/invalid — refresh (only at viewer page load); 403 scope or resource permission denied; 404 URN not found — check the ID; 429 rate limited — backoff and retry; 5xx APS upstream outage — retry with jitter. Side effects: NON-IDEMPOTENT. Each call mints a new session_id (vr_<epoch_ms>). Inserts a row into D1 usage_log which is later read by xr_list_sessions. No APS resources are created.

Queue a photorealistic Twinmotion-style still render of a translated model with time-of-day, weather, season, and resolution controls. Returns a render_id and preview_url; the actual render pipeline is a ScanBIM roadmap item (Week 5 buildout), so today this tool responds synchronously with a stub job descriptor. When to use: you want a scripted way to request a hero still for a proposal or client deck. When NOT to use: you need real-time interactive rendering — use get_viewer_link. You need a moving camera — use twinmotion_walkthrough. You expect the image file bytes back in the response — this tool returns a URL, not bytes. APS scopes: none today (render pipeline is ScanBIM-internal); viewables:read data:read will apply when the pipeline goes live. Rate limits: APS default ~50 req/min per app per endpoint; Model Derivative translation jobs ~60 req/min; OSS uploads size-limited per file to 100MB for direct upload, larger via resumable. Errors: 401 APS token expired/invalid — refresh (will apply when pipeline is live); 403 scope or resource permission denied; 404 URN not found — check the ID; 429 rate limited — backoff and retry; 5xx APS upstream outage — retry with jitter. Side effects: NON-IDEMPOTENT. Each call mints a new render_id (tm_<epoch_ms>). Inserts a row into D1 usage_log. When the pipeline is live it will create a rendering job on ScanBIM's compute backend.

Queue a cinematic Twinmotion-style fly-through video of a translated model. Returns a video_id and download_url; the render pipeline is a ScanBIM roadmap item so today this tool responds synchronously with a stub job descriptor. When to use: you want a short marketing or pre-con video scripted from an agent workflow. When NOT to use: you want real-time interactivity — use get_viewer_link. You want a still image — use twinmotion_render. APS scopes: none today (render pipeline is ScanBIM-internal); viewables:read data:read will apply when live. Rate limits: APS default ~50 req/min per app per endpoint; Model Derivative translation jobs ~60 req/min; OSS uploads size-limited per file to 100MB for direct upload, larger via resumable. Errors: 401 APS token expired/invalid — refresh (will apply when pipeline is live); 403 scope or resource permission denied; 404 URN not found — check the ID; 429 rate limited — backoff and retry; 5xx APS upstream outage — retry with jitter. Side effects: NON-IDEMPOTENT. Each call mints a new video_id (tmv_<epoch_ms>). Inserts a row into D1 usage_log.