Praktikal

Create a new slideshow over an existing lecture. Requires the lecture contains worksheet nodes. The slideshow starts in the WAITING lobby — call OPEN_SLIDESHOW to get its URL; the owner then clicks Start Presentation in the lobby to go live.

create_slideshow

Create a one-time local-file upload URL. Choose target.kind image for a picture or file for a document or 3D model. Run the returned upload_command to transfer the bytes. Images may be staged without a destination; files require a title for a new node or node_id to replace an existing attachment. Replacement overwrites the current image or attachment. Uploads require a client that can execute shell commands.

create_upload

Delete a set. Only the set itself goes: it holds content by reference, so nothing that was in it is touched and nothing is lost from the repository. Anyone the set was shared with loses the collection, not the material. Deleting is also how an account over its plan allowance gets back under it, so it stays available even when the set cannot otherwise be edited.

delete_set

Describe the creation, update, native explanation, and answer-key contract for one node type. Call this before CREATE_NODE for any type whose fields you are not certain of: `creation_schema` lists exactly the fields that type accepts, and create_node refuses fields it does not name. Also authoritative for READ_NODE.authoring and UPDATE_NODE.authoring_patch.

describe_node_type

Detach specified instruments from a node or remove one member from a kit. Choose target.kind node or kit. Other attachments and the instrument or nested kit itself survive.

detach_instruments

Detach a node from one parent, removing it from that place in the tree. This does NOT delete the node: it stays in the repository and keeps every other parent it had, so a node used in several lessons is only removed from the one you name. The response reports the parents that remain and whether the node is now unattached. To re-place a detached node, use INSERT_NODE; to move it to a different parent in one step, use MOVE_NODE.

detach_node

Load the `canvas-authoring` skill with read_skill before your first call — this takes a Praktikal canvas document, which is not Excalidraw, tldraw or any other format you may know, and a document in the wrong shape is refused whole. Draw or edit a native canvas atomically using stable element IDs. This is how a canvas node gets its content: create the node empty with create_node, then send the whole `document` here with base_revision null. The skill carries the document envelope, the node kinds (shape/path/text/image/group/connector/instance) and their properties, and the layout rules; a document that misses a required field is refused whole. Afterwards read_canvas and send `operations` instead, passing the revision it returned as base_revision, and a unique request_id reused only for an exact retry. Operations: set/remove/insert/move/replace-text/style-text (UTF-16 text offsets), create-component/insert-instance/update-component/remove-component/override-instance/reset-instance/detach-instance. Nested component definitions live in document.components; override keys identify source nodes in the resolved definition. Cycles are rejected. Detaching preserves nested child instances. The server renders the SVG preview from the document — the node takes no image of its own. For a hand-drawn look the skill covers `roughness`, `fillStyle`, `connection.roughness`, the handwriting font `Excalifont` and tapered `freehand` pencil paths. No changes commit if validation or rendering fails.

edit_canvas

Make targeted edits to an existing htmlArtifact node without resending the whole document. Each edit replaces an exact substring of the current HTML. Read the node first (read_node, mode "full") to get the current HTML, then pass small, surgical edits. Rules for each edit: • old_string must match the current HTML EXACTLY — including whitespace and indentation — and must be unique unless replace_all is true. • Include a few surrounding lines/characters so old_string is unambiguous. • new_string must obey the same authoring constraints as the original artifact (self-contained, allowlisted CDNs only, no network calls). Edits apply in order; if any old_string is missing or non-unique the whole call fails and nothing is changed. For a full rewrite, use update_node with the complete html in `content` instead.

edit_html_artifact

Compose a slide without rewriting it: layout, background, heading, decorative shapes, and where and how each element on it is drawn. Read it with read_slide first and pass its revision as base_revision; a stale revision is refused. Operations apply in order and are all checked before anything is written. In every operation an omitted field is left as it is and null clears it. - set_layout: single, two-column, main-sidebar, three-column, two-row, grid-2x2, or free (every element has its own box). Switching keeps the arrangement. - set_background: color, image_reference or image_url (replaces the picture), remove_image. - set_heading: rect and color (free slides), align, size. The heading text is changed with update_node. - set_element node_id: area (divided slides, as read_slide lists them) or rect (free slides); align and valign (free) start|center|end; show_title; text_size and line_spacing on text, formula, table and callout (idea, concept, warning, instructions) elements, text_fit (free) on text only; background, background_opacity, opacity; border_width, border_color, border_radius, padding; button {label, size, color} to open the element from a button (free; {} for defaults); participant true to move it to the participants' own screen in a live session. - order_element node_id before_node_id (null = last); later elements draw on top. - set_shape: without id adds a shape (type rectangle|circle|vertical-line|horizontal-line and rect required); with id changes one. z, fill_color, border_color, border_width, border_style, border_radius, opacity. remove_shape id. Units: a rect is {x, y, w, h} in percent of the slide area inside its padding, w and h at least 5. Sizes, borders, radii and padding are pixels of the 1920×1080 slide: text 12–240 (default 32, heading 64), border up to 40, radius and padding up to 200. line_spacing 0.8–3, opacities 0–1. Out-of-range values are clamped. Colours are CSS: "#fefceb", "rgb(254 252 235)" or a keyword. Elements are added with insert_node and removed with detach_node; their content and view are changed with update_node. Load the `slide-composition` skill with read_skill for layout choice and projector readability.

