Stage Dsl logo

Stage Dsl

OrganizationPopular
THU-MAIC
stage-dsl

The map for reading and editing an OpenMAIC stage document with read_stage, patch_stage, and grep_stage. Load it before patching a structure you have not patched before, when patch_stage rejects an operation, or whenever the path from a stage, outline, scene, content object, or action to the field you need is uncertain. It routes to field-level references for quizzes, interactive widgets, actions, and PBL projects; the installed slide-dsl skill remains the complete slide canvas manual.

Overview

PublisherTHU-MAIC
RepositoryOpenMAIC
Skill namestage-dsl
Stars
37.6K
Forks
5.9K
Bundled files
4
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 4 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by THU-MAIC on GitHub. Read the source before you install it.

Installation

Install the Stage Dsl AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/THU-MAIC/OpenMAIC.git /tmp/OpenMAIC
mkdir -p .claude/skills
cp -r /tmp/OpenMAIC/skills/agent-runtime/stage-dsl .claude/skills/stage-dsl
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Stage Dsl in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Stage Dsl on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Stage Dsl is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

The stage document map

This is a map, not the field manual.

Use it to decide which subtree owns a value, which path to read, and which reference chapter to load. Then read the exact source before writing.

The document model

The durable structure is:

text
stage
├── outline
└── scenes[]                    ordered by scene.order, shown as pages 1..N
    ├── id                     stable scene identity
    ├── order                  1-based page position
    ├── type                   slide | quiz | interactive | pbl
    ├── content                shape selected by scene.type
    │   ├── slide.canvas
    │   ├── quiz.questions[]
    │   ├── interactive.html / widgetConfig
    │   └── pbl.projectV2
    └── actions[]              ordered playback verbs

stage is the stage's metadata. outline is the generation plan. A persisted page is a scene. Its type and content.type must agree.

The three generic tools do not replace page-list operations. Insert, delete, reorder, and retitle pages with edit_deck.

Tool vocabulary

NeedToolHow
Read a sceneread_stage`path:/scenes/<order
Edit scene content or actionspatch_stage`target:/scenes/<order
Search visible text or sourcegrep_stageliteral search over the whole stage
List stages in folderslist_folder_stagesreturns the explicit stageId required by every stage tool
Insert, delete, reorder, or retitle pagesedit_deckpage-list operations stay outside the document patcher
Plan and build a new stageconversation + create_stage + generate_scenesettle the page plan in conversation, then call generate_scene once per page with an explicit brief
Set the classroom castset_rosterwrite the settled roster before page generation

Addressing with read_stage

PathResolves to
"" or omittedthe whole stage
/outlinethe persisted outline snapshot
/scenes/3the scene whose order is 3
/scenes/scene_abcthe scene with that stable id
/scenes/scene-abcthe historical hyphenated scene-id form
/scenes/3/actionsonly scene 3's action array

Orders are 1-based. Array indices inside source JSON are 0-based.

detail:"tree" is the compact structural inventory. It reports scene id, order, type, title, element/question/project counts, and action counts. It is for finding a target, never for reconstructing a write value.

detail:"source" is the exact JSON at the selected path. A scene source is the persisted scene object, so writable pointers begin /content/... or /actions/.... Inline media bytes larger than 2 KiB are replaced in this read projection by a read-only placeholder. The stored document is unchanged.

detail:"text" is the visible-text projection. Use it to find learner-facing copy or prove that old wording no longer remains. It deliberately omits known internal PBL prompts and runtime state.

Source and text responses are character-paged after 12,000 characters. Pass the returned nextOffset back as offset until it disappears.

Writing with patch_stage

target is one scene path: /scenes/<order|sceneId>.

Every call carries a human intent and one or more ops. The ops are atomic: the server applies them to a clone, validates the resulting scene, and writes once. If op 2 fails, op 1 is not persisted.

OpFieldsMeaning
setpath, valuereplace an existing leaf or add an optional object key
removepathdelete an existing object key or splice an array index
str_replacepath, oldText, newText, optional replaceAllreplace one exact occurrence of oldText inside the string field at path; replaceAll:true replaces every occurrence
add_elementelement, optional afterId or indexadd one complete id-less slide element
delete_elementelementIddelete one slide element by stable id

Set/remove/str_replace paths are JSON Pointers rooted at the scene source:

text
/content/canvas/elements/0/content
/content/questions/1/options/0/label
/content/widgetConfig/description
/content/projectV2/milestones/0/title
/actions/2/text

