@blokkli/editor 2.0.0-alpha.58 → 2.0.0-alpha.59

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

@@ -1,5 +1,5 @@
-import { Session } from './Session.js';
-import type { ServerToolMetadata } from '../shared/types.js';
+import { Session } from '../Session/index.js';
+import type { ServerToolMetadata } from '../../../shared/types.js';
 export declare class SessionManager {
     private toolDefinitions;
     private sessions;

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

@@ -1,6 +1,5 @@
-import { createHmac, timingSafeEqual } from "node:crypto";
-import { Session } from "./Session.js";
-const TOKEN_EXPIRY_SECONDS = 300;
+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) {
@@ -35,24 +34,10 @@ export class SessionManager {
    * 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;
+    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;
   }

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.js

@@ -15,7 +15,6 @@ export default defineBlokkliAgentSkill({
 - 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.js

@@ -1,6 +1,6 @@
 import { defineBlokkliAgentSkill } from "../skills/index.js";
 export default defineBlokkliAgentSkill({
-  name: "asses-and-fix-readability",
+  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: [

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

@@ -13,8 +13,7 @@ The \`delegate_text_rewrite\` tool uses prompt templates for precise control. Ch
 For translating text fields to another language. Always uses FULL mode.
 \`\`\`json
 {
-  "template": "translate",
-  "templateParams": { "targetLanguage": "German" },
+  "request": { "template": "translate", "targetLanguage": "German" },
   "fields": [{ "uuid": "...", "fieldName": "..." }]
 }
 \`\`\`
@@ -23,8 +22,7 @@ For translating text fields to another language. Always uses FULL mode.
 For general-purpose rewrites with a free-form instruction.
 \`\`\`json
 {
-  "template": "rewrite",
-  "templateParams": { "instruction": "Make more concise and professional" },
+  "request": { "template": "rewrite", "instruction": "Make more concise and professional" },
   "fields": [{ "uuid": "...", "fieldName": "..." }]
 }
 \`\`\`
@@ -33,8 +31,11 @@ For general-purpose rewrites with a free-form instruction.
 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." },
+  "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": "..." }]
 }
 \`\`\`
@@ -45,10 +46,9 @@ For writing new content for empty fields (e.g. after adding blocks). Optionally
 - 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.
+- 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!
-- When asked for suggestions by the user: USE THE ask_question TOOL!
 `
 });

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

@@ -7,7 +7,7 @@ export default defineBlokkliAgentSystemPrompt({
   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_skills!
+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/workflow.js

@@ -13,7 +13,6 @@ export default defineBlokkliAgentSystemPrompt({
       "Use get_paragraph_context to get comprehensive info about a specific paragraph (parent chain, siblings, children, content fields, options) - prefer this over multiple individual calls",
       "Use find_paragraphs to search for paragraphs by bundle, text content, nesting level, or options",
       "Use get_child_paragraphs to see a paragraph's or page's fields with their paragraphs - returns parent objects ready for add_paragraphs",
-      "If you need specialized tools (media search, content search, templates, etc.), use load_tools to activate them first",
       "Add up to 5 paragraphs at a time. For more paragraphs, use multiple add_paragraphs calls.",
       "For paragraphs with lots of text (more than 100 words), add one at a time."
     ];

package/dist/modules/agent/runtime/server/{agentPrompt.d.ts → helpers/agentPrompt.d.ts}

@@ -1,6 +1,6 @@
-import type { PageContext, TranscriptSystemPrompt } from '../shared/types.js';
-import type { ResolvedSkill } from './skills/types.js';
-import type { ActivePlanContext, SystemPromptBlock } from './system-prompts/types.js';
+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.

package/dist/modules/agent/runtime/server/helpers/errors.d.ts

@@ -0,0 +1,10 @@
+import type { AgentErrorType } from '../../shared/types.js';
+/**
+ * Classify an API error into a structured error with type, message, and detail.
+ * Works with both Anthropic and OpenAI SDK errors (both use HTTP status codes).
+ */
+export declare function classifyError(error: unknown): {
+    errorType: AgentErrorType;
+    message: string;
+    detail?: string;
+};

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

@@ -0,0 +1,63 @@
+export function classifyError(error) {
+  if (!(error instanceof Error)) {
+    return {
+      errorType: "unknown",
+      message: "An unexpected error occurred."
+    };
+  }
+  const detail = error.message || void 0;
+  const status = error.status;
+  if (status === void 0) {
+    if (error.constructor.name === "APIConnectionError") {
+      return {
+        errorType: "connection",
+        message: "Could not connect to the AI service.",
+        detail
+      };
+    }
+    return {
+      errorType: "unknown",
+      message: error.message || "An unexpected error occurred.",
+      detail
+    };
+  }
+  switch (status) {
+    case 401:
+      return {
+        errorType: "authentication",
+        message: "API authentication failed. Please check your API key.",
+        detail
+      };
+    case 400:
+      return {
+        errorType: "bad_request",
+        message: "The request to the AI service was invalid.",
+        detail
+      };
+    case 404:
+      return {
+        errorType: "not_found",
+        message: "The configured AI model was not found. Please check the configuration.",
+        detail
+      };
+    case 429:
+      return {
+        errorType: "rate_limit",
+        message: "Rate limit exceeded. Please wait a moment before trying again.",
+        detail
+      };
+    case 529:
+    case 503:
+      return {
+        errorType: "overloaded",
+        message: "The AI service is currently overloaded. Please try again in a moment.",
+        detail
+      };
+    default:
+      return {
+        errorType: "unknown",
+        message: `API error (${status}).`,
+        detail
+      };
+  }
+}

package/dist/modules/agent/runtime/server/helpers/messages.d.ts

@@ -0,0 +1,6 @@
+import type { GenericMessage } from '../../shared/types.js';
+/**
+ * Validate message array for issues that would cause API errors.
+ * Returns an array of issue descriptions (empty if valid).
+ */
+export declare function validateMessages(messages: GenericMessage[]): string[];

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

@@ -0,0 +1,70 @@
+function findToolNameForResult(messages, userMsgIndex, toolUseId) {
+  for (let i = userMsgIndex - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (!msg) continue;
+    if (msg.role !== "assistant" || !Array.isArray(msg.content)) continue;
+    for (const block of msg.content) {
+      if (block.type === "tool_use" && block.id === toolUseId) {
+        return block.name;
+      }
+    }
+    break;
+  }
+  return void 0;
+}
+export function validateMessages(messages) {
+  const issues = [];
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (!msg) continue;
+    const prevMsg = i > 0 ? messages[i - 1] : void 0;
+    if (prevMsg && prevMsg.role === msg.role) {
+      issues.push(
+        `Consecutive ${msg.role} messages at indices ${i - 1} and ${i}`
+      );
+    }
+    if (Array.isArray(msg.content) && msg.content.length === 0) {
+      issues.push(`Empty content array in ${msg.role} message at index ${i}`);
+    }
+    if (msg.role === "user" && Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === "tool_result") {
+          const toolName = findToolNameForResult(messages, i, block.tool_use_id);
+          if (!toolName) {
+            issues.push(
+              `Orphaned tool_result for ${block.tool_use_id} at message index ${i}`
+            );
+          }
+        }
+      }
+    }
+    if (msg.role === "assistant" && Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === "tool_use") {
+          const nextMsg = messages[i + 1];
+          if (!nextMsg || nextMsg.role !== "user") {
+            issues.push(
+              `tool_use "${block.name}" (${block.id}) at message index ${i} has no following user message`
+            );
+            continue;
+          }
+          if (!Array.isArray(nextMsg.content)) {
+            issues.push(
+              `tool_use "${block.name}" (${block.id}) at message index ${i} has no matching tool_result`
+            );
+            continue;
+          }
+          const hasResult = nextMsg.content.some(
+            (b) => b.type === "tool_result" && b.tool_use_id === block.id
+          );
+          if (!hasResult) {
+            issues.push(
+              `tool_use "${block.name}" (${block.id}) at message index ${i} has no matching tool_result`
+            );
+          }
+        }
+      }
+    }
+  }
+  return issues;
+}

package/dist/modules/agent/runtime/server/helpers/models.d.ts

@@ -0,0 +1,20 @@
+import type { AgentModelDefinition, UsageTurn } from '../../shared/types.js';
+/**
+ * Model selection and per-turn usage accounting.
+ */
+/**
+ * The model used for the main agent loop: the one flagged `isDefault`, or the
+ * first configured model as a fallback.
+ */
+export declare function getDefaultModel(models: AgentModelDefinition[]): AgentModelDefinition | undefined;
+/**
+ * Build a `UsageTurn` from a provider `message_end` event and the model that
+ * produced it (for pricing). Returns undefined when token counts are absent,
+ * so callers can skip emitting a usage message.
+ */
+export declare function createUsageTurn(event: {
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheCreationInputTokens?: number;
+    cacheReadInputTokens?: number;
+}, model: AgentModelDefinition | null | undefined): UsageTurn | undefined;

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

@@ -0,0 +1,15 @@
+export function getDefaultModel(models) {
+  return models.find((m) => m.isDefault) || models[0];
+}
+export function createUsageTurn(event, model) {
+  if (event.inputTokens === void 0 || event.outputTokens === void 0) {
+    return void 0;
+  }
+  return {
+    inputTokens: event.inputTokens,
+    outputTokens: event.outputTokens,
+    cacheCreationInputTokens: event.cacheCreationInputTokens ?? 0,
+    cacheReadInputTokens: event.cacheReadInputTokens ?? 0,
+    pricing: model?.pricing ?? null
+  };
+}

package/dist/modules/agent/runtime/server/{routing.d.ts → helpers/routing.d.ts}

@@ -1,5 +1,5 @@
-import type { ResolvedSkill } from './skills/types.js';
-import type { UsageTurn } from '../shared/types.js';
+import type { ResolvedSkill } from '../skills/types.js';
+import type { UsageTurn } from '../../shared/types.js';
 export type RoutingResult = {
     skills: string[];
     tools: string[];

package/dist/modules/agent/runtime/server/{routing.js → helpers/routing.js}

@@ -1,4 +1,5 @@
 import { provider, models } from "#blokkli-build/agent-server";
+import { createUsageTurn } from "./models.js";
 function getRoutingModel() {
   if (!models.length) return null;
   return models.find((m) => m.routing) || models.find((m) => m.isDefault) || models[0];
@@ -78,15 +79,7 @@ Given the user's message, select which skills and tools should be pre-loaded. On
       if (event.type === "tool_use_delta") {
         toolInput += event.partial_json;
       } else if (event.type === "message_end") {
-        if (event.inputTokens !== void 0 && event.outputTokens !== void 0) {
-          usage = {
-            inputTokens: event.inputTokens,
-            outputTokens: event.outputTokens,
-            cacheCreationInputTokens: event.cacheCreationInputTokens ?? 0,
-            cacheReadInputTokens: event.cacheReadInputTokens ?? 0,
-            pricing: routingModelDef.pricing ?? null
-          };
-        }
+        usage = createUsageTurn(event, routingModelDef) ?? usage;
       } else if (event.type === "error") {
         console.warn("[blokkli:agent] Routing error:", event.error.message);
         return null;

package/dist/modules/agent/runtime/server/helpers/security.d.ts

@@ -0,0 +1,22 @@
+import type { ConversationStateSnapshot, GenericMessage } from '../../shared/types.js';
+/**
+ * HMAC-based verification: agent auth tokens (WebSocket handshake) and
+ * conversation-state tamper detection. Both fail closed on a missing secret.
+ */
+/** Seconds an agent auth token remains valid after issuance. */
+export declare const TOKEN_EXPIRY_SECONDS = 300;
+/**
+ * Validate an HMAC auth token: well-formed `<timestamp>:<hmac>`, not expired,
+ * and HMAC matches. Does NOT track one-time use — `SessionManager` layers its
+ * replay check on top. Returns false (never throws) on any malformed input.
+ */
+export declare function validateToken(token: string, secret: string): boolean;
+/**
+ * Compute an HMAC-SHA256 hash for a conversation state snapshot.
+ */
+export declare function computeStateHash(messages: GenericMessage[], activatedLazyTools: string[], secret: string): string;
+/**
+ * Verify the HMAC hash of a conversation state snapshot.
+ * Uses timing-safe comparison to prevent timing attacks.
+ */
+export declare function verifyStateHash(snapshot: ConversationStateSnapshot, secret: string): boolean;

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

@@ -0,0 +1,44 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+export const TOKEN_EXPIRY_SECONDS = 300;
+export function validateToken(token, secret) {
+  if (!secret || !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", secret).update(timestampStr).digest("hex");
+  if (providedHmac.length !== expectedHmac.length) return false;
+  try {
+    return timingSafeEqual(
+      Buffer.from(providedHmac, "hex"),
+      Buffer.from(expectedHmac, "hex")
+    );
+  } catch {
+    return false;
+  }
+}
+export function computeStateHash(messages, activatedLazyTools, secret) {
+  const payload = JSON.stringify(messages) + "|" + JSON.stringify(activatedLazyTools);
+  return createHmac("sha256", secret).update(payload).digest("hex");
+}
+export function verifyStateHash(snapshot, secret) {
+  if (!secret) return false;
+  const expected = computeStateHash(
+    snapshot.messages,
+    snapshot.activatedLazyTools,
+    secret
+  );
+  if (expected.length !== snapshot.hash.length) return false;
+  try {
+    return timingSafeEqual(
+      Buffer.from(expected, "hex"),
+      Buffer.from(snapshot.hash, "hex")
+    );
+  } catch {
+    return false;
+  }
+}

package/dist/modules/agent/runtime/server/helpers/skills.d.ts

@@ -0,0 +1,14 @@
+import type { PageContext } from '../../shared/types.js';
+import type { ResolvedSkill, SkillDefinition } from '../skills/types.js';
+/**
+ * Resolve the configured skills against the current page context.
+ */
+/**
+ * Resolve a skill label to a string, optionally using the given language.
+ */
+export declare function resolveSkillLabel(label: SkillDefinition['label'], language?: string): string;
+/**
+ * Resolve skills for the given page context.
+ * Calls getContents on each skill and filters out nulls.
+ */
+export declare function resolveSkills(context: PageContext): ResolvedSkill[];

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

@@ -0,0 +1,22 @@
+import { skills } from "#blokkli-build/agent-server";
+export function resolveSkillLabel(label, language) {
+  if (typeof label === "string") return label;
+  if (language && language in label) {
+    return label[language] || label.en;
+  }
+  return label.en;
+}
+export function resolveSkills(context) {
+  return skills.map((skill) => {
+    const content = skill.getContents(context);
+    if (content === null) return null;
+    return {
+      name: skill.name,
+      label: resolveSkillLabel(skill.label, context.interfaceLanguage),
+      englishLabel: resolveSkillLabel(skill.label),
+      description: skill.description,
+      content,
+      tools: skill.tools ?? []
+    };
+  }).filter((s) => s !== null);
+}

package/dist/modules/agent/runtime/server/helpers/socket.d.ts

@@ -0,0 +1,4 @@
+import type { Peer } from 'crossws';
+import type { ServerMessage } from '../../shared/types.js';
+/** Serialize and send a server message to a connected WebSocket peer. */
+export declare function send(peer: Peer, message: ServerMessage): void;

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

@@ -0,0 +1,3 @@
+export function send(peer, message) {
+  peer.send(JSON.stringify(message));
+}

package/dist/modules/agent/runtime/server/helpers/text.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Transform text before sending to client or storing in conversation.
+ * Replaces ß with ss for Swiss German audiences.
+ */
+export declare function transformText(text: string): string;

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

@@ -0,0 +1,3 @@
+export function transformText(text) {
+  return text.replace(/ß/g, "ss");
+}