@revenexx/editor 0.1.0

package/dist/modules/agent/runtime/server/classes/SessionManager/index.d.ts

@@ -0,0 +1,24 @@
+import { Session } from '../Session/index.js';
+import type { ServerToolMetadata } from '../../../shared/types.js';
+export declare class SessionManager {
+    private toolDefinitions;
+    private sessions;
+    /** Maps used token strings to their embedded timestamp (seconds). */
+    private usedTokens;
+    private pruneTimer;
+    constructor(toolDefinitions: ServerToolMetadata[]);
+    create(peerId: string): Session;
+    get(peerId: string): Session | undefined;
+    /**
+     * Record activity for a peer to prevent idle timeout.
+     */
+    touch(peerId: string): void;
+    /**
+     * Validate an auth token and consume it so it cannot be reused.
+     * Returns true only if the token is valid, not expired, and not previously used.
+     */
+    authenticate(token: string | undefined, authSecret: string): boolean;
+    cleanup(peerId: string): void;
+    private pruneIdleSessions;
+    private pruneTokens;
+}

package/dist/modules/agent/runtime/server/classes/SessionManager/index.js

@@ -0,0 +1,68 @@
+import { Session } from "../Session/index.js";
+import { validateToken, TOKEN_EXPIRY_SECONDS } from "../../helpers/security.js";
+const SESSION_IDLE_TIMEOUT_MS = 5 * 60 * 1e3;
+export class SessionManager {
+  constructor(toolDefinitions) {
+    this.toolDefinitions = toolDefinitions;
+  }
+  sessions = /* @__PURE__ */ new Map();
+  /** Maps used token strings to their embedded timestamp (seconds). */
+  usedTokens = /* @__PURE__ */ new Map();
+  pruneTimer = setInterval(() => {
+    this.pruneIdleSessions();
+    this.pruneTokens();
+  }, 6e4);
+  create(peerId) {
+    const session = new Session(this.toolDefinitions);
+    this.sessions.set(peerId, { session, lastActivity: Date.now() });
+    return session;
+  }
+  get(peerId) {
+    return this.sessions.get(peerId)?.session;
+  }
+  /**
+   * Record activity for a peer to prevent idle timeout.
+   */
+  touch(peerId) {
+    const entry = this.sessions.get(peerId);
+    if (entry) {
+      entry.lastActivity = Date.now();
+    }
+  }
+  /**
+   * Validate an auth token and consume it so it cannot be reused.
+   * Returns true only if the token is valid, not expired, and not previously used.
+   */
+  authenticate(token, authSecret) {
+    if (!token || !validateToken(token, authSecret)) return false;
+    this.pruneTokens();
+    if (this.usedTokens.has(token)) return false;
+    const timestamp = parseInt(token.substring(0, token.indexOf(":")), 10);
+    this.usedTokens.set(token, timestamp);
+    return true;
+  }
+  cleanup(peerId) {
+    const entry = this.sessions.get(peerId);
+    if (entry) {
+      entry.session.cleanup();
+      this.sessions.delete(peerId);
+    }
+  }
+  pruneIdleSessions() {
+    const cutoff = Date.now() - SESSION_IDLE_TIMEOUT_MS;
+    for (const [peerId, entry] of this.sessions) {
+      if (entry.lastActivity < cutoff) {
+        entry.session.cleanup();
+        this.sessions.delete(peerId);
+      }
+    }
+  }
+  pruneTokens() {
+    const cutoff = Math.floor(Date.now() / 1e3) - TOKEN_EXPIRY_SECONDS;
+    for (const [token, timestamp] of this.usedTokens) {
+      if (timestamp < cutoff) {
+        this.usedTokens.delete(token);
+      }
+    }
+  }
+}

package/dist/modules/agent/runtime/server/classes/StreamAccumulator/index.d.ts

