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

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

@@ -0,0 +1,35 @@
+import { B as BlokkliModule } from '../../shared/editor.DsGJIlGn.mjs';
+import 'nuxt/schema';
+import 'consola';
+import '../../../dist/global/types/definitions.js';
+import '../../../dist/global/types/theme.js';
+import '@nuxt/kit';
+import '../../../dist/global/types/features.js';
+
+type ChartColor = {
+    /**
+     * A valid CSS color value, e.g. '#ff0000', 'rgb(255, 0, 0)',
+     * or 'rgb(var(--theme-color-primary))' for CSS custom properties.
+     */
+    color: string;
+    /**
+     * The label of the color.
+     */
+    label: string;
+};
+type ChartsModuleOptions = {
+    /**
+     * Provide the path to a custom component to render charts.
+     *
+     * @todo not yet implemented
+     */
+    chartRenderComponent?: string;
+    /**
+     * The available chart colors.
+     */
+    colors: Record<string, ChartColor>;
+};
+
+declare const _default: (options: ChartsModuleOptions) => BlokkliModule<ChartsModuleOptions>;
+
+export { _default as default };

package/dist/modules/charts/index.mjs

@@ -0,0 +1,57 @@
+import { createResolver } from '@nuxt/kit';
+import { defineBlokkliModule } from '../index.mjs';
+import { fileURLToPath } from 'node:url';
+import { d as defineCodeTemplate } from '../../shared/editor.6D5vApr0.mjs';
+
+function chartsConfigTemplate(options) {
+  return defineCodeTemplate(
+    "charts-config",
+    () => {
+      return `
+export const COLORS = ${JSON.stringify(options.colors)}
+`;
+    },
+    () => {
+      return `
+import type { ChartColor } from '#blokkli/charts/types'
+
+export const COLORS: Record<string, ChartColor>
+`;
+    },
+    {
+      context: "both",
+      write: true
+    }
+  );
+}
+
+const resolve = createResolver(
+  fileURLToPath(new URL("./", import.meta.url))
+).resolve;
+const index = defineBlokkliModule({
+  alterOptions(options) {
+    options.blokkliDirs ??= [];
+    options.blokkliDirs.push(resolve("./runtime/blokkli"));
+  },
+  setup({ context, helper, $t }, options) {
+    context.addTemplate(chartsConfigTemplate(options));
+    helper.addAlias("#blokkli/charts/types", resolve("./runtime/types"));
+    helper.addAlias(
+      "#blokkli/charts/components",
+      resolve("./runtime/components")
+    );
+    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",
+      editorTitle: $t("chartsEditorTitle", "Edit chart")
+    });
+  }
+});
+
+export { index as default };

package/dist/modules/charts/runtime/blokkli/skills/charts.d.ts

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

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

@@ -0,0 +1,51 @@
+import { defineBlokkliAgentSkill } from "#blokkli/agent/server/skills";
+export default defineBlokkliAgentSkill({
+  name: "charts",
+  label: { en: "Working with charts", de: "Arbeiten mit Diagrammen" },
+  description: "Load this when the user asks about charts or when you need to create or update a chart!",
+  tools: [
+    "create_chart",
+    "update_chart",
+    "get_chart_data",
+    "get_chart_type_options"
+  ],
+  getContents: () => `
+# Charts
+
+## Key concept
+
+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). 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. 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.
+
+## IMPORTANT
+
+- DO NOT use the add_paragraph tool for creating charts! Always use create_chart!
+- DO NOT use the set_paragraph_option tool for updating charts! Always use update_chart!
+
+## Chart types
+
+bar, line, pie, area, donut, heatmap, radialBar, radar.
+
+- pie, donut, radialBar: Single-series charts where each category gets its own color (categoryColors).
+- bar, line, area, heatmap, radar: Multi-series charts where each series has its own color.
+
+Each chart type has different options!
+
+## Colors
+
+Series colors and category colors use color IDs defined in the project configuration. They are auto-assigned if omitted. The valid color IDs are part of the tool schemas (enum values).
+`
+});

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

