@blokkli/editor 2.0.0-alpha.36 → 2.0.0-alpha.37

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

@@ -3,6 +3,9 @@ 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();
@@ -11,7 +14,7 @@ export class SessionManager {
     this.pruneTokens();
   }, 6e4);
   create(peerId) {
-    const session = new Session();
+    const session = new Session(this.toolDefinitions);
     this.sessions.set(peerId, { session, lastActivity: Date.now() });
     return session;
   }

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

@@ -2,7 +2,8 @@ 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();
+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 || "";
@@ -69,7 +70,7 @@ export default defineWebSocketHandler({
       }
       switch (data.type) {
         case "init":
-          session.init(data.tools, data.pageContext);
+          session.init(data.toolNames, data.pageContext);
           break;
         case "start":
           if (!apiKey) {

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,69 @@
+import { defineBlokkliAgentSkill } from "../skills/index.js";
+export default defineBlokkliAgentSkill({
+  name: "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.",
+  getContents: () => `
+# Fix Readability - Iterative Workflow
+
+Fixing readability is an **iterative process**. You must verify your rewrites actually improved the scores before moving on.
+
+## Step 1: Analyze
+
+Call \`get_readability_issues\` to get current issues.
+
+The result is an object keyed by paragraph UUID, then by field name:
+\`\`\`
+{
+  "<uuid>": {
+    "<fieldName>": {
+      "fieldValue": "current text",
+      "issues": [
+        { "text": "flagged segment", "impact": "critical", "scores": { "lix": 85 } }
+      ]
+    }
+  }
+}
+\`\`\`
+
+- \`fieldValue\` is the full editable field content.
+- Each issue is a text segment within the field that was flagged, with its own scores.
+- A field can have multiple issues (e.g. a rich text field with several hard-to-read paragraphs).
+
+## Step 2: Pre-check with \`check_readability_for_texts\`
+
+Before applying a rewrite, use \`check_readability_for_texts\` to verify your rewritten text actually scores better. Pass the proposed new text and check that the scores improved compared to the original.
+
+This is cheap and fast \u2014 use it to iterate on your wording before committing a rewrite.
+
+## Step 3: Rewrite
+
+Use \`batch_rewrite_text\` to apply the improved texts. The UUID and field name from the analyze result map directly to the batch_rewrite_text input:
+\`\`\`
+{ "uuids": { "<uuid>": { "<fieldName>": "improved text" } } }
+\`\`\`
+
+When rewriting:
+- Use shorter sentences and simpler words.
+- Keep the original meaning and tone.
+- Focus on fields with "critical" and "serious" impact first.
+
+## Step 4: Verify
+
+After the rewrites are applied, call \`get_readability_issues\` **again** to check if the issues are resolved.
+
+- If issues remain: rewrite again with different wording.
+- If new issues appeared: fix those too.
+- Repeat until no more readability issues are reported.
+
+**Do NOT skip the verification step.** A rewrite can easily make readability worse if sentences become longer or more complex.
+
+## Important
+
+- Always pre-check with \`check_readability_for_texts\` before applying rewrites.
+- Always verify with \`get_readability_issues\` after applying rewrites.
+- Never assume a rewrite fixed the issue.
+- The scores (LIX, CLI, ARI) measure sentence length and word complexity. Lower is easier to read.
+- LIX above 60 is flagged. Above 70 is critical.
+`
+});

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

@@ -51,6 +51,34 @@ export default defineBlokkliAgentSystemPrompt({
         lines.push(formatContentField(field));
       }
     }
+    if (pageContext.contentSearchTabs?.length) {
+      lines.push(
+        "",
+        "## Content Search Tabs",
+        "",
+        "Use the `search_content` tool with one of these tab IDs to search for content:",
+        ""
+      );
+      for (const tab of pageContext.contentSearchTabs) {
+        const typesDescription = tab.types.map((t) => `${t.type} (${t.bundles.join(", ")})`).join(", ");
+        lines.push(`- **\`${tab.id}\`** \u2014 ${tab.title}: ${typesDescription}`);
+      }
+    }
+    if (pageContext.analyzers?.length) {
+      lines.push(
+        "",
+        "## Available Analyzers",
+        "",
+        "Use `get_readability_issues` to run all readability analyzers. The following analyzers are available:",
+        ""
+      );
+      for (const a of pageContext.analyzers) {
+        const parts = [`- **\`${a.id}\`**`];
+        if (a.label) parts.push(`\u2014 ${a.label}`);
+        if (a.description) parts.push(`: ${a.description}`);
+        lines.push(parts.join(""));
+      }
+    }
     const editModeDescription = getEditModeDescription(pageContext.editMode);
     if (editModeDescription) {
       lines.push("", "## Edit Mode", "", editModeDescription);

package/dist/modules/agent/runtime/server/server-tools/index.d.ts

@@ -23,7 +23,10 @@ export type ToolResultEntry = {
 export type ToolDefinitionContext = {
     resolvedSkills: ResolvedSkill[];
     plan: ServerPlan | null;
-    unloadedLazyTools: ClientToolDefinition[];
+    unloadedLazyTools: {
+        name: string;
+        description: string;
+    }[];
 };
 /**
  * Context passed to `handle()` — provides access to session state
@@ -33,7 +36,7 @@ export type ServerToolContext = {
     toolUseId: string;
     send: (message: ServerMessage) => void;
     resolvedSkills: ResolvedSkill[];
-    lazyTools: ClientToolDefinition[];
+    lazyToolNames: string[];
     activatedLazyTools: Set<string>;
     loadedSkills: Set<string>;
     plan: ServerPlan | null;
@@ -79,6 +82,11 @@ export type ServerSideTool<T extends z.ZodType = z.ZodType> = {
  * Identity function for type inference when defining a server-side tool.
  */
 export declare function defineServerSideTool<T extends z.ZodType>(tool: ServerSideTool<T>): ServerSideTool<T>;
+/**
+ * Recursively strip $schema and additionalProperties from a JSON Schema object.
+ * These are unnecessary for the LLM and waste context window tokens.
+ */
+export declare function stripSchemaOverhead(obj: unknown): unknown;
 /**
  * Build a ClientToolDefinition from a ServerSideTool for a given context.
  * Returns null when the tool should not be offered this turn.

package/dist/modules/agent/runtime/server/server-tools/index.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 export function defineServerSideTool(tool) {
   return tool;
 }
-function stripSchemaOverhead(obj) {
+export function stripSchemaOverhead(obj) {
   if (Array.isArray(obj)) {
     return obj.map(stripSchemaOverhead);
   }

package/dist/modules/agent/runtime/server/server-tools/load_tools/index.js

@@ -18,7 +18,7 @@ export default defineServerSideTool({
   handle(ctx, input) {
     const loaded = [];
     for (const name of input.tools) {
-      if (ctx.lazyTools.some((t) => t.name === name)) {
+      if (ctx.lazyToolNames.includes(name)) {
         ctx.activatedLazyTools.add(name);
         loaded.push(name);
       }

package/dist/modules/agent/runtime/shared/types.d.ts

@@ -113,6 +113,21 @@ export type BlockBundle = {
  * Edit mode determines what actions the user is allowed to perform.
  */
 export type EditMode = 'readonly' | 'editing' | 'translating' | 'review';
+/**
+ * Server-side tool metadata extracted at build time.
+ * Contains only static properties needed by the server — no execute(), label(),
+ * component, or other runtime-only fields.
+ */
+export type ServerToolMetadata = {
+    name: string;
+    description: string;
+    category: 'query' | 'mutation';
+    modes: EditMode[];
+    paramsSchema: z.ZodType;
+    lazy?: boolean;
+    volatile?: boolean;
+    requiredAdapterMethods?: string[];
+};
 /**
  * Fragment definition for reusable content blocks.
  */
@@ -152,6 +167,22 @@ export type PageContext = {
     fragments: Fragment[];
     /** Content fields on the page entity itself (e.g., lead text, hero image) */
     entityContentFields: BlockBundleContentField[];
+    /** Available content search tabs (for the search_content tool) */
+    contentSearchTabs?: {
+        id: string;
+        title: string;
+        types: {
+            type: string;
+            bundles: string[];
+        }[];
+    }[];
+    /** Available content analyzers (for the get_readability_issues tool) */
+    analyzers?: {
+        id: string;
+        type?: string;
+        label?: string;
+        description?: string;
+    }[];
 };
 /**
  * Classified error categories for AI provider errors.
@@ -266,17 +297,7 @@ export declare const clientMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     authToken: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"init">;
-    tools: z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        description: z.ZodString;
-        input_schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        lazy: z.ZodOptional<z.ZodBoolean>;
-        category: z.ZodOptional<z.ZodEnum<{
-            query: "query";
-            mutation: "mutation";
-        }>>;
-        volatile: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
+    toolNames: z.ZodArray<z.ZodString>;
     pageContext: z.ZodObject<{
         title: z.ZodString;
         entityType: z.ZodString;
@@ -347,6 +368,20 @@ export declare const clientMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 bundles: z.ZodArray<z.ZodString>;
             }, z.core.$strip>>;
         }, z.core.$strip>]>>;
+        contentSearchTabs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            types: z.ZodArray<z.ZodObject<{
+                type: z.ZodString;
+                bundles: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        analyzers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"start">;

package/dist/modules/agent/runtime/shared/types.js

@@ -66,7 +66,27 @@ const pageContextSchema = z.object({
   isPublished: z.boolean().nullable(),
   editMode: z.enum(["readonly", "editing", "translating", "review"]),
   fragments: z.array(fragmentSchema),
-  entityContentFields: z.array(blockBundleContentFieldSchema)
+  entityContentFields: z.array(blockBundleContentFieldSchema),
+  contentSearchTabs: z.array(
+    z.object({
+      id: z.string(),
+      title: z.string(),
+      types: z.array(
+        z.object({
+          type: z.string(),
+          bundles: z.array(z.string())
+        })
+      )
+    })
+  ).optional(),
+  analyzers: z.array(
+    z.object({
+      id: z.string(),
+      type: z.string().optional(),
+      label: z.string().optional(),
+      description: z.string().optional()
+    })
+  ).optional()
 });
 const pageStructureBlockSchema = z.lazy(
   () => z.object({
@@ -81,14 +101,6 @@ export const pageStructureSchema = z.object({
   fields: z.record(z.string(), z.array(pageStructureBlockSchema)),
   entityContentFields: z.record(z.string(), z.string()).optional()
 });
-const clientToolDefinitionSchema = z.object({
-  name: z.string(),
-  description: z.string(),
-  input_schema: z.record(z.string(), z.unknown()),
-  lazy: z.boolean().optional(),
-  category: z.enum(["query", "mutation"]).optional(),
-  volatile: z.boolean().optional()
-});
 const genericContentBlockSchema = z.discriminatedUnion("type", [
   z.object({ type: z.literal("text"), text: z.string() }),
   z.object({ type: z.literal("skill"), name: z.string(), text: z.string() }),
@@ -118,7 +130,7 @@ export const clientMessageSchema = z.discriminatedUnion("type", [
   z.object({ type: z.literal("authenticate"), authToken: z.string() }),
   z.object({
     type: z.literal("init"),
-    tools: z.array(clientToolDefinitionSchema),
+    toolNames: z.array(z.string()),
     pageContext: pageContextSchema
   }),
   z.object({

package/dist/modules/charts/index.d.mts

@@ -1,4 +1,4 @@
-import { B as BlokkliModule } from '../../shared/editor.CWQIFIEQ.mjs';
+import { B as BlokkliModule } from '../../shared/editor.BdBm1Z7C.mjs';
 import 'nuxt/schema';
 import 'consola';
 import '../../../dist/global/types/definitions.js';

package/dist/modules/charts/index.mjs

@@ -17,6 +17,10 @@ import type { ChartColor } from '#blokkli/charts/types'
 
 export const COLORS: Record<string, ChartColor>
 `;
+    },
+    {
+      context: "both",
+      write: true
     }
   );
 }
@@ -29,14 +33,24 @@ const index = defineBlokkliModule({
     options.blokkliDirs ??= [];
     options.blokkliDirs.push(resolve("./runtime/blokkli"));
   },
-  setup(ctx, options) {
-    ctx.context.blocks.addFile(
-      resolve("./runtime/components/Fragment/BlokkliChart.vue")
+  setup({ context, helper, $t }, options) {
+    context.features.addFile(resolve("./runtime/features/charts/index.vue"));
+    context.addTemplate(chartsConfigTemplate(options));
+    helper.addAlias("#blokkli/charts/types", resolve("./runtime/types"));
+    helper.addAlias(
+      "#blokkli/charts/components",
+      resolve("./runtime/components")
     );
-    ctx.context.features.addFile(resolve("./runtime/features/charts/index.vue"));
-    ctx.context.addFeatureFragment("blokkli_chart");
-    ctx.context.addTemplate(chartsConfigTemplate(options));
-    ctx.helper.addAlias("#blokkli/charts/types", resolve("./runtime/types"));
+    context.registerComplexOptionType({
+      id: "chart",
+      typeName: "BlokkliChartData",
+      typePath: resolve("./runtime/types"),
+      editorComponentPath: resolve(
+        "./runtime/features/charts/Editor/index.vue"
+      ),
+      editorButtonLabel: $t("chartsEditButton", "Edit chart..."),
+      editorIcon: "bk_mdi_area_chart"
+    });
   }
 });
 

package/dist/modules/charts/runtime/blokkli/skills/charts.js

@@ -2,27 +2,27 @@ import { defineBlokkliAgentSkill } from "#blokkli/agent/server/skills";
 export default defineBlokkliAgentSkill({
   name: "charts",
   label: { en: "Working with charts", de: "Arbeiten mit Diagrammen" },
-  description: "How charts work in bl\xF6kkli. LOAD THIS when the user asks about charts or when you need to create or update a chart! Charts are a special blokkli_fragment.",
+  description: "How charts work in bl\xF6kkli. LOAD THIS when the user asks about charts or when you need to create or update a chart!",
   getContents: () => `
 # Charts
 
-Charts are implemented as **fragments** with the bundle "blokkli_fragment" and the fragment name "blokkli_chart". When you see a paragraph with bundle "blokkli_fragment" and fragmentName "blokkli_chart", that IS the chart paragraph.
+Charts are NOT a specific block bundle. Instead, charts are a **complex option type**: any block can have a JSON option with \`dataType: 'chart'\`. The chart data is stored as a JSON string in that option. The option key can be anything (e.g. "data", "chart", etc.) \u2014 the tools detect it automatically.
 
 ## Key concept
 
-The chart paragraph's UUID is what you pass directly to the chart tools. There is no separate "chart entity" inside the fragment \u2014 the fragment IS the chart.
+A "chart block" is any block whose definition has a JSON option with \`dataType: 'chart'\`. The chart tools automatically detect which option holds chart data, so you don't need to know the option key or bundle name.
 
 ## Available tools
 
 - **get_chart_data**: Read the current chart data (type, categories, series, colors, typeOptions). Always call this first when modifying an existing chart!
-- **create_chart**: Create a new chart. Requires chart data (type, categories, series).
-- **update_chart**: Update an existing chart. Pass the fragment paragraph's UUID and only the properties you want to change (title, type, categories, series, categoryColors, footnotes, typeOptions).
+- **create_chart**: Create a new chart. Requires chart data (type, categories, series). The tool automatically finds which bundle in the target field has a chart option.
+- **update_chart**: Update an existing chart. Pass the block's UUID and only the properties you want to change (title, type, categories, series, categoryColors, footnotes, typeOptions).
 - **get_chart_type_options**: Get available typeOptions for a chart type. Call this to discover which rendering options exist (e.g. stacked, horizontal for bar charts) before setting typeOptions.
 
 ## Workflow
 
 1. To **read** a chart's current state: use get_chart_data with the paragraph UUID.
-2. To **create** a chart: use create_chart with the data.
+2. To **create** a chart: use create_chart with the data. The tool finds the right bundle automatically from the target field's allowed bundles.
 3. To **modify** a chart: first call get_chart_data to see the current state, then use update_chart with only the properties you want to change.
 4. To **change rendering options** (e.g. stacked bars, smooth lines, grid lines): first call get_chart_type_options with the chart type to see available options, then use update_chart with the typeOptions property.
 

package/dist/modules/charts/runtime/blokkli/tools/chart_schemas.d.ts

@@ -1,10 +1,11 @@
 import { z } from 'zod';
 import type { BlokkliChartData, ChartColor } from '#blokkli/charts/types';
+import type { McpToolContext } from '#blokkli/agent/app/types';
 export declare const chartTypeEnum: z.ZodEnum<{
     bar: "bar";
     line: "line";
-    pie: "pie";
     area: "area";
+    pie: "pie";
     donut: "donut";
     heatmap: "heatmap";
     radialBar: "radialBar";
@@ -25,8 +26,8 @@ export declare const chartDataSchema: z.ZodObject<{
     type: z.ZodEnum<{
         bar: "bar";
         line: "line";
-        pie: "pie";
         area: "area";
+        pie: "pie";
         donut: "donut";
         heatmap: "heatmap";
         radialBar: "radialBar";
@@ -61,3 +62,25 @@ export declare function validateChartData(data: BlokkliChartData, colors: Record
 } | {
     data: BlokkliChartData;
 };
+/**
+ * Find the option key for a chart option on a block.
+ *
+ * Charts are stored as a JSON option with `dataType: 'chart'` on any block.
+ * This helper looks up the block's definition and returns the option key.
+ */
+export declare function findChartOptionKey(ctx: McpToolContext, uuid: string): {
+    key: string;
+} | {
+    error: string;
+};
+/**
+ * Find a bundle that has a chart option among a field's allowed bundles.
+ *
+ * Returns the bundle name and the option key for the chart data.
+ */
+export declare function findChartBundle(ctx: McpToolContext, allowedBundles: string[]): {
+    bundle: string;
+    key: string;
+} | {
+    error: string;
+};

package/dist/modules/charts/runtime/blokkli/tools/chart_schemas.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { getColorIdAtIndex } from "#blokkli/charts/types";
+import { getColorIdAtIndex } from "../../helpers/index.js";
 import { getChartTypeRuntime, getDefaultTypeOptions } from "../../chartTypes/index.js";
 import { COLORS } from "#blokkli-build/charts-config";
 const SINGLE_SERIES_TYPES = ["pie", "donut", "radialBar"];
@@ -96,3 +96,41 @@ export function validateChartData(data, colors) {
   }
   return { data };
 }
+export function findChartOptionKey(ctx, uuid) {
+  const { blocks, definitions, selection } = ctx.app;
+  const block = blocks.getBlock(uuid);
+  if (!block) return { error: `Paragraph not found: ${uuid}` };
+  const bundle = block.library?.reusableBundle || block.bundle;
+  const selectionItem = selection.items.value.find((v) => v.uuid === uuid);
+  const definition = definitions.getBlockDefinition(
+    bundle,
+    selectionItem?.fieldListType ?? "default",
+    selectionItem?.parentBlockBundle
+  );
+  if (!definition?.options) {
+    return { error: `Paragraph "${uuid}" (${bundle}) has no chart option.` };
+  }
+  const chartEntry = Object.entries(definition.options).find(
+    ([_, opt]) => opt.type === "json" && "dataType" in opt && opt.dataType === "chart"
+  );
+  if (!chartEntry) {
+    return { error: `Paragraph "${uuid}" (${bundle}) has no chart option.` };
+  }
+  return { key: chartEntry[0] };
+}
+export function findChartBundle(ctx, allowedBundles) {
+  const { definitions } = ctx.app;
+  for (const bundle of allowedBundles) {
+    const def = definitions.getDefaultDefinition(bundle);
+    if (!def?.options) continue;
+    const entry = Object.entries(def.options).find(
+      ([_, opt]) => opt.type === "json" && "dataType" in opt && opt.dataType === "chart"
+    );
+    if (entry) {
+      return { bundle, key: entry[0] };
+    }
+  }
+  return {
+    error: `No block type with a chart option is allowed in this field.`
+  };
+}

package/dist/modules/charts/runtime/blokkli/tools/create_chart/index.js

@@ -3,10 +3,14 @@ import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import {
   mutationResultSchema,
   parentSchema,
-  positionSchema,
-  resolvePosition
+  positionSchema
 } from "#blokkli/agent/app/tools/schemas";
-import { chartDataSchema, validateChartData } from "../chart_schemas.js";
+import { resolvePosition } from "#blokkli/agent/app/tools/helpers";
+import {
+  chartDataSchema,
+  validateChartData,
+  findChartBundle
+} from "../chart_schemas.js";
 import { COLORS } from "#blokkli-build/charts-config";
 const paramsSchema = z.object({
   chart: chartDataSchema,
@@ -25,24 +29,19 @@ export default defineBlokkliAgentTool({
   },
   paramsSchema,
   resultSchema: mutationResultSchema,
-  requiredAdapterMethods: ["fragmentsAddBlock"],
+  requiredAdapterMethods: ["addNewBlocks"],
   execute(ctx, params) {
-    const { fields, definitions } = ctx.app;
-    const fragment = definitions.fragmentDefinitions.value.find(
-      (f) => f.name === "blokkli_chart"
-    );
-    if (!fragment) {
-      return { error: 'Chart fragment "blokkli_chart" is not available.' };
-    }
+    const { fields } = ctx.app;
     const field = fields.find(params.parent.uuid, params.parent.field);
     if (!field) {
       return {
         error: `Field not found: ${params.parent.field} on entity ${params.parent.uuid}`
       };
     }
-    if (!field.allowedFragments.includes("blokkli_chart")) {
+    const chartBundle = findChartBundle(ctx, field.allowedBundles);
+    if ("error" in chartBundle) {
       return {
-        error: `Field "${params.parent.field}" does not allow the "blokkli_chart" fragment. Allowed fragments: ${field.allowedFragments.length ? field.allowedFragments.join(", ") : "none"}`
+        error: `No block type with a chart option is allowed in field "${params.parent.field}". Allowed bundles: ${field.allowedBundles.length ? field.allowedBundles.join(", ") : "none"}`
       };
     }
     const chartData = {
@@ -68,18 +67,26 @@ export default defineBlokkliAgentTool({
     );
     if ("error" in resolved) return resolved;
     const { $t } = ctx.app;
+    const blockUuid = crypto.randomUUID();
     return {
       type: "add",
       label: $t("aiAgentCreateChartDone", "Added chart"),
-      apply: (adapter) => adapter.fragmentsAddBlock({
-        name: "blokkli_chart",
+      apply: (adapter) => adapter.addNewBlocks({
+        blocks: [
+          {
+            bundle: chartBundle.bundle,
+            blockUuid,
+            options: {
+              [chartBundle.key]: JSON.stringify(result.data)
+            }
+          }
+        ],
         host: {
           type: params.parent.type,
           uuid: params.parent.uuid,
           fieldName: params.parent.field
         },
-        preceedingUuid: resolved.afterUuid,
-        options: { data: JSON.stringify(result.data) }
+        afterUuid: resolved.afterUuid
       })
     };
   }

package/dist/modules/charts/runtime/blokkli/tools/get_chart_data/index.js

@@ -1,9 +1,13 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import { chartTypeEnum, chartColorEnum, chartSeriesSchema } from "../chart_schemas.js";
+import {
+  chartTypeEnum,
+  chartColorEnum,
+  chartSeriesSchema,
+  findChartOptionKey
+} from "../chart_schemas.js";
 import { COLORS } from "#blokkli-build/charts-config";
-import { getDefaultChartData } from "#blokkli/charts/types";
-import { fragmentBlockBundle } from "#blokkli-build/config";
+import { getDefaultChartData } from "../../../helpers/index.js";
 const paramsSchema = z.object({
   uuid: z.string().describe("UUID of the chart paragraph")
 });
@@ -30,23 +34,11 @@ export default defineBlokkliAgentTool({
   paramsSchema,
   resultSchema,
   execute(ctx, params) {
-    const { blocks, state, $t } = ctx.app;
-    const block = blocks.getBlock(params.uuid);
-    if (!block) {
-      return { error: `Paragraph not found: ${params.uuid}` };
-    }
-    if (block.bundle !== fragmentBlockBundle) {
-      return {
-        error: `Paragraph "${params.uuid}" is a "${block.bundle}", not a fragment.`
-      };
-    }
-    if (block.fragment?.name !== "blokkli_chart") {
-      return {
-        error: `Fragment "${params.uuid}" is a "${block.fragment?.name}", not a "blokkli_chart".`
-      };
-    }
+    const { state, $t } = ctx.app;
+    const chartOption = findChartOptionKey(ctx, params.uuid);
+    if ("error" in chartOption) return chartOption;
     const item = state.getFieldListItem(params.uuid);
-    const rawData = item?.options?.data;
+    const rawData = item?.options?.[chartOption.key];
     let data;
     if (rawData) {
       try {

package/dist/modules/charts/runtime/blokkli/tools/get_chart_type_options/index.js

@@ -1,9 +1,7 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import {
-  blockOptionsMapSchema,
-  buildBlockOptionsMapFromDefinitions
-} from "#blokkli/agent/app/tools/schemas";
+import { blockOptionsMapSchema } from "#blokkli/agent/app/tools/schemas";
+import { buildBlockOptionsMapFromDefinitions } from "#blokkli/agent/app/tools/helpers";
 import { getChartTypeRuntime } from "../../../chartTypes/index.js";
 import { chartTypeEnum } from "../chart_schemas.js";
 const paramsSchema = z.object({