@@ -0,0 +1,58 @@
+import type { GenericContentBlock } from '../../../shared/types.js';
+/**
+ * The outcome of finalizing a streamed tool_use block.
+ * `ok: false` means the model produced malformed JSON input — the tool_use block
+ * is still recorded (so the assistant message stays structurally valid), but the
+ * caller should return an error tool_result rather than dispatch the tool.
+ */
+export type FinishedToolUse = {
+    ok: true;
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+    /** Raw concatenated input JSON — used for repeated-call detection. */
+    inputJson: string;
+} | {
+    ok: false;
+    id: string;
+    name: string;
+};
+/**
+ * Turns a provider's stream of delta events (`text_*` / `tool_use_*`) into the
+ * completed content blocks of a single assistant turn.
+ *
+ * This is the pure, side-effect-free state machine extracted from `runAgentLoop`:
+ * it owns the in-progress text/tool_use buffers and the resulting block array,
+ * while the caller keeps the I/O concerns (streaming deltas to the client,
+ * dispatching tools, retry/repeat detection).
+ */
+export declare class StreamAccumulator {
+    private readonly _blocks;
+    private currentText;
+    private inText;
+    private toolUse;
+    /**
+     * Live array of completed content blocks for the current turn. The caller may
+     * append to it directly (e.g. reasoning blocks) and reset it (`.length = 0`)
+     * when committing messages early — the accumulator keeps appending afterwards.
+     */
+    get blocks(): GenericContentBlock[];
+    startText(): void;
+    /**
+     * Accumulate a raw text delta and return its transformed form for the caller
+     * to stream to the client. Returns `null` when no text block is open (the
+     * delta is ignored, matching the original `if (inTextBlock)` guard).
+     */
+    pushTextDelta(raw: string): string | null;
+    /** Finalize the open text block, recording it only if it has content. */
+    endText(): void;
+    startToolUse(id: string, name: string): void;
+    pushToolUseDelta(partialJson: string): void;
+    /**
+     * Finalize the open tool_use block: parse its accumulated JSON input, always
+     * record the tool_use block (so the assistant message stays valid even on
+     * malformed input), and return the parse outcome. Returns `null` if no tool_use
+     * was open.
+     */
+    finishToolUse(): FinishedToolUse | null;
+}

package/dist/modules/agent/runtime/server/classes/StreamAccumulator/index.js

@@ -0,0 +1,72 @@
+import { transformText } from "../../helpers/text.js";
+export class StreamAccumulator {
+  _blocks = [];
+  currentText = "";
+  inText = false;
+  toolUse = null;
+  /**
+   * Live array of completed content blocks for the current turn. The caller may
+   * append to it directly (e.g. reasoning blocks) and reset it (`.length = 0`)
+   * when committing messages early — the accumulator keeps appending afterwards.
+   */
+  get blocks() {
+    return this._blocks;
+  }
+  startText() {
+    this.inText = true;
+    this.currentText = "";
+  }
+  /**
+   * Accumulate a raw text delta and return its transformed form for the caller
+   * to stream to the client. Returns `null` when no text block is open (the
+   * delta is ignored, matching the original `if (inTextBlock)` guard).
+   */
+  pushTextDelta(raw) {
+    if (!this.inText) return null;
+    const transformed = transformText(raw);
+    this.currentText += transformed;
+    return transformed;
+  }
+  /** Finalize the open text block, recording it only if it has content. */
+  endText() {
+    if (this.inText && this.currentText) {
+      this._blocks.push({ type: "text", text: this.currentText });
+    }
+    this.currentText = "";
+    this.inText = false;
+  }
+  startToolUse(id, name) {
+    this.toolUse = { id, name, inputJson: "" };
+  }
+  pushToolUseDelta(partialJson) {
+    if (this.toolUse) {
+      this.toolUse.inputJson += partialJson;
+    }
+  }
+  /**
+   * Finalize the open tool_use block: parse its accumulated JSON input, always
+   * record the tool_use block (so the assistant message stays valid even on
+   * malformed input), and return the parse outcome. Returns `null` if no tool_use
+   * was open.
+   */
+  finishToolUse() {
+    const tu = this.toolUse;
+    if (!tu) return null;
+    this.toolUse = null;
+    let input;
+    let ok = true;
+    try {
+      input = JSON.parse(tu.inputJson || "{}");
+    } catch {
+      input = {};
+      ok = false;
+    }
+    this._blocks.push({
+      type: "tool_use",
+      id: tu.id,
+      name: tu.name,
+      input
+    });
+    return ok ? { ok: true, id: tu.id, name: tu.name, input, inputJson: tu.inputJson } : { ok: false, id: tu.id, name: tu.name };
+  }
+}