edit_slide

Change individual cells of a table, or add and remove its rows and columns, without rewriting the whole table. Read it with read_table first and pass the revision it returned as base_revision; an edit against a stale revision is refused rather than written into the wrong cell. Operations apply in order: set_cell (text, alignment, header cell, picture), insert_row, remove_row, insert_column, remove_column. A cell picture is a child image node of the table: set_cell takes image_reference or image_url to add one, image_node_id to show a picture the table already holds in another cell as well, and image_node_id null to clear the cell. A picture no cell shows any more is removed from the table. Prefer this over update_node for an existing table — update_node replaces the whole content and strands every picture the markup stops naming.

edit_table

Return the extras container for a node, creating it if absent. Use its container_id as the parent for supplementary materials. Repeated calls reuse the container.

ensure_extras_container

Use this when ChatGPT needs the full text for one accessible Praktikal search result by id. Returns a citation URL and compact document metadata.

fetch

Copy an E-Koolikott material into the teacher's own Praktikal repository. Activities are converted into native Praktikal nodes where they can be — questions, text, media — and anything that will not convert is kept as a working embed, so a copy never lands broken. The source licence and authors are recorded as credit on what it creates. Read the material first if the teacher wants only part of it: pass the `part_id`s they do not want as `skip_parts`. The copy is additive: it creates new nodes and changes nothing that was already there. Every root it created comes back in `root_node_ids`. A copy made with `into_node_id` can be taken back out with detach_node; one that built its own artifact is a top-level node, which no tool removes — the teacher deletes it in Praktikal if they do not want it.

import_ekoolikott_material

Insert an inline computed-value atom by appending it or replacing exact anchor text in a node. Read the node in full mode first and reuse exact formula_reference strings.

insert_inline_computed_value

Place an EXISTING node; CREATE_NODE creates new content. `reference` shares edits across placements; `copy` makes an independent duplicate. Omitted mode references same-owner nodes and copies others, subject to licence. Use copy for localization/adaptation. relationship="explanation" attaches a container tree as a native worked solution; clear any existing explanation. References need source write access and matching ownership; copies need copy permission.

insert_node

List the curricula (national or school teaching frameworks) this account can read: the ones it owns, the ones it maintains — including unpublished drafts — and every published curriculum. Start here to get a curriculum id, then use read_curriculum_tree to explore its structure or search_curriculum_positions to jump straight to a subject or topic.

list_curricula

List slideshows owned by the current user. Returns id, title, status, and creation timestamp (up to 50 by default). Use this to find an existing slideshow to launch or reference.

list_my_slideshows

List the reusable assistant skills available in this session. Skills are saved, expert playbooks for recurring teaching tasks. Returns metadata only (id, name, description, audience), not the skill body. Before doing relevant work, scan this list and call read_skill to load the full instructions for any matching skill.

list_skills

Change an existing node to a different type in place, keeping its id, its placements and any student responses already recorded against it. Only the conversions Disco allows are possible — read the node first and use its `allowed_morph_targets`. Prefer this over deleting and recreating: a replacement node is a new identity, which breaks scoring history and any reference pointing at the original.

morph_node

Move a node to a new parent or reorder it within the same parent. Can move to a different parent or reorder among siblings by specifying a new index.

move_node

Get the Praktikal Play URL for a slideshow so the user can open it. Does not change slideshow state — the owner still clicks Start Presentation in the lobby when ready.

open_slideshow

Publish a numeric/math question, numerical table cell or table column as a reusable computed-value variable. Re-publishing may change its display name.

publish_computed_value

Read how learners move through a lesson: its stops (one per slide), the questions on each stop with their option ids and max points, and the navigation rules currently in force. Always call this before set_adventure_route: stop ids, question ids and option ids all come from here, and a lesson with no saved route still returns the implicit slide-order one you would be editing. Needs edit access to the lesson: the stops carry its answer key.

read_adventure_route

Read an image or attachment. Choose target.kind node_image with node_id for an existing node image (SVG markup or raster image), or snapshot_asset with an account-scoped asset_handle from read_tree_snapshot for metadata, original content, extracted document text or a rendered page. Snapshot handles expire and current access is rechecked.

read_asset

