AhaSlides

Convert legacy content slides into NEW `content-v2` slides. Accepts the legacy static types: `content` (free-form canvas), heading (`textSlide`) and list (`bulletPoints`). Each source slide gets a new `content-v2` slide inserted directly after it, with layout, text styling, images, shapes and the slide theme (colours, background image) carried over. Source slides are never modified or deleted; delete them with `update_slide_properties` afterwards if the user wants only the new versions. Prefer this over re-creating the slide with `create_slides` when the user wants an existing slide upgraded to Content V2. Args: presentation_id: The presentation the slides belong to. slide_ids: Slide ids to convert, in order (at most 50 per call; the rest come back as `batch_limit_exceeded`). Interactive slides are rejected per slide with code `unsupported_slide_type`; an empty slide with `empty_slide`; a wrong id with `slide_not_found`. Returns: {"success": bool, "message": str, "data": {"converted": [{source_slide_id, new_slide_id, source_type, blocks_in, blocks_out, warnings: [{code, message, block_id}]}], "failed": [{slide_id, code, message}]}} `success` is true when at least one slide converted; `warnings` lists lossy steps such as `mark_dropped` or `theme_copy_failed`.

AhaSlides eLearning tool. Create a new, empty DRAFT course; returns JSON with its ``id``. Then add lessons with ``create_lesson`` and fill them with ``add_lesson_pages`` / ``add_lesson_blocks``. The result includes ``editor_url``, the link to the course editor: share it as-is, never build one.

Create a folder to organise presentations. Args: folder_name: Name of the new folder. parent_folder_id: (Optional) Nest under this folder. Returns: Dict with the created folder.

AhaSlides eLearning tool. Add an EMPTY lesson at the end of a course — one blank page, no content — as the course editor's "Add lesson" does. Fill it with ``add_lesson_blocks`` on the returned ``page_id``. Returns JSON: ``{"lesson_id", "title", "page_id"}``. On ``partial_create`` the lesson exists without its page: ``add_lesson_page`` on ``details.lesson_id``, never create it again. The result includes ``editor_url``, the link to the lesson editor: share it as-is, never build one.

Create a new AhaSlides presentation. Creates an empty presentation with the given name. After creating, use create_slides to add slides to it. Args: name: Name of the presentation to create (e.g. "Q3 Team Review"). lang: Language code for the presentation (optional, e.g. "en", "vi", "ja"). Returns: Dict with success status and presentation data including the new presentation ID, plus editor_url — the link to open the presentation in the AhaSlides editor. Share editor_url with the user.

Save a personal skill: a plain-text instruction. Limits: title at most 80 characters, body at most 4000, description at most 200; applies_to any of presentation, survey, course. folder_id: a My files folder; none = root.