package/dist/modules/agent/runtime/server/default-skills/adding-new-paragraphs.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../skills/index.js").SkillDefinition;
+export default _default;

package/dist/modules/agent/runtime/server/default-skills/adding-new-paragraphs.js

@@ -0,0 +1,20 @@
+import { defineBlokkliAgentSkill } from "../skills/index.js";
+export default defineBlokkliAgentSkill({
+  name: "adding-new-paragraphs",
+  label: { en: "Adding new paragraphs", de: "Neue Bl\xF6cke hinzuf\xFCgen" },
+  description: "How to add new paragraphs. LOAD THIS THE FIRST TIME BEFORE CALLING add_paragraphs!!!",
+  getContents: () => `
+- paragraphs can be NESTED! More often than not a paragraph such as an accordeon, section, grid, etc. will have paragraph fields for nested paragraphs
+- Before adding paragraphs, THINK how you want to structure them! For example, when asked to "create a section about XYZ", check which paragraph is most appropriate for that
+- That paragraph could have multiple paragraph fields!
+- You can add multiple paragraphs using the add_paragraphs tool.
+- Use get_bundle_info to learn which bundles are allowed and what content fields AND paragraph fields they have BEFORE providing values in add_paragraphs.
+- IMPORTANT: When get_bundle_info shows a paragraph has paragraphFields (like "header", "paragraphs", "left", "right"), plan your structure so that matching content goes INTO those fields, not as sibling paragraphs. For example, if a grid has a "header" paragraphField that allows "title" bundles, create the title INSIDE the grid's header field, not as a separate paragraph alongside the grid.
+- PREFERRED: Use the \`children\` property on each paragraph to create entire nested structures in a SINGLE add_paragraphs call! The \`children\` property is a record keyed by paragraph field name, with arrays of child paragraphs. Children can also have children (recursive, no depth limit).
+- This is MUCH better than making multiple sequential calls (create parent, get_child_paragraphs, add children). Use children whenever you know the paragraph field names from get_bundle_info.
+- When adding paragraphs to a NEW parent that you did NOT just create with children, call get_child_paragraphs first to get the correct parent objects and field names. NEVER construct parent objects manually!
+- You SHOULD already provide default content field values if possible!
+- You can set paragraph OPTIONS inline via the \`options\` property on each paragraph (key-value pairs). Use get_bundle_info to see which options are available for a bundle. This avoids a separate set_paragraph_options call after creating paragraphs.
+- If you made a mistake, use the move_paragraphs to move the newly created paragraphs if possible or update_text_fields if you need to change text.
+`
+});

package/dist/modules/agent/runtime/server/default-skills/fixReadability.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../skills/index.js").SkillDefinition;
+export default _default;

package/dist/modules/agent/runtime/server/default-skills/fixReadability.js

@@ -0,0 +1,50 @@
+import { defineBlokkliAgentSkill } from "../skills/index.js";
+export default defineBlokkliAgentSkill({
+  name: "assess-and-fix-readability",
+  label: { en: "Fix Readability", de: "Lesbarkeit verbessern" },
+  description: "Load this skill when asked to check, fix, or improve readability of texts on the page.",
+  tools: [
+    "get_readability_issues",
+    "check_readability_for_texts",
+    "delegate_text_rewrite"
+  ],
+  getContents: () => `
+# Fix Readability
+
+## Step 1: Analyze
+
+Call \`get_readability_issues\` to see current issues. Review the results to decide which fields need fixing.
+
+## Step 2: Fix with \`delegate_text_rewrite\`
+
+Call \`delegate_text_rewrite\` with:
+- \`template\`: \`"fix_readability"\`
+- \`templateParams\`: \`{}\` (empty \u2014 issues are resolved automatically)
+- \`fields\`: array of \`{ uuid, fieldName }\` for the fields you want to fix
+
+Include ALL fields that have issues. The tool handles everything automatically:
+1. Runs readability analyzers to find issues in the specified fields
+2. Streams rewrites to fix them
+3. Verifies readability scores on the proposed text
+4. If any fields still fail, retries automatically with feedback (up to 3 attempts)
+5. Presents the user with before/after readability scores for approval
+
+Example:
+\`\`\`json
+{
+  "template": "fix_readability",
+  "templateParams": {},
+  "fields": [
+    { "uuid": "uuid-1", "fieldName": "field_text" },
+    { "uuid": "uuid-2", "fieldName": "title" }
+  ]
+}
+\`\`\`
+
+You do NOT need to pass any issue data, map field indices, or verify results manually. The tool does all of this internally.
+
+## Optional: Pre-check with \`check_readability_for_texts\`
+
+Use \`check_readability_for_texts\` to check readability scores for specific text strings without applying changes. Useful for spot-checks or comparing phrasings.
+`
+});

