@blokkli/editor 2.0.0-alpha.32 → 2.0.0-alpha.34

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

@@ -0,0 +1,21 @@
+import { Session } from './Session.js';
+export declare class SessionManager {
+    private sessions;
+    /** Maps used token strings to their embedded timestamp (seconds). */
+    private usedTokens;
+    private pruneTimer;
+    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/SessionManager.js

@@ -0,0 +1,80 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+import { Session } from "./Session.js";
+const TOKEN_EXPIRY_SECONDS = 300;
+const SESSION_IDLE_TIMEOUT_MS = 5 * 60 * 1e3;
+export class SessionManager {
+  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.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) return false;
+    const colonIndex = token.indexOf(":");
+    if (colonIndex === -1) return false;
+    const timestampStr = token.substring(0, colonIndex);
+    const providedHmac = token.substring(colonIndex + 1);
+    const timestamp = parseInt(timestampStr, 10);
+    if (isNaN(timestamp)) return false;
+    const now = Math.floor(Date.now() / 1e3);
+    if (Math.abs(now - timestamp) > TOKEN_EXPIRY_SECONDS) return false;
+    const expectedHmac = createHmac("sha256", authSecret).update(timestampStr).digest("hex");
+    if (providedHmac.length !== expectedHmac.length) return false;
+    const valid = timingSafeEqual(
+      Buffer.from(providedHmac, "hex"),
+      Buffer.from(expectedHmac, "hex")
+    );
+    if (!valid) return false;
+    this.pruneTokens();
+    if (this.usedTokens.has(token)) return false;
+    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/agent.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/modules/agent/runtime/server/agent.js

@@ -0,0 +1,148 @@
+import { defineWebSocketHandler, useRuntimeConfig } from "#imports";
+import { clientMessageSchema } from "../shared/types.js";
+import { SessionManager } from "./SessionManager.js";
+import { send } from "./helpers.js";
+const sessionManager = new SessionManager();
+const config = useRuntimeConfig();
+const authSecret = config.blokkli?.agent?.authSecret || "";
+const apiKey = config.blokkli?.agent?.apiKey || "";
+export default defineWebSocketHandler({
+  open(_peer) {
+  },
+  async message(peer, message) {
+    try {
+      const parsed = clientMessageSchema.safeParse(JSON.parse(message.text()));
+      if (!parsed.success) {
+        send(peer, {
+          type: "error",
+          errorType: "bad_request",
+          message: "Invalid message format"
+        });
+        return;
+      }
+      const data = parsed.data;
+      if (data.type === "authenticate") {
+        if (!authSecret || !sessionManager.authenticate(data.authToken, authSecret)) {
+          send(peer, {
+            type: "error",
+            errorType: "unauthorized",
+            message: "Authentication required."
+          });
+          peer.close();
+          return;
+        }
+        if (sessionManager.get(peer.id)) {
+          sessionManager.cleanup(peer.id);
+        }
+        sessionManager.create(peer.id);
+        send(peer, { type: "authenticated" });
+        return;
+      }
+      const session = sessionManager.get(peer.id);
+      if (!session) {
+        send(peer, {
+          type: "error",
+          errorType: "unauthorized",
+          message: "Authentication required."
+        });
+        peer.close();
+        return;
+      }
+      sessionManager.touch(peer.id);
+      if (data.type === "ping") {
+        return;
+      }
+      if (session.isProcessing) {
+        switch (data.type) {
+          case "init":
+          case "accept":
+          case "reject":
+          case "new_conversation":
+          case "restore_conversation":
+            send(peer, {
+              type: "error",
+              errorType: "bad_request",
+              message: "Cannot perform this action while the agent is processing."
+            });
+            return;
+        }
+      }
+      switch (data.type) {
+        case "init":
+          session.init(data.tools, data.pageContext);
+          break;
+        case "start":
+          if (!apiKey) {
+            send(peer, {
+              type: "error",
+              errorType: "authentication",
+              message: "API key not configured"
+            });
+            return;
+          }
+          session.start(
+            peer,
+            data.prompt,
+            apiKey,
+            authSecret,
+            data.selectedUuids
+          );
+          break;
+        case "tool_result":
+          session.resolveToolResult(data.callId, {
+            result: data.result,
+            error: data.error
+          });
+          break;
+        case "cancel":
+          session.cancel(peer);
+          break;
+        case "accept":
+          session.acceptChanges(peer, authSecret);
+          break;
+        case "reject":
+          session.rejectChanges(peer, authSecret);
+          break;
+        case "get_transcript":
+          session.getTranscript(peer);
+          break;
+        case "new_conversation":
+          session.newConversation(peer, authSecret);
+          break;
+        case "restore_conversation": {
+          const result = session.restoreConversation(data.state, authSecret);
+          if (result.success) {
+            send(peer, { type: "conversation_restored" });
+          } else {
+            send(peer, {
+              type: "conversation_restore_failed",
+              reason: result.reason || "Unknown error"
+            });
+          }
+          break;
+        }
+        case "plan_approve":
+          session.approvePlan();
+          break;
+        case "plan_reject":
+          session.rejectPlan();
+          break;
+      }
+    } catch (error) {
+      console.error("WebSocket message error:", error);
+      send(peer, {
+        type: "error",
+        errorType: "unknown",
+        message: "Failed to process message",
+        detail: error instanceof Error ? error.message : void 0
+      });
+    }
+  },
+  close(peer) {
+    sessionManager.cleanup(peer.id);
+  },
+  error(peer, error) {
+    console.error(`[WebSocket] Error for ${peer.id}:`, error);
+    sessionManager.cleanup(peer.id);
+  }
+});

package/dist/modules/agent/runtime/server/agentPrompt.d.ts

@@ -0,0 +1,22 @@
+import type { PageContext } from '../shared/types.js';
+import type { ResolvedSkill } from './skills/types.js';
+import type { ActivePlanContext, SystemPromptBlock } from './system-prompts/types.js';
+/**
+ * Build structured system prompt blocks for the AI agent.
+ * Returns an array of text blocks with optional cache hints.
+ *
+ * Prompts are sorted by cacheGroup (static → per-page → per-turn), then by weight.
+ * A cacheHint is placed on the last block of each cacheable group boundary,
+ * enabling providers to apply their caching strategy.
+ */
+export declare function buildSystemPrompt(context: PageContext, resolvedSkills: ResolvedSkill[], lazyTools?: {
+    name: string;
+    description: string;
+}[], activePlan?: ActivePlanContext, loadedSkills?: ReadonlySet<string>): SystemPromptBlock[];
+/**
+ * Build a plain-text system prompt string (for transcript/debug use).
+ */
+export declare function buildSystemPromptText(context: PageContext, resolvedSkills: ResolvedSkill[], lazyTools?: {
+    name: string;
+    description: string;
+}[], activePlan?: ActivePlanContext, loadedSkills?: ReadonlySet<string>): string;

package/dist/modules/agent/runtime/server/agentPrompt.js

@@ -0,0 +1,53 @@
+import { debugPrompt, systemPrompts } from "#blokkli-build/agent-server";
+const CACHE_GROUP_ORDER = {
+  static: 0,
+  "per-page": 1
+};
+function getCacheGroupOrder(sp) {
+  return sp.cacheGroup ? CACHE_GROUP_ORDER[sp.cacheGroup] ?? 2 : 2;
+}
+export function buildSystemPrompt(context, resolvedSkills, lazyTools = [], activePlan, loadedSkills = /* @__PURE__ */ new Set()) {
+  const promptContext = {
+    pageContext: context,
+    resolvedSkills,
+    lazyTools,
+    isDebugMode: !!(import.meta.dev && debugPrompt),
+    activePlan,
+    loadedSkills
+  };
+  const sorted = systemPrompts.filter((sp) => !sp.modes?.length || sp.modes.includes(context.editMode)).sort((a, b) => {
+    const groupDiff = getCacheGroupOrder(a) - getCacheGroupOrder(b);
+    if (groupDiff !== 0) return groupDiff;
+    return a.weight - b.weight;
+  });
+  const entries = [];
+  for (const sp of sorted) {
+    const text = sp.getPrompt(promptContext)?.trim();
+    if (!text) continue;
+    const formatted = sp.title ? `## ${sp.title}
+
+${text}` : text;
+    entries.push({ text: formatted, cacheGroup: sp.cacheGroup });
+  }
+  const blocks = [];
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    const nextEntry = entries[i + 1];
+    const isLastInGroup = entry.cacheGroup && (!nextEntry || nextEntry.cacheGroup !== entry.cacheGroup);
+    const block = { text: entry.text };
+    if (isLastInGroup) {
+      block.cacheHint = "ephemeral";
+    }
+    blocks.push(block);
+  }
+  return blocks;
+}
+export function buildSystemPromptText(context, resolvedSkills, lazyTools = [], activePlan, loadedSkills = /* @__PURE__ */ new Set()) {
+  return buildSystemPrompt(
+    context,
+    resolvedSkills,
+    lazyTools,
+    activePlan,
+    loadedSkills
+  ).map((b) => b.text).join("\n\n");
+}

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,21 @@
+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.
+- The add_paragraphs tool will thoroughly validate your input (including children and options recursively), so it's impossible for you to add invalid paragraphs.
+- If you made a mistake, use the move_paragraphs to move the newly created paragraphs if possible or batch_rewrite_text if you need to change text.
+`
+});

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 IMMEDIATELY AFTER being asked to review, critique, or analyze a page!",
+  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,14 @@
+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.",
+  getContents: () => `
+- Use the batch_rewrite_text tool to rewrite or translate multiple texts at once!
+- The batch_rewrite_text will ASK the user accept each changed text by default - no need to manually ask the user beforehand!
+- You CAN set requireApproval to "false" if the user already provided you with the text (either manually in a message OR via a tool), as it makes no sense to let the user approve a text they are approved (e.g. via ask_question) or by explicitly requesting a text.
+- When approval is required and the user rejects one or more texts, they can provide a reason. Carefully read the reason if provided!
+- If unsure about something: USE THE ask_question TOOL!
+- When asked for suggestions by the user: USE THE ask_question TOOL!
+`
+});

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
+- You can create markdown links for a specific paragraph by using the paragraph UUID! For example: "You should rewrite [this text](#UUID)". This will be converted to a HTML link the user can click on!
+- 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_skill` 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,22 @@
+import { defineBlokkliAgentSystemPrompt } from "../system-prompts/index.js";
+export default defineBlokkliAgentSystemPrompt({
+  id: "important-rules",
+  title: "IMPORTANT",
+  weight: 600,
+  cacheGroup: "static",
+  getPrompt: () => {
+    return `
+- ALWAYS USE THE "ask_question" TOOL TO ASK STRUCTURED QUESTIONS!!!
+- Use "ask_question" also when presenting the user with some options to pick from (text suggestions, suggestions on how to change structure, etc.)
+- 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.
+- When the user's prompt implies acting on specific paragraphs but doesn't specify which ones (e.g. "translate this to german", "make this bigger", "delete these"), ALWAYS call "get_selected_paragraphs" first to check what is selected. Do this even if the prompt seems ambiguous - the selection is the most likely target.
+- You can output text as you please, markdown is allowed!
+`;
+  }
+});

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,14 @@
+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! You also have access to additional knowledge available via load_skill!
+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;