@blokkli/editor 2.0.0-alpha.5 → 2.0.0-alpha.50

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

@@ -0,0 +1,24 @@
+import { Session } from './Session.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/SessionManager.js

@@ -0,0 +1,83 @@
+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 {
+  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) 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,154 @@
+import { defineWebSocketHandler, useRuntimeConfig } from "#imports";
+import { clientMessageSchema } from "../shared/types.js";
+import { SessionManager } from "./SessionManager.js";
+import { send } from "./helpers.js";
+import { toolDefinitions } from "#blokkli-build/agent-server";
+const sessionManager = new SessionManager(toolDefinitions);
+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.toolNames, 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,
+            data.autoLoadTools,
+            data.autoLoadSkills,
+            data.preSeededResults,
+            data.autoExecuteTools
+          );
+          break;
+        case "tool_result":
+          session.resolveToolResult(data.callId, {
+            result: data.result,
+            error: data.error,
+            skipLlmResponse: data.skipLlmResponse
+          });
+          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,30 @@
+import type { PageContext, TranscriptSystemPrompt } 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;
+/**
+ * Build structured system prompt entries for the transcript.
+ * Returns one entry per prompt definition with id, name, and content.
+ */
+export declare function buildSystemPromptEntries(context: PageContext, resolvedSkills: ResolvedSkill[], lazyTools?: {
+    name: string;
+    description: string;
+}[], activePlan?: ActivePlanContext, loadedSkills?: ReadonlySet<string>): TranscriptSystemPrompt[];

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

@@ -0,0 +1,79 @@
+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");
+}
+export function buildSystemPromptEntries(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;
+    entries.push({
+      id: sp.id,
+      name: sp.title,
+      content: text
+    });
+  }
+  return entries;
+}

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 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: "asses-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
+{
+  "template": "translate",
+  "templateParams": { "targetLanguage": "German" },
+  "fields": [{ "uuid": "...", "fieldName": "..." }]
+}
+\`\`\`
+
+### \`rewrite\` template
+For general-purpose rewrites with a free-form instruction.
+\`\`\`json
+{
+  "template": "rewrite",
+  "templateParams": { "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
+{
+  "template": "generate_content",
+  "templateParams": { "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 \`uuids\` 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!
+- 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_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;