package/dist/modules/agent/runtime/server/default-skills/pageReview.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../skills/index.js").SkillDefinition;
+export default _default;

package/dist/modules/agent/runtime/server/default-skills/pageReview.js

@@ -0,0 +1,28 @@
+import { defineBlokkliAgentSkill } from "../skills/index.js";
+export default defineBlokkliAgentSkill({
+  name: "page-review",
+  label: { en: "Page Review", de: "Seiten-Review" },
+  description: "Tool guidance for reviewing page content. Load this when asked to do a full page review.",
+  getContents: () => `
+# Page Review - Tool Guide
+
+## Step 1: Get All Content First
+
+**Always start with \`get_all_page_content\`** - this returns all text from every paragraph on the page in a single call.
+
+This gives you:
+- A flat list of all paragraphs with text content
+- Each paragraph's uuid, bundle (type), and concatenated text
+- Complete page content for analysis
+
+## Step 2: Get Structure If Needed
+
+If you need to understand how paragraphs are organized:
+
+**Use \`get_child_paragraphs\`** (without uuid) to see page-level structure:
+- Shows which fields exist and what paragraphs they contain
+- Reveals the hierarchy and grouping of content
+
+**Use \`get_child_paragraphs\` with a uuid** to see a specific paragraph's children.
+`
+});

package/dist/modules/agent/runtime/server/default-skills/reusable-paragraphs.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../skills/index.js").SkillDefinition;
+export default _default;

package/dist/modules/agent/runtime/server/default-skills/reusable-paragraphs.js

@@ -0,0 +1,21 @@
+import { defineBlokkliAgentSkill } from "../skills/index.js";
+export default defineBlokkliAgentSkill({
+  name: "from-library-reusable-paragraphs",
+  label: { en: "Reusable paragraphs", de: "Bl\xF6cke aus der Bibliothek" },
+  description: 'READ this BEFORE dealing with reusable paragraphs ("from_library"), such as editing a from_library paragraph OR searching one in the library ("Bibliothek", "wiederverwendbar").',
+  getContents: () => `
+- reusable paragraphs are "global" paragraphs that are shared between multiple pages
+- editing them updates them everywhere
+- BUT: They can NOT be directly edited on this page!
+- This means: You can NOT edit content fields or paragraph fields of a reusable paragraph!
+- You CAN however edit their options - editing them ONLY affects the options on THIS current page, because the options are stored on the "from_library" paragraph and they override options from the "global" one.
+
+Internally, a "from_library" paragraph bundle references a special entity called "library_item". This entity contains the actual paragraph.
+So basically, if the user wants to "edit a reusable paragraph", you have to guide them to the edit mode of a library item. They can just double click the paragraph to launch a separate bl\xF6kkli instance.
+
+## Tools
+- Use "search_reusable_paragraphs" to find paragraphs from the library
+- Use "add_reusable_paragraph" to add a paragraph from the library on the page
+- Use "detach_reusable_paragraph" to _detach_ a "from_library" paragraph on the current page. Doing so will copy the reusable paragraph into this page, making it fully editable.
+`
+});

package/dist/modules/agent/runtime/server/default-skills/rewriteAndTranslate.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../skills/index.js").SkillDefinition;
+export default _default;

package/dist/modules/agent/runtime/server/default-skills/rewriteAndTranslate.js