Create slides in a presentation. Slide types are registered dynamically: `list_slide_types` names them and `load_slide_type_specs` gives each type's fields. Each dict needs a 'slide_type' plus that type's fields. Before building or restructuring a deck (two or more new slides), call `load_authoring_guide` once — it holds the routing, density, interactivity and theme rules this tool relies on. Static slides: prefer `content-v2` (its `layouts` skill holds the templates; `grammar` only when no layout fits; `creative` only for effects beyond the layouts' built-in reveals) over the legacy `content` / `listing` types, which are a fallback only when content-v2 is absent. Diagrams, word clouds: its `26-diagram`; charts: `27-chart`; `diagram` only for swimlanes or edits. Act on any "Design check" lines ("new slide N": Nth of this call; runs checked per call). AhaSlides is interactive: unless the user asks for static-only, weave in polls, quizzes, word clouds, scales and Q&A — about 40% of a deck. Images: `search_images` or bring your own, rehost with `upload_image`, and reference the returned URL. Never hot-link a foreign image URL. Every slide dict accepts an optional `notes` (speaker notes) string. Positioning: insert_after_slide_id places slides after that ID; omitting it appends. Each call inserts at a single position. The 'order' field is not accepted — ordering is derived server-side. Args: slides: List of dicts with 'slide_type' and the type's fields, per `load_slide_type_specs`. presentation_id: Target presentation ID. insert_after_slide_id: (Optional) Slide ID to insert after. Returns: Dict with created slides including IDs. On a brand-new presentation the empty placeholder poll it starts with is removed after the create, and the message says so.

Create a new survey with one empty page ready for questions. Args: title: Title of the survey. Returns: Dict with the new survey's `id` (use it for all later calls), `section_id`, the first page's id, and `editor_url`, the link to the survey editor: share it as-is, never build one.

Delete a folder. This is a soft delete — its presentations move to trash and can be recovered. Args: folder_id: ID of the folder to delete.

AhaSlides eLearning tool. Delete one lesson of a course with all its pages and blocks. Not undoable: confirm with the user first. ``lesson_id`` must be a lesson of THIS course, top-level or inside a module (``get_course_tree``); only the lesson is deleted, never its module or the course. Returns JSON: ``{"id", "deleted"}``.

AhaSlides eLearning tool. Delete a content block from a lesson. Also deletes a PAGE with everything on it (``delete_lesson_page`` is the typed form), never the lesson's last page nor the lesson itself (``delete_lesson``). Not undoable. Returns JSON: ``{"id", "deleted"}``.

AhaSlides eLearning tool. Delete one page of a lesson AND every block on it. Not undoable: confirm with the user first. A lesson always keeps at least one page, so its last page is refused (``last_page``) — delete its blocks instead. Returns JSON: ``{"id", "deleted"}``.

Delete one or more presentations. This is a soft delete — they move to trash and can be restored with `recover_presentations`. Args: presentation_ids: IDs of the presentations to delete.

Delete one of your own skills. Recoverable from trash.

Delete an element/question from a survey. Args: survey_id: ID of the survey. element_id: ID of the element to delete.

Delete a section from a survey. Args: survey_id: ID of the survey. section_id: ID of the section to delete.

Duplicate a presentation. The copy's name is suffixed automatically. Args: presentation_id: ID of the presentation to copy. Returns: Dict with the new presentation, including `editor_url` — the link to open the copy in the AhaSlides editor. Share it with the user.

AhaSlides eLearning tool. Read an existing course's lessons. Call this before adding another lesson, or whenever you need a lesson's id to pass to the lesson tools (``get_lesson_tree``, ``add_lesson_block``, ...). Returns JSON: ``{"course_id", "title", "lessons": [{"id", "title", "module_id"}], "modules": [{"id", "title", "lesson_ids"}]}``. ``lessons`` is one flat list in course order, including lessons inside modules; ``module_id`` is null for a top-level lesson. The course and each lesson carry ``editor_url``, the link to the course or lesson editor: share it as-is, never build one.

AhaSlides eLearning tool. Read an existing lesson's pages and content blocks, in on-page order. Call it BEFORE modifying a lesson: ``update_lesson_block`` replaces content wholesale, so you need the block's full current ``content``. Do not call it after a write to confirm — every write returns what it stored. Returns JSON: ``{"lesson_id", "title", "pages": [{"id", "title", "blocks": [{"id", "type", "variant", "content"}]}]}``. ``variant`` is the block's layout (``""`` if never set), the value ``add_lesson_block`` accepts.

Get complete presentation detail including all slides, theme, and active slide. Returns comprehensive information about a presentation: - presentation_name: The presentation's title - slides_overview: Compact list of all slides with type, title, ID, and key settings - slides_detailed: Full markdown breakdown of each slide's content and configuration - slides_with_id_and_order: ID and order for each slide (useful for positioning operations) - theme_id / theme_name: Current theme applied to the presentation - current_active_slide_id: Which slide is currently active in a live session - editor_url: Link to open the presentation in the AhaSlides editor — share this with the user Provides the presentation structure typically needed before making changes. Args: presentation_id: ID of the presentation to fetch. include_media: Also return slide image and YouTube URLs. Returns: Dict with presentation detail, slides overview, and theme information.

Read a presentation's settings (read-only): API key, value, and the label users see. Take this snapshot before changing any setting, so you can restore the old value. Match what the user says to the label, then use the key. Today the only setting you can change is isModerationMode, via update_presentation_settings. Requires permission to present. Args: presentation_id: ID of the presentation. Returns: settings, a list of {key, label, value[, meaning]}.

Read one skill with its text. skill_id from list_skills.

Read the built-in skill (any role) with this intent: {"skill": <as get_skill>}, or {"skill": null}.

Read a survey's full structure (sections + elements with their ids). Args: survey_id: ID of the survey. Returns: The survey plus `editor_url`, the link to the survey editor: share it as-is, never build one.

Get a response/results summary for a survey. Args: survey_id: ID of the survey.

Get all available themes (official, custom, and team-shared). Returns three categories of themes: - official_themes: Built-in themes available to all users - custom_themes: Themes created by the current user - shared_themes: Themes shared by team members Each theme includes: - id: Theme ID (use this with update_presentation_theme) - themeName: Display name of the theme - textColour: Text color hex code - baseColour: Background color hex code The theme `id` returned here is what `update_presentation_theme` accepts to apply a theme to a presentation. Returns: Dict with official_themes, custom_themes, and shared_themes lists.

Mint the share link for an insight, and get back a URL you can hand over. Idempotent: publishing an already-published insight returns the same link rather than minting a second one, so a token cannot be orphaned by calling this twice. The link needs no login — the token IS the permission — and it re-runs the pinned queries each time it is opened, so the numbers stay current. Say that to the user before sharing it. Writing never publishes -- there is no flag for it, and no `publishError` to retry: this tool is the only way an insight becomes shareable. Call it when the person asks to share, send, or get a link -- not because an insight is finished and a link seems tidy. Args: report: reportId of the insight to publish.

Validate, scope and PIN SELECTs to an insight. Returns ids, never rows. THE QUERY IS THE FINDING. You never see the rows — a pinned query is re-run when someone opens the insight, so a value read into prose is true today and wrong after the next session. Put the finding IN the SQL (ORDER BY, LIMIT, a computed rate) and let a stat, chart or table block recompute it. One query per thing shown. Send EVERY query the insight needs in one call. Each is validated on its own, so a mistake costs one query rather than the batch: the result lists what pinned and names each casualty with its reason in `failed`. Call `insight_schema` first. A rejection here names the valid alternatives — read it and retry rather than guessing a column. STATE: the result carries the `reportId` every query landed on. Hold it and pass it back as `report` on later calls — this server remembers nothing between calls; the insight lives in the report service, keyed to you. Args: queries: A LIST of {"sql": "...", "label": "..."}. report: (Optional) EITHER a reportId from an earlier call, to pin onto that insight, OR — on a first call, when you have no id yet — a short key unique to this piece of work, such as "q3-course-review-2026-09-25". Upstream tells them apart by shape: a UUID is an id, anything else is an idempotency key, and the same key always resolves to the same insight — reusing a key from earlier work returns that earlier insight. Passing a key on the FIRST call is what makes that call safe to retry; omitting `report` entirely mints a new insight every time, so a timeout there cannot be retried without risking a duplicate you have no id to find.

The warehouse tables an insight can query, and how much data you own. START HERE, with NO argument. The result's `scope` says what the caller actually has, per dataset — presentations, and courses/lessons. A count of ZERO is not an obstacle to route around: it IS the answer to every question about that dataset, and this is the only place you can learn it, because a pinned query never returns rows to you. Report the zero rather than presenting it as a finding about activity. `table` takes SEVERAL table names, comma-separated ("fact_answers2,dim_questions,dim_sessions"), and returns their columns and gotchas. Ask for every table the insight touches in ONE call — a round trip is the expensive unit here. The result also carries the accepted `reportTheme` keys for `insight_write`. Read them from here rather than remembering them: they are generated from the validator's own key set, so they cannot drift from what is actually accepted. This REPLACES the deprecated `query_user_data` / `query_presentation_data` tools, which see presentation data only and cannot produce a shareable result. Args: table: (Optional) Comma-separated table names to describe. Omit for the table list plus your scope.

Create or edit an insight and write its body. Pinned queries are untouched. Omit `report` to create one (needs `title`); pass a reportId to edit. Only the fields you pass change. Charts and tables render FROM THE PINNED QUERY — reference a queryId from `insight_query`, never paste values into the body. Everything is validated before anything is stored, and the result's `stored` counts what landed by block and chart type: that is your confirmation it validated. blocks = {"version": 1, "blocks": [...]}, each one of: {"type":"heading","text":"...","level":2} {"type":"text","md":"Markdown. Inline HTML is not rendered."} {"type":"divider"} {"type":"image","src":"https://...","alt":"...","width":160,"align":"left"} {"type":"stat","query":"q_","column":"col","label":"...","row":0} {"type":"chart","query":"q_","chart":"bar","x":"col","y":["col"],"title":null,"limit":50} {"type":"table","query":"q_","columns":["a","b"],"limit":50} {"type":"row","columns":[{"width":3,"blocks":[...]},{"width":9,"blocks":[...]}]} {"type":"tabs","tabs":[{"label":"Overview","blocks":[...]}]} chart: bar hbar line area pie donut scatter row: 2-4 columns. `width` is a span of a 12-column grid; set one on every column totalling 12, or on none for equal. A tab may hold rows; a row may not hold tabs. Args: report: (Optional) A reportId to edit. An ID ONLY — unlike `insight_query`, this takes no idempotency key: anything that is not a UUID is rejected as not a valid id. Omit to create a new insight (needs `title`), which mints a fresh one every call and so cannot be safely repeated after a timeout. The usual flow avoids that anyway: pin a query first, then write the body with the reportId that comes back. title: Names the insight. Required when creating. blocks: The body, in the shape above. theme: (Optional) Colours and font. `insight_schema` returns the accepted keys under `reportTheme`; keys that did not apply come back as `themeIgnored`. This does NOT share. `url` comes back only when the insight already has a link; none is created here. Use `insight_publish`, and only when the person asks — the link needs no login, so anyone holding it sees the data.

List the people a presentation or folder is shared with. For surveys use `list_survey_collaborators`. Args: target_type: "presentation" or "folder". target_id: ID of that presentation or folder.

AhaSlides eLearning tool. List the people a course is shared with: each one's ``user_id``, ``email``, name, ``role`` (owner/editor/viewer) and ``is_owner``. Use the ``user_id`` with ``update_course_collaborator_role`` or ``remove_course_collaborator``.

AhaSlides eLearning tool. List the caller's COURSES (id, title, draft/published), newest first. Not lesson ids — those come from ``list_lessons``. ``status="published"`` narrows to courses learners can already open. Returns JSON with ``items`` and ``next_cursor``. Each course carries ``editor_url``, the link to the course editor: share it as-is, never build one.

List the user's folders as a full nested tree, or search them by name. Args: query: (Optional) Text to search for in folder names. Omit for the tree.

AhaSlides eLearning tool. The full ``aha.*`` block-type catalogue: each type's purpose, content shape, layout variants, ``interactive``/``scored``/``tracksCompletion`` capabilities, and whether it is ``agentAuthorable`` (if not, ``unauthorableReason`` says why — usually a media URL or presentation). Call it while PLANNING a lesson, before writing blocks. Returns JSON: ``[{"type", "label", "summary", "agentAuthorable", "unauthorableReason"?, "contentShape", "variants", "capabilities"}]``.

AhaSlides eLearning tool. List the caller's LESSONS (id, title, draft/published status): where a ``lesson_id`` for ``get_lesson_tree``, ``add_lesson_page``, ``add_lesson_block`` and the other lesson tools comes from. Returns JSON with ``items`` and ``next_cursor``.

List or search the user's presentations (paginated). Args: text_search: (Optional) Filter by title/metadata text. limit: Page size (default 20). page: 1-based page number. Returns: Dict with the matching presentations.

Read a presentation's audience Q&A questions live, as they arrive. Use this to help a presenter moderate Q&A during a session: group questions by topic, spot duplicates, and suggest which to answer next. Data is live (a few seconds old at most) — unlike query_presentation_data, which reads the warehouse and has no Q&A. Polling: the first call (no `after_id`) lists every question. Pass the returned `next_after_id` on the next call to list only questions that arrived since. If `truncated` is true, call again with `next_after_id` to page through the rest. `counts` and `top_open` always cover the whole Q&A, so the current ranking is in every response. A listed question's votes, answered or dismissed state can change later — call without `after_id` to refresh everything. Each question has: id, text, votes, answered, pinned, status ('approved' | 'pending' | 'dismissed' — 'pending' only exists when `moderation_on` is true and means the audience can't see it yet), author, created_at. Requires permission to present the presentation. Args: presentation_id: The presentation being presented (the id in its editor URL). after_id: (Optional) A previous call's `next_after_id`. include_answered: (Optional) List questions marked answered. Default true. include_dismissed: (Optional) List dismissed questions. Default false. limit: (Optional) Max questions listed per call, oldest first. Default 200, max 500. Returns: Dict with moderation_on, counts, top_open (up to 10 unanswered questions, pinned first, then by votes), questions, truncated and next_after_id.

List your skills and the built-in recipes. Returns titles and descriptions only; call get_skill for the text.

List every available slide type with a one-line description. Covers plugin types that are registered dynamically and so are not enumerated in this server's static docstrings. The full schema for a given type is available from `load_slide_type_specs`. Returns: markdown bullet list of `slide_type: short description`.