Escape / in an object key as ~1 and ~ as ~0. Array indices are canonical zero-based integers: 0, 1, 2, never 03, -1, or +1.

Every intermediate segment must exist. set may create only the final object key. remove requires the final key or array slot to exist.

For a change inside a large HTML document or long text field, prefer str_replace over rewriting the whole field with set: transcribing 27 KB of HTML to change one number is expensive, and any transcription error silently corrupts the page. Read detail:"source", pick a short unique anchor, replace it, then read back and grep_stage to verify. oldText must appear exactly once in the stored string; on multiple matches extend the anchor or set replaceAll:true. Neither oldText nor newText may contain a read-side media omission placeholder; newText may be empty to delete the anchor.

Scene metadata is not writable here. Paths must begin /content/ or /actions/; use edit_deck for page metadata and page-list changes.

Finding with grep_stage

scope:"text" searches the visible-text projection. scope:"source" searches serialized scene JSON, including field names and internal data.

Search is literal, case-insensitive, and applies NFKC to both query and source. Thus half-width AI finds full-width AI. Result start and end still slice the original, unnormalized scene string correctly.

A call returns at most 10 matches per scene and 30 overall, within its time and character budget. truncated:true always includes an opaque cursor. Repeat the same query, scope, and stage with that cursor to continue.

Read before write

For every edit:

  1. Read the target scene with detail:"source".
  2. Locate the exact field and array index in that source.
  3. Load the matching field-reference chapter below if this structure is new to you or a previous patch was rejected.
  4. Patch the smallest leaf that expresses the intent.
  5. Read the same source path again and verify the stored value.
  6. Use detail:"text" or grep_stage when the check is “no old copy remains.”

Never build a patch from tree; it intentionally omits neighbouring fields.

Never copy a <… bytes omitted: …> media placeholder into a write. Supply a new real URL/src or leave that field untouched.

Route to the field manual

What you need to writeRead this first
Slide canvas, background, theme, any of the ten slide element typesRead the installed slide-dsl skill at the location shown in <available_skills>. It is the complete manual and its examples already use scene-root /content/canvas/... pointers.
Quiz questions, options, answers, grading fieldsreferences/quiz.md
Interactive HTML or typed widget configurationreferences/widget.md
Narration, spotlight, whiteboard, video, discussion, or widget playback actionsreferences/actions.md
PBL projectV2 roles, milestones, microtasks, packaged design, or runtime-owned fieldsreferences/pbl.md

Validation boundary

Slides use the closed slide element schema and reject unknown fields, wrong types, missing required fields, id changes, and element-type changes.

Quiz writes add a closed question/option check around the current document validator. Interactive content is closed at its content root, but historical widgetConfig objects remain intentionally tolerant below that root. PBL is closed at its content root, while the existing projectV2 validator requires its core containers and deliberately tolerates historical runtime extension fields.

That difference matters: “accepted” means the current persisted contract accepted the shape, not that every value is pedagogically sound or every renderer consumes it. The reference chapters name the hard boundary and the known semantic boundary separately.

Hard rules

  • Read source before every patch and read it again afterward.
  • Patch one leaf when one leaf is enough.
  • Use scene-root paths: /content/... and /actions/....
  • For a change inside a large HTML or long text field, use str_replace with a short unique anchor instead of rewriting the whole field.
  • Use add_element and delete_element for slide element identity changes.
  • Do not use patch_stage for page insertion, deletion, reordering, or titles.
  • Do not write media omission placeholders.
  • A rejected atomic batch changed nothing.
  • When uncertain, stop guessing and read the matching reference chapter.

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Stage Dsl AI skill do?

The map for reading and editing an OpenMAIC stage document with read_stage, patch_stage, and grep_stage. Load it before patching a structure you have not patched before, when patch_stage rejects an operation, or whenever the path from a stage, outline, scene, content object, or action to the field you need is uncertain. It routes to field-level references for quizzes, interactive widgets, actions, and PBL projects; the installed slide-dsl skill remains the complete slide canvas manual.

Why use Stage Dsl on TypingMind?

Because you install it once and use it with any model. Stage Dsl is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Stage Dsl in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/THU-MAIC/OpenMAIC/tree/main/skills/agent-runtime/stage-dsl. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Stage Dsl?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Stage Dsl?

As many as you like. As long as a model supports skills, you can use Stage Dsl with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Stage Dsl AI skill free?

Yes. It is published on GitHub by THU-MAIC under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