@@ -0,0 +1,54 @@
+import { defineBlokkliAgentSkill } from "../skills/index.js";
+export default defineBlokkliAgentSkill({
+  name: "rewrite-and-translate",
+  label: { en: "Rewrite and Translate", de: "Umschreiben und \xDCbersetzen" },
+  description: "ALWAYS use this skill when asked to rewrite OR translate texts.",
+  tools: ["delegate_text_rewrite", "update_text_fields"],
+  getContents: () => `
+## delegate_text_rewrite \u2014 Template-Based Rewriting
+
+The \`delegate_text_rewrite\` tool uses prompt templates for precise control. Choose the right template:
+
+### \`translate\` template
+For translating text fields to another language. Always uses FULL mode.
+\`\`\`json
+{
+  "request": { "template": "translate", "targetLanguage": "German" },
+  "fields": [{ "uuid": "...", "fieldName": "..." }]
+}
+\`\`\`
+
+### \`rewrite\` template
+For general-purpose rewrites with a free-form instruction.
+\`\`\`json
+{
+  "request": { "template": "rewrite", "instruction": "Make more concise and professional" },
+  "fields": [{ "uuid": "...", "fieldName": "..." }]
+}
+\`\`\`
+
+### \`generate_content\` template
+For writing new content for empty fields (e.g. after adding blocks). Optionally include page context.
+\`\`\`json
+{
+  "request": {
+    "template": "generate_content",
+    "instruction": "Write an introductory paragraph about sustainable energy",
+    "context": "This is a blog post about renewable energy sources."
+  },
+  "fields": [{ "uuid": "...", "fieldName": "..." }]
+}
+\`\`\`
+
+## Guidelines
+
+- Prefer \`delegate_text_rewrite\` when rewriting or translating multiple or large text fields \u2014 it delegates to a specialized sub-agent for live preview.
+- Fall back to \`update_text_fields\` for small/direct text changes where you already have the final values (e.g. fixing a typo, or setting text provided by the user).
+- Use \`update_text_fields\` with \`operations\` (search/replace) for small targeted edits like typo fixes \u2014 avoids outputting the entire field value.
+- Use \`operations\` with \`selector: true\` to target a specific HTML element by CSS selector (e.g. \`p:nth-child(3)\`, \`h2\`, \`li:last-child\`) and replace its innerHTML.
+- Use \`update_text_fields\` with \`updates\` (a list of { uuid, fieldName, value }) for full rewrites where the entire value changes.
+- The \`update_text_fields\` tool can also be used when requireApproval is "false" (e.g. when the user provided the text themselves).
+- Both tools will ASK the user to accept each changed text by default - no need to manually ask the user beforehand!
+- When the user rejects one or more texts, they can provide a reason. Carefully read the reason if provided!
+`
+});

package/dist/modules/agent/runtime/server/default-system-prompts/architecture.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../system-prompts/index.js").SystemPromptDefinition;
+export default _default;

package/dist/modules/agent/runtime/server/default-system-prompts/architecture.js

@@ -0,0 +1,39 @@
+import { PLACEHOLDER_USER_NAME } from "../../shared/placeholders.js";
+import { defineBlokkliAgentSystemPrompt } from "../system-prompts/index.js";
+export default defineBlokkliAgentSystemPrompt({
+  id: "architecture",
+  title: "Architecture",
+  weight: 200,
+  cacheGroup: "static",
+  getPrompt: () => {
+    return `- bl\xF6kkli is an interactive page builder to manage complex content paragraphs
+- The "page" itself is a separate entity type, e.g. "content" or "node"
+- A paragraph can be placed in "paragraph fields"
+- A field can restrict which paragraph bundles it allows or how many paragraphs are allowed (cardinality)
+- A cardinality of -1 means: no limit on number of paragraphs, 1 = one paragraph, 2 = two paragraphs, etc.
+- Both the page and paragraph bundles themselves can have fields to place nested paragraphs
+- A paragraph always has a "parent". This consists of:
+  - type: The entity type of the "parent"
+  - uuid: The UUID of the "parent"
+  - field: The name of the field the paragraph is in
+- paragraphs can have "content fields" \u2014 fields that hold content values. There are four types:
+  - **plain**: Plain text (no HTML)
+  - **markup**: Rich text / HTML
+  - **reference**: Entity reference (media, nodes, etc.)
+  - **link**: Link field
+- paragraphs can have "options", such as "backgroundColor" or "showLink". They make it possible to change the appearance or behaviour of a paragraph.
+- The available options change based on various factors, such as the value of other options, the specific state of the paragraph's field values, etc. Always first check which options are available.
+
+### EXTRA UX FEATURES
+- To reference a specific paragraph, write its bare UUID inline. For example: "You should rewrite aaaaaaaa-1111-2222-3333-444444444444." The frontend renders the UUID as a clickable chip labelled with the paragraph's bundle. Do **not** wrap the UUID in markdown link syntax \u2014 emit the UUID on its own.
+- You can address the user using the special "${PLACEHOLDER_USER_NAME}" placeholder for a friendly welcome message. This is magically replaced in the frontend with the name of the user!
+
+### History and Undo/Redo
+- bl\xF6kkli maintains a history of all changes (undo/redo)
+- All query tools reflect the **current** history state
+- This works exactly like any history implementation:
+  - When navigating back in history (undo), all changes are reverted and none of the mutations past that index are applied
+  - When navigating forward (redo), changes will be re-applied
+  - When navigating back **and then** adding a new mutation, ALL mutations past that index are removed; you can not navigate forward anymore`;
+  }
+});