Read a curriculum. Choose view tree for its structure, scoped branches and depth-limited content; start with include structure and a small depth. Choose view node for one item with its full rendered body. Both views require curriculum_id and enforce membership and access within that curriculum.

read_curriculum

Read one E-Koolikott material: what it is, who made it, how it is licensed, and the parts it is built from. Returns a table of contents rather than the content itself — enough to decide what is worth copying and which parts to leave behind. Each part carries a `part_id` to pass to import_ekoolikott_material as `skip_parts`. `suggested_artifact_kind` is what the material looks like it should become; override it on the import only when the teacher wants something else.

read_ekoolikott_material

Fetch tree structure and detailed content for specific node IDs. Use to inspect node content, understand tree structure, or gather information before modifications. Essential before inserting, updating, or deleting. Full mode returns editable raw fields, placement, provenance, and metadata the caller may edit. Authors also receive real option IDs, correctness, answers, and explanations; read-only callers receive the redacted definition view. Full mode also returns computed_values with exact formula_reference and atom_html anchors for computed-value operations, grading_mode and allowed_morph_targets for questions, and provenance.parentIds so a node shared between lessons is visible as such. For a quick table-of-contents of a book or lesson, use mode: "structure" with max_depth: 2. For user-facing visual display of a single node, use VIEW_NODE instead. In full mode, requested board, canvas, table and slide roots also return content_state entries containing their structured editable state and save revision. Read the target node directly before updating its content. Descendant nodes are not expanded into content_state; request their IDs directly. Canvas state retains the empty starter document and legacy_svg warning; never replace a legacy drawing without explicit intent. Optional include sections return complete results in details for each requested root; extras includes the container ID, instruments includes quantities and kit contents, ancestors includes every lineage. Rights includes terms, authors and credits, with management identifiers only when permitted; rights.include_management controls that view. Learning connections includes learning alignment and requires curriculum:read. Translations returns stored title/summary translations for instruments, kits and components.

read_node

Read learning results. Choose target.kind question for per-student responses to one question, optionally within a slideshow, or slideshow for per-question session summaries. Results require ownership checks; grades and answer keys require their additional scopes. Question responses are capped at 200.

read_results

Read one set: its name, description, stored filter, and a page of the content it currently resolves to. Membership is resolved fresh on every read — hand-picked members first in the order the owner gave them, then whatever the stored filter matches now, minus anything excluded. A set grants no access to its contents: members the caller cannot read on their own are simply absent, so two people can read the same set and see different amounts of it. For a caller who may change the set this also reports its exclusions and how much of it a recipient would miss.

read_set

Read an assistant skill or one of its supporting references. Choose target.kind skill with a skill_id from list_skills; then use target.kind reference with a reference_id listed by that skill when its instructions require it. Both targets enforce actor access and session audience restrictions.

read_skill

Read the content of a slideshow — slides, questions, text, and structure. Use when a user shares a Praktikal Play link (play.praktikal.ee/slideshow/ID) or mentions a slideshow and wants help studying the material. Extract the slideshow ID from the URL. Returns all visible slide content with node IDs. Then use VIEW_NODE on individual question or content node IDs to show them as visual cards in the chat — do not re-type question text as plain text.

read_slideshow_content

Read the authoring history of a tree: what changed under a node, when, and who changed it. Covers the node and everything structurally beneath it, one entry per changed field, newest first, including nodes that were deleted. Use it to review what an agent or a colleague just did, to audit a shared collection, or to find what has moved since a date. Narrow with start_date, end_date and account_id rather than paging through everything. This reports history only — read_node shows what a node says now.

read_tree_changelog

Create or continue a stable, paginated full-tree snapshot for audits and transformations. Unlike READ_NODE, this separates distinct node records from ordered parent-child placements, includes per-node content hashes and version IDs, and keeps continuation pages fixed for 30 minutes. Start with root_node_id alone. To continue, repeat the snapshot_id you were given with the next_cursor from the page you just received, one page at a time — do not guess cursor values ahead of a response. Stop when has_more is false.

read_tree_snapshot

Remove one external author from this material using an author_id from read_node details.rights.management.authors (include rights). Platform account authors cannot be removed here.

remove_author

Remove a sum or mean aggregate from a table column. Formulas referencing it may stop resolving.

remove_computed_aggregate

Remove the computed formula from a table cell or column.

remove_computed_formula

Remove one external-source credit from the specified material using a credit_id returned in read_node details.rights.management.credits (include rights).

remove_credit

Remove the entire extras section from a node. The supplementary materials themselves survive in the repository.

remove_extras_container

Remove an inline computed-value atom matched by exact atom_html from a full node read.

remove_inline_computed_value

Remove specified learning connections from material. Choose connection.kind: focus, outcome, or curriculum_position. This detaches only the specified connections; the connected nodes and their other uses survive. Missing connections are harmless.

remove_learning_connections