@@ -0,0 +1,86 @@
+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";
+    area: "area";
+    pie: "pie";
+    donut: "donut";
+    heatmap: "heatmap";
+    radialBar: "radialBar";
+    radar: "radar";
+}>;
+export declare const chartColorEnum: z.ZodEnum<{
+    [x: string]: string;
+}>;
+export declare const chartSeriesSchema: z.ZodObject<{
+    name: z.ZodString;
+    color: z.ZodOptional<z.ZodEnum<{
+        [x: string]: string;
+    }>>;
+    data: z.ZodArray<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const chartDataSchema: z.ZodObject<{
+    title: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    type: z.ZodEnum<{
+        bar: "bar";
+        line: "line";
+        area: "area";
+        pie: "pie";
+        donut: "donut";
+        heatmap: "heatmap";
+        radialBar: "radialBar";
+        radar: "radar";
+    }>;
+    categories: z.ZodArray<z.ZodString>;
+    series: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        color: z.ZodOptional<z.ZodEnum<{
+            [x: string]: string;
+        }>>;
+        data: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>>;
+    categoryColors: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        [x: string]: string;
+    }>>>;
+    footnotes: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    typeOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+}, z.core.$strip>;
+/**
+ * Validate and normalize chart data.
+ *
+ * - Checks series data length matches categories length
+ * - Auto-assigns missing series colors
+ * - Auto-assigns categoryColors for pie/donut/radialBar
+ * - Validates color IDs exist in the provided colors map
+ * - Validates typeOptions keys against the chart type definition
+ * - Fills typeOptions defaults
+ */
+export declare function validateChartData(data: BlokkliChartData, colors: Record<string, ChartColor>): {
+    error: string;
+} | {
+    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

@@ -0,0 +1,136 @@
+import { z } from "zod";
+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"];
+export const chartTypeEnum = z.enum([
+  "bar",
+  "line",
+  "pie",
+  "area",
+  "donut",
+  "heatmap",
+  "radialBar",
+  "radar"
+]);
+const colorIds = Object.keys(COLORS);
+export const chartColorEnum = z.enum(colorIds);
+export const chartSeriesSchema = z.object({
+  name: z.string().describe("Series name (shown in legend)"),
+  color: chartColorEnum.optional().describe(
+    "Color ID from available chart colors. Auto-assigned if omitted."
+  ),
+  data: z.array(z.number()).describe("Data values, one per category")
+});
+export const chartDataSchema = z.object({
+  title: z.string().optional().default("").describe("Chart title"),
+  type: chartTypeEnum.describe("Chart type"),
+  categories: z.array(z.string()).min(1).describe("Category labels (x-axis or slice names)"),
+  series: z.array(chartSeriesSchema).min(1).describe("Data series"),
+  categoryColors: z.array(chartColorEnum).optional().describe(
+    "Color IDs per category (for pie/donut/radialBar). Auto-assigned if omitted."
+  ),
+  footnotes: z.array(z.string()).optional().default([]).describe(
+    "Footnote texts. Reference in categories/series names as {1}, {2}, etc."
+  ),
+  typeOptions: z.record(z.string(), z.union([z.string(), z.boolean(), z.number()])).optional().describe(
+    "Type-specific rendering options. Use get_chart_type_options to see available keys."
+  )
+});
+export function validateChartData(data, colors) {
+  const colorIds2 = Object.keys(colors);
+  for (let i = 0; i < data.series.length; i++) {
+    const series = data.series[i];
+    if (series.data.length !== data.categories.length) {
+      return {
+        error: `Series "${series.name}" has ${series.data.length} data values but there are ${data.categories.length} categories. Each series must have exactly one value per category.`
+      };
+    }
+  }
+  for (let i = 0; i < data.series.length; i++) {
+    const series = data.series[i];
+    if (!series.color) {
+      series.color = getColorIdAtIndex(i, colors);
+    } else if (!colors[series.color]) {
+      return {
+        error: `Invalid color ID "${series.color}" on series "${series.name}". Available colors: ${colorIds2.join(", ")}`
+      };
+    }
+  }
+  const isSingleSeries = SINGLE_SERIES_TYPES.includes(data.type);
+  if (isSingleSeries) {
+    if (!data.categoryColors || data.categoryColors.length !== data.categories.length) {
+      data.categoryColors = data.categories.map(
+        (_, i) => getColorIdAtIndex(i, colors)
+      );
+    } else {
+      for (let i = 0; i < data.categoryColors.length; i++) {
+        const id = data.categoryColors[i];
+        if (!colors[id]) {
+          return {
+            error: `Invalid categoryColor ID "${id}" at index ${i}. Available colors: ${colorIds2.join(", ")}`
+          };
+        }
+      }
+    }
+  } else if (!data.categoryColors || data.categoryColors.length !== data.categories.length) {
+    data.categoryColors = data.categories.map(
+      (_, i) => getColorIdAtIndex(i, colors)
+    );
+  }
+  const defaults = getDefaultTypeOptions(data.type);
+  const typeDef = getChartTypeRuntime(data.type);
+  if (data.typeOptions && typeDef) {
+    for (const key of Object.keys(data.typeOptions)) {
+      if (!(key in typeDef.editor.options)) {
+        const availableKeys = Object.keys(typeDef.editor.options);
+        return {
+          error: `Invalid typeOption "${key}" for chart type "${data.type}". Available options: ${availableKeys.join(", ")}`
+        };
+      }
+    }
+  }
+  data.typeOptions = { ...defaults, ...data.typeOptions || {} };
+  if (!data.footnotes) {
+    data.footnotes = [];
+  }
+  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 ?? null
+  );
+  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.d.ts

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

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

@@ -0,0 +1,93 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import {
+  mutationResultSchema,
+  parentSchema,
+  positionSchema
+} from "#blokkli/agent/app/tools/schemas";
+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,
+  parent: parentSchema.describe("The parent entity to add the chart to"),
+  position: positionSchema
+});
+export default defineBlokkliAgentTool({
+  name: "create_chart",
+  description: "Create a new chart on the page. Series colors are auto-assigned if omitted. For pie/donut/radialBar charts, only the first series is used and each category gets its own color (auto-assigned if categoryColors is omitted). Use get_chart_type_options to discover available typeOptions for the chosen chart type before setting them.",
+  category: "mutation",
+  prunedSummary: (r) => r.success ? "created chart" : "rejected",
+  modes: ["editing"],
+  lazy: true,
+  label($t) {
+    return $t("aiAgentCreateChartRunning", "Creating chart...");
+  },
+  paramsSchema,
+  resultSchema: mutationResultSchema,
+  requiredAdapterMethods: ["addNewBlocks"],
+  execute(ctx, params) {
+    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}`
+      };
+    }
+    const chartBundle = findChartBundle(ctx, field.allowedBundles);
+    if ("error" in chartBundle) {
+      return {
+        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 = {
+      title: params.chart.title,
+      type: params.chart.type,
+      categories: params.chart.categories,
+      series: params.chart.series.map((s) => ({
+        name: s.name,
+        color: s.color || "",
+        data: s.data
+      })),
+      categoryColors: params.chart.categoryColors || [],
+      footnotes: params.chart.footnotes,
+      typeOptions: params.chart.typeOptions || {}
+    };
+    const result = validateChartData(chartData, COLORS);
+    if ("error" in result) return result;
+    const resolved = resolvePosition(
+      ctx.app,
+      params.parent.uuid,
+      params.parent.field,
+      params.position
+    );
+    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.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
+        },
+        afterUuid: resolved.afterUuid
+      })
+    };
+  }
+});

package/dist/modules/charts/runtime/blokkli/tools/get_chart_data/index.d.ts

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

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

@@ -0,0 +1,66 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import {
+  chartTypeEnum,
+  chartColorEnum,
+  chartSeriesSchema,
+  findChartOptionKey
+} from "../chart_schemas.js";
+import { COLORS } from "#blokkli-build/charts-config";
+import { getDefaultChartData } from "../../../helpers/index.js";
+const paramsSchema = z.object({
+  uuid: z.string().describe("UUID of the chart paragraph")
+});
+const resultSchema = z.object({
+  title: z.string().describe("Chart title"),
+  type: chartTypeEnum.describe("Chart type"),
+  categories: z.array(z.string()).describe("Category labels"),
+  series: z.array(chartSeriesSchema.required()).describe("Data series with colors"),
+  categoryColors: z.array(chartColorEnum).describe("Color IDs per category"),
+  footnotes: z.array(z.string()).describe("Footnote texts"),
+  typeOptions: z.record(z.string(), z.union([z.string(), z.boolean(), z.number()])).describe("Current type-specific rendering options")
+});
+export default defineBlokkliAgentTool({
+  name: "get_chart_data",
+  description: "Get the current data of a chart. Returns the chart type, categories, series, colors, footnotes, and typeOptions. Use this to inspect a chart before updating it.",
+  category: "query",
+  volatile: true,
+  prunedSummary: (r) => `chart data (${r.type})`,
+  modes: ["readonly", "editing", "translating", "review"],
+  lazy: true,
+  label($t) {
+    return $t("aiAgentGetChartDataRunning", "Getting chart data...");
+  },
+  paramsSchema,
+  resultSchema,
+  execute(ctx, params) {
+    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 = state.mutatedOptions[params.uuid]?.[chartOption.key] || item?.options?.[chartOption.key];
+    let data;
+    if (rawData) {
+      try {
+        data = JSON.parse(rawData);
+      } catch {
+        data = getDefaultChartData(COLORS);
+      }
+    } else {
+      data = getDefaultChartData(COLORS);
+    }
+    return {
+      result: {
+        title: data.title || "",
+        type: data.type,
+        categories: data.categories,
+        series: data.series,
+        categoryColors: data.categoryColors || [],
+        footnotes: data.footnotes || [],
+        typeOptions: data.typeOptions || {}
+      },
+      label: $t("aiAgentGetChartDataDone", "Got chart data"),
+      affectedUuids: [params.uuid]
+    };
+  }
+});

package/dist/modules/charts/runtime/blokkli/tools/get_chart_type_options/index.d.ts

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

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

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+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({
+  type: chartTypeEnum.describe("The chart type to get options for")
+});
+const resultSchema = z.object({
+  type: z.string().describe("The chart type ID"),
+  options: blockOptionsMapSchema.describe("Available typeOptions")
+});
+export default defineBlokkliAgentTool({
+  name: "get_chart_type_options",
+  description: "Get available typeOptions for a chart type. Call this before setting typeOptions on create_chart or update_chart to know which keys are valid, their types, defaults, and allowed values.",
+  category: "query",
+  volatile: true,
+  lazy: true,
+  prunedSummary: (r) => `options for ${r.type}`,
+  modes: ["editing"],
+  label($t) {
+    return $t("aiAgentGetChartTypeOptionsRunning", "Getting chart options...");
+  },
+  paramsSchema,
+  resultSchema,
+  execute(_ctx, params) {
+    const def = getChartTypeRuntime(params.type);
+    if (!def) {
+      return { error: `Unknown chart type: ${params.type}` };
+    }
+    return {
+      result: {
+        type: params.type,
+        options: buildBlockOptionsMapFromDefinitions(def.editor.options)
+      },
+      label: `Chart options for "${def.editor.label}"`
+    };
+  }
+});

package/dist/modules/charts/runtime/blokkli/tools/update_chart/index.d.ts

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

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

@@ -0,0 +1,89 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { mutationResultSchema } from "#blokkli/agent/app/tools/schemas";
+import {
+  chartTypeEnum,
+  chartColorEnum,
+  chartSeriesSchema,
+  validateChartData,
+  findChartOptionKey
+} from "../chart_schemas.js";
+import { COLORS } from "#blokkli-build/charts-config";
+import { getDefaultChartData } from "../../../helpers/index.js";
+const paramsSchema = z.object({
+  uuid: z.string().describe("UUID of the chart paragraph to update"),
+  title: z.string().optional().describe("Chart title"),
+  type: chartTypeEnum.optional().describe("Chart type"),
+  categories: z.array(z.string()).min(1).optional().describe(
+    "Category labels (x-axis or slice names). Replaces all existing categories."
+  ),
+  series: z.array(chartSeriesSchema).min(1).optional().describe("Data series. Replaces all existing series."),
+  categoryColors: z.array(chartColorEnum).optional().describe(
+    "Color IDs per category (for pie/donut/radialBar). Auto-assigned if omitted."
+  ),
+  footnotes: z.array(z.string()).optional().describe(
+    "Footnote texts. Reference in categories/series names as {1}, {2}, etc."
+  ),
+  typeOptions: z.record(z.string(), z.union([z.string(), z.boolean(), z.number()])).optional().describe(
+    "Type-specific rendering options. Use get_chart_type_options to see available keys."
+  )
+});
+export default defineBlokkliAgentTool({
+  name: "update_chart",
+  description: "Update an existing chart. Provide only the properties you want to change \u2014 they will be merged with the current chart data. Arrays (series, categories, footnotes) are replaced entirely when provided, not merged element-by-element.",
+  category: "mutation",
+  prunedSummary: (r) => r.success ? "updated chart" : "rejected",
+  modes: ["editing"],
+  lazy: true,
+  label($t) {
+    return $t("aiAgentUpdateChartRunning", "Updating chart...");
+  },
+  paramsSchema,
+  resultSchema: mutationResultSchema,
+  requiredAdapterMethods: ["updateOptions"],
+  execute(ctx, params) {
+    const { state } = ctx.app;
+    const chartOption = findChartOptionKey(ctx, params.uuid);
+    if ("error" in chartOption) return chartOption;
+    let current;
+    const item = state.getFieldListItem(params.uuid);
+    const rawData = state.mutatedOptions[params.uuid]?.[chartOption.key] || item?.options?.[chartOption.key];
+    if (rawData) {
+      try {
+        current = JSON.parse(rawData);
+      } catch {
+        current = getDefaultChartData(COLORS);
+      }
+    } else {
+      current = getDefaultChartData(COLORS);
+    }
+    const merged = {
+      title: params.title !== void 0 ? params.title : current.title,
+      type: params.type !== void 0 ? params.type : current.type,
+      categories: params.categories !== void 0 ? params.categories : current.categories,
+      series: params.series !== void 0 ? params.series.map((s) => ({
+        name: s.name,
+        color: s.color || "",
+        data: s.data
+      })) : current.series,
+      categoryColors: params.categoryColors !== void 0 ? params.categoryColors : current.categoryColors,
+      footnotes: params.footnotes !== void 0 ? params.footnotes : current.footnotes,
+      typeOptions: params.typeOptions !== void 0 ? params.typeOptions : current.typeOptions || {}
+    };
+    const result = validateChartData(merged, COLORS);
+    if ("error" in result) return result;
+    const { $t } = ctx.app;
+    return {
+      type: "options",
+      label: $t("aiAgentUpdateChartDone", "Updated chart"),
+      affectedUuids: [params.uuid],
+      apply: (adapter) => adapter.updateOptions([
+        {
+          uuid: params.uuid,
+          key: chartOption.key,
+          value: JSON.stringify(result.data)
+        }
+      ])
+    };
+  }
+});