package/dist/modules/agent/runtime/server/default-system-prompts/available-skills.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../system-prompts/index.js").SystemPromptDefinition;
+export default _default;

package/dist/modules/agent/runtime/server/default-system-prompts/available-skills.js

@@ -0,0 +1,18 @@
+import { defineBlokkliAgentSystemPrompt } from "../system-prompts/index.js";
+import { formatItems } from "../system-prompts/helpers.js";
+export default defineBlokkliAgentSystemPrompt({
+  id: "available-skills",
+  title: "Available Skills",
+  weight: 900,
+  cacheGroup: "per-page",
+  getPrompt: (context) => {
+    return formatItems(
+      context.resolvedSkills.map((s) => ({
+        id: s.name,
+        label: context.loadedSkills.has(s.name) ? `${s.englishLabel} (loaded)` : s.englishLabel,
+        description: context.loadedSkills.has(s.name) ? "Already loaded in the conversation. Do NOT load again." : s.description
+      })),
+      "You can load detailed guidelines using the `load_skills` tool. Use skills when the task requires following specific rules or guidelines. Load skills when you feel they help you achieve a goal or when the user mentions it."
+    );
+  }
+});

package/dist/modules/agent/runtime/server/default-system-prompts/available-tools.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../system-prompts/index.js").SystemPromptDefinition;
+export default _default;

package/dist/modules/agent/runtime/server/default-system-prompts/available-tools.js

@@ -0,0 +1,18 @@
+import { defineBlokkliAgentSystemPrompt } from "../system-prompts/index.js";
+import { formatItems } from "../system-prompts/helpers.js";
+export default defineBlokkliAgentSystemPrompt({
+  id: "available-tools",
+  title: "Additional Tools",
+  weight: 1e3,
+  cacheGroup: "per-page",
+  getPrompt: (context) => {
+    return formatItems(
+      context.lazyTools.map((t) => ({
+        id: t.name,
+        label: t.name,
+        description: t.description
+      })),
+      "The following tools are available but must be loaded first by calling `load_tools`. Only load tools you actually need for the current task."
+    );
+  }
+});

package/dist/modules/agent/runtime/server/default-system-prompts/fragments.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../system-prompts/index.js").SystemPromptDefinition;
+export default _default;

package/dist/modules/agent/runtime/server/default-system-prompts/fragments.js

@@ -0,0 +1,19 @@
+import { defineBlokkliAgentSystemPrompt } from "../system-prompts/index.js";
+import { formatItems } from "../system-prompts/helpers.js";
+export default defineBlokkliAgentSystemPrompt({
+  id: "fragments",
+  title: "Available Fragments",
+  weight: 820,
+  cacheGroup: "per-page",
+  modes: ["editing"],
+  getPrompt: (context) => {
+    return formatItems(
+      context.pageContext.fragments.map((f) => ({
+        id: f.name,
+        label: f.label,
+        description: f.description
+      })),
+      "Fragments are hardcoded content components that can be added to the page. They have no content that can be edited by users."
+    );
+  }
+});

package/dist/modules/agent/runtime/server/default-system-prompts/important-rules.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../system-prompts/index.js").SystemPromptDefinition;
+export default _default;

package/dist/modules/agent/runtime/server/default-system-prompts/important-rules.js

@@ -0,0 +1,23 @@
+import { defineBlokkliAgentSystemPrompt } from "../system-prompts/index.js";
+export default defineBlokkliAgentSystemPrompt({
+  id: "important-rules",
+  title: "IMPORTANT",
+  weight: 600,
+  cacheGroup: "static",
+  getPrompt: () => {
+    return `
+- Use "ask_question" when presenting the user with some options to pick from (text suggestions, suggestions on how to change structure, etc.), but don't overuse it.
+- Always verify the structure before making changes
+- For markup fields, preserve HTML structure
+- For plain fields, use plain text only
+- When adding paragraphs, make sure to populate all required text fields!
+- Use the move_paragraphs tool when moving paragraphs, instead of creating a new paragraph of the same bundle and copy pasting text.
+- ALL mutation MCP tools will make sure that the mutation is valid - it's not possible for you to make a mistake there. They return a descriptive error message.
+- It's impossible for you to make irreversible mutations! All mutations can ALWAYS be undone. You can not actually publish any changes, this can only be done by a human.
+- The user's first message includes their selection inline as "[User has selected: <bundle> (<uuid>), ...]". Treat that as the target of vague references like "this", "these", "translate this", "make this bigger" \u2014 no extra tool call needed to identify them.
+- For LATER messages where the prompt implies acting on the current selection but the first-message annotation is absent or stale, call "get_selected_paragraphs" \u2014 the user may have changed their selection since the conversation started.
+- You can output text as you please, markdown is allowed!
+- DO NOT use emojis when writing content, unless explicitly told to do so!
+`;
+  }
+});

package/dist/modules/agent/runtime/server/default-system-prompts/interaction.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../system-prompts/index.js").SystemPromptDefinition;
+export default _default;

package/dist/modules/agent/runtime/server/default-system-prompts/interaction.js

@@ -0,0 +1,20 @@
+import { defineBlokkliAgentSystemPrompt } from "../system-prompts/index.js";
+export default defineBlokkliAgentSystemPrompt({
+  id: "interaction",
+  title: "Interaction with User",
+  weight: 400,
+  cacheGroup: "per-page",
+  getPrompt: ({ pageContext }) => {
+    const isGerman = pageContext.interfaceLanguage === "de";
+    const listItems = [
+      `Be polite and helpful.`,
+      isGerman ? `When speaking in German, address the bl\xF6kkli user in the "informal you" ("du", "dich", "deine", etc.). This does not apply for generated page content!` : void 0,
+      `The bl\xF6kkli user is a person who edits content. They are not interested in technical jargon. They don't care about UUIDs (this is never shown to them in the editor).`,
+      `Never use any swear words, even if the user's prompt is mean towards you.`,
+      `Talk to the user in the same language as their initial message`,
+      `DO NOT respond with long messages, unless asked to! Keep your answers short.`,
+      `After mutations, **BRIEFLY** confirm what you did. No lengthy summaries. No repeating of updated content.`
+    ].filter(Boolean);
+    return listItems.map((v) => "- " + v).join("\n");
+  }
+});

package/dist/modules/agent/runtime/server/default-system-prompts/introduction.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../system-prompts/index.js").SystemPromptDefinition;
+export default _default;

package/dist/modules/agent/runtime/server/default-system-prompts/introduction.js

@@ -0,0 +1,15 @@
+import { defineBlokkliAgentSystemPrompt } from "../system-prompts/index.js";
+export default defineBlokkliAgentSystemPrompt({
+  id: "introduction",
+  title: "",
+  weight: 100,
+  cacheGroup: "static",
+  getPrompt: () => {
+    return `You are a friendly AI agent that helps users create and edit complex page content in a Drupal paragraphs-based page editor called bl\xF6kkli.
+
+You have access to various MCP tools to query and mutate the page. Use them!
+**ALL MCP tools require VALID JSON as input!**
+These tools will use a lot of Drupal terminology such as "paragraph", "entity type", "bundle" or "field".
+`;
+  }
+});

package/dist/modules/agent/runtime/server/default-system-prompts/page-context.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../system-prompts/index.js").SystemPromptDefinition;
+export default _default;