@blokkli/editor 2.0.0-alpha.60 → 2.0.0-alpha.62

package/dist/modules/agent/runtime/app/tools/add_template/index.js

@@ -2,25 +2,27 @@ import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { mutationResultSchema, parentSchema, positionSchema } from "../schemas.js";
 import { resolvePosition } from "../helpers.js";
-const paramsSchema = z.object({
+import { countNewParagraphs } from "#blokkli/agent/app/helpers/mutationResult";
+export const paramsSchema = z.object({
   templateUuid: z.string().describe(
     "The UUID of the template to add (from search_templates results)"
   ),
   parent: parentSchema.describe("The parent entity to add the template to"),
   position: positionSchema
 });
+export const resultSchema = mutationResultSchema;
 export default defineBlokkliAgentTool({
   name: "add_template",
   description: "Add a template to the page. Templates are copied when added, so changes to the added paragraphs won't affect other pages using the same template.",
   category: "mutation",
-  prunedSummary: (r) => r.success ? `added template (${r.newParagraphs?.length || 0} paragraphs)` : "rejected",
+  prunedSummary: (r) => r.success ? `added template (${countNewParagraphs(r.newParagraphs ?? [])} paragraphs)` : "rejected",
   lazy: true,
   modes: ["editing"],
   label($t) {
     return $t("aiAgentAddTemplateRunning", "Adding template", { more: true });
   },
   paramsSchema,
-  resultSchema: mutationResultSchema,
+  resultSchema,
   requiredAdapterMethods: ["templatesAdd"],
   execute(ctx, params) {
     const { fields, $t } = ctx.app;

package/dist/modules/agent/runtime/app/tools/ask_question/index.d.ts

@@ -1,14 +1,14 @@
 import { z } from 'zod';
-declare const paramsSchema: z.ZodObject<{
+export declare const paramsSchema: z.ZodObject<{
     question: z.ZodString;
     options: z.ZodArray<z.ZodObject<{
         value: z.ZodString;
         label: z.ZodString;
     }, z.core.$strip>>;
-    multiSelect: any;
+    multiSelect: z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>>;
     paragraphUuids: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
-declare const resultSchema: z.ZodObject<{
+export declare const resultSchema: z.ZodObject<{
     selected: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
     label: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;

package/dist/modules/agent/runtime/app/tools/ask_question/index.js

@@ -1,22 +1,23 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import { booleanParam } from "#blokkli/agent/shared/toolParams";
+import { booleanParamWithDefault } from "../../../shared/toolParams.js";
 import Component from "./Component.vue";
 const optionSchema = z.object({
   value: z.string().describe("The option value"),
   label: z.string().describe("The display label")
 });
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   question: z.string().describe("The question to ask the user"),
   options: z.array(optionSchema).describe("Available options to choose from"),
-  multiSelect: booleanParam(
-    `Allow selecting multiple options. If false, the user has the option to enter a custom option if none of the options are good.`
-  ).default(false),
+  multiSelect: booleanParamWithDefault(
+    `Allow selecting multiple options. If false, the user has the option to enter a custom option if none of the options are good.`,
+    false
+  ),
   paragraphUuids: z.array(z.string()).optional().describe(
     "Optional UUIDs of paragraphs this question relates to. When provided, these paragraphs will be highlighted on the page."
   )
 });
-const resultSchema = z.object({
+export const resultSchema = z.object({
   selected: z.union([z.string(), z.array(z.string())]).nullable().describe("Selected value(s), or null if cancelled"),
   label: z.string().optional().describe("Human-readable label of what was selected (for UI display)")
 });

package/dist/modules/agent/runtime/app/tools/auto_translate_paragraphs/index.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { fieldDiffResultSchema } from '../schemas.js';
 import { type SkippedField } from '../fieldDiffApproval.js';
-declare const paramsSchema: z.ZodObject<{
+export declare const paramsSchema: z.ZodObject<{
     uuids: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type AutoTranslateParams = z.infer<typeof paramsSchema>;
@@ -15,5 +15,14 @@ export type ComponentParams = {
     uuids: string[];
     skipped: SkippedField[];
 };
+export declare const resultSchema: z.ZodObject<{
+    acceptedCount: z.ZodNumber;
+    rejectedByUser: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+        reasonForRejection: z.ZodString;
+    }, z.core.$strip>>>;
+    label: z.ZodString;
+    agentMessage: z.ZodOptional<z.ZodString>;
+    historyIndex: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
 declare const _default: any;
 export default _default;

package/dist/modules/agent/runtime/app/tools/auto_translate_paragraphs/index.js

@@ -5,17 +5,17 @@ import {
   requireNoRestrictedAncestor
 } from "../../helpers/validation.js";
 import { onlyUnique } from "#blokkli/helpers";
-import { fieldDiffResultSchema } from "../schemas.js";
-import { stringArrayParam } from "../schemas.js";
+import { fieldDiffResultSchema, stringArrayParam } from "../schemas.js";
 import { resolveHost } from "../helpers.js";
 import { skippedFieldsMessage } from "../fieldDiffApproval.js";
 import Component from "./Component.vue";
 import DetailsComponent from "../../components/FieldDiffDetails/index.vue";
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   uuids: stringArrayParam(
     "UUIDs of paragraphs to auto-translate. Every editable text field on each paragraph is sent to the backend's translation service. The user reviews and accepts/rejects each translation before it is applied. The source language is always the host entity's source language; the target language is the currently-edited language."
   )
 });
+export const resultSchema = fieldDiffResultSchema;
 export default defineBlokkliAgentTool({
   name: "auto_translate_paragraphs",
   description: "Translate every editable text field of one or more paragraphs into the currently-edited language using the backend's configured translation service (e.g. DeepL via Drupal) \u2014 not the agent's own LLM. The user reviews each translation in a diff approval UI before it is applied. Only available in translating mode and only when the adapter exposes a translation service. Prefer this when the user asks for an automatic translation; use `delegate_text_rewrite` with `template: 'translate'` only when the user specifically wants the agent to do the translation, or when no backend translation service is configured.",
@@ -29,7 +29,7 @@ export default defineBlokkliAgentTool({
     });
   },
   paramsSchema,
-  resultSchema: fieldDiffResultSchema,
+  resultSchema,
   requiredAdapterMethods: [
     "loadTextFieldValuesForLanguage",
     "requestTranslation",

package/dist/modules/agent/runtime/app/tools/check_readability_for_texts/index.d.ts

@@ -1,2 +1,19 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    texts: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodObject<{
+    results: z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+        level: z.ZodEnum<{
+            unknown: "unknown";
+            ok: "ok";
+            good: "good";
+            hard: "hard";
+        }>;
+        score: z.ZodNullable<z.ZodNumber>;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 declare const _default: any;
 export default _default;

package/dist/modules/agent/runtime/app/tools/check_readability_for_texts/index.js

@@ -7,12 +7,12 @@ const textResultSchema = z.object({
   score: z.number().nullable(),
   note: z.string().optional()
 });
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   texts: z.array(z.string()).describe(
     "Text strings to check for readability. Each string is analyzed independently."
   )
 });
-const resultSchema = z.object({
+export const resultSchema = z.object({
   results: z.array(textResultSchema)
 });
 export default defineBlokkliAgentTool({

package/dist/modules/agent/runtime/app/tools/delegate_text_rewrite/index.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { fieldDiffResultSchema } from '../schemas.js';
 import { type SkippedField } from '../fieldDiffApproval.js';
-declare const paramsSchema: z.ZodObject<{
+export declare const paramsSchema: z.ZodObject<{
     request: z.ZodDiscriminatedUnion<[z.ZodObject<{
         template: z.ZodLiteral<"fix_readability">;
     }, z.core.$strip>, z.ZodObject<{
@@ -37,5 +37,14 @@ export type ComponentParams = {
     /** Field references dropped because the paragraph/field doesn't exist. */
     skipped: SkippedField[];
 };
+export declare const resultSchema: z.ZodObject<{
+    acceptedCount: z.ZodNumber;
+    rejectedByUser: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+        reasonForRejection: z.ZodString;
+    }, z.core.$strip>>>;
+    label: z.ZodString;
+    agentMessage: z.ZodOptional<z.ZodString>;
+    historyIndex: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
 declare const _default: any;
 export default _default;

package/dist/modules/agent/runtime/app/tools/delegate_text_rewrite/index.js

@@ -39,10 +39,11 @@ const requestSchema = z.discriminatedUnion("template", [
 ]).describe(
   "The transform to perform. Pick a template and provide its parameters:\n- fix_readability: fix flagged readability issues (no extra params \u2014 issues are resolved automatically).\n- translate: translate all fields into `targetLanguage`.\n- rewrite: general-purpose rewrite using `instruction`.\n- generate_content: write new content using `instruction` (optional `context`)."
 );
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   request: requestSchema,
   fields: z.array(fieldSchema).describe("The fields to transform (UUIDs and field names only)")
 });
+export const resultSchema = fieldDiffResultSchema;
 export default defineBlokkliAgentTool({
   name: "delegate_text_rewrite",
   description: "Rewrite, translate, fix readability, or generate text fields with live streaming preview. Set `request` to the chosen template and its parameters (see the request field). The content will be streamed live into the page for immediate visual feedback.",
@@ -56,7 +57,7 @@ export default defineBlokkliAgentTool({
     });
   },
   paramsSchema,
-  resultSchema: fieldDiffResultSchema,
+  resultSchema,
   requiredAdapterMethods: ["updateFieldValueBatched"],
   component: Component,
   detailsComponent: DetailsComponent,

package/dist/modules/agent/runtime/app/tools/delete_paragraphs/index.d.ts

@@ -1,2 +1,18 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    uuids: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodEnum<{
+        rewrite: "rewrite";
+        delete: "delete";
+        add: "add";
+        move: "move";
+        options: "options";
+    }>;
+    label: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
 declare const _default: any;
 export default _default;

package/dist/modules/agent/runtime/app/tools/delete_paragraphs/index.js

@@ -5,9 +5,10 @@ import {
   requireBundlePermission,
   requireNoRestrictedAncestor
 } from "../../helpers/validation.js";
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   uuids: z.array(z.string()).describe("The UUIDs of the paragraphs to delete")
 });
+export const resultSchema = mutationResultSchema;
 export default defineBlokkliAgentTool({
   name: "delete_paragraphs",
   description: "Delete one or more paragraphs from the page.",
@@ -19,7 +20,7 @@ export default defineBlokkliAgentTool({
     return $t("aiAgentDeleteBlocksRunning", "Deleting blocks", { more: true });
   },
   paramsSchema,
-  resultSchema: mutationResultSchema,
+  resultSchema,
   requiredAdapterMethods: ["deleteBlocks"],
   execute(ctx, params) {
     const { blocks, types } = ctx.app;

package/dist/modules/agent/runtime/app/tools/detach_reusable_paragraph/index.d.ts

@@ -1,2 +1,18 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    uuids: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodEnum<{
+        rewrite: "rewrite";
+        delete: "delete";
+        add: "add";
+        move: "move";
+        options: "options";
+    }>;
+    label: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
 declare const _default: any;
 export default _default;

package/dist/modules/agent/runtime/app/tools/detach_reusable_paragraph/index.js

@@ -6,9 +6,10 @@ import {
   requireNoRestrictedAncestor
 } from "../../helpers/validation.js";
 import { fromLibraryBlockBundle } from "#blokkli-build/config";
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   uuids: z.array(z.string()).describe("UUIDs of library paragraphs to detach")
 });
+export const resultSchema = mutationResultSchema;
 export default defineBlokkliAgentTool({
   name: "detach_reusable_paragraph",
   description: "Detach one or more library paragraphs to create editable copies. IMPORTANT: The original library paragraph UUIDs will no longer exist after detaching. The result includes newParagraphs containing the UUIDs and bundles of the newly created editable paragraph. Use these new UUIDs for any subsequent operations.",
@@ -22,7 +23,7 @@ export default defineBlokkliAgentTool({
     });
   },
   paramsSchema,
-  resultSchema: mutationResultSchema,
+  resultSchema,
   requiredAdapterMethods: ["detachReusableBlock"],
   execute(ctx, params) {
     const { blocks, $t } = ctx.app;

package/dist/modules/agent/runtime/app/tools/duplicate_paragraphs/index.d.ts

@@ -1,2 +1,24 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    uuids: z.ZodArray<z.ZodString>;
+    parent: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        uuid: z.ZodString;
+        field: z.ZodString;
+    }, z.core.$strip>>;
+    position: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodEnum<{
+        rewrite: "rewrite";
+        delete: "delete";
+        add: "add";
+        move: "move";
+        options: "options";
+    }>;
+    label: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
 declare const _default: any;
 export default _default;

package/dist/modules/agent/runtime/app/tools/duplicate_paragraphs/index.js

@@ -11,18 +11,20 @@ import {
   requireNoRestrictedAncestor
 } from "../../helpers/validation.js";
 import { getFieldKey } from "#blokkli/helpers";
-const paramsSchema = z.object({
+import { countNewParagraphs } from "#blokkli/agent/app/helpers/mutationResult";
+export const paramsSchema = z.object({
   uuids: z.array(z.string()).min(1).describe("Paragraph UUIDs to duplicate"),
   parent: parentSchema.optional().describe("Target parent field. If omitted, duplicates in same field."),
   position: positionSchema.describe(
     'Where to place the duplicated paragraphs (only when parent is provided). Defaults to "end".'
   )
 });
+export const resultSchema = mutationResultSchema;
 export default defineBlokkliAgentTool({
   name: "duplicate_paragraphs",
   description: "Duplicate one or more paragraphs, with ALL their child paragraphs. Without parent parameter, duplicates in the same field. With parent parameter, duplicates to a different field.",
   category: "mutation",
-  prunedSummary: (r) => r.success ? `duplicated ${r.newParagraphs?.length || 0} paragraphs` : "rejected",
+  prunedSummary: (r) => r.success ? `duplicated ${countNewParagraphs(r.newParagraphs ?? [])} paragraphs` : "rejected",
   modes: ["editing"],
   lazy: true,
   label($t) {
@@ -31,7 +33,7 @@ export default defineBlokkliAgentTool({
     });
   },
   paramsSchema,
-  resultSchema: mutationResultSchema,
+  resultSchema,
   requiredAdapterMethods: ["duplicateBlocks"],
   execute(ctx, params) {
     const { $t, types } = ctx.app;

package/dist/modules/agent/runtime/app/tools/find_paragraphs/index.d.ts

@@ -1,2 +1,33 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    bundle: z.ZodOptional<z.ZodString>;
+    bundles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    hasChildren: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>;
+    isRootLevel: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>;
+    nestingLevel: z.ZodOptional<z.ZodNumber>;
+    parentBundle: z.ZodOptional<z.ZodString>;
+    inField: z.ZodOptional<z.ZodString>;
+    containsText: z.ZodOptional<z.ZodString>;
+    optionEquals: z.ZodOptional<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>;
+    }, z.core.$strip>>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodObject<{
+    paragraphs: z.ZodArray<z.ZodObject<{
+        uuid: z.ZodString;
+        bundle: z.ZodString;
+        label: z.ZodString;
+        nestingLevel: z.ZodNumber;
+        parent: z.ZodObject<{
+            type: z.ZodString;
+            uuid: z.ZodString;
+            field: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    hasMore: z.ZodBoolean;
+}, z.core.$strip>;
 declare const _default: any;
 export default _default;

package/dist/modules/agent/runtime/app/tools/find_paragraphs/index.js

@@ -1,23 +1,23 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { parentSchema } from "../schemas.js";
-import { booleanParam } from "#blokkli/agent/shared/toolParams";
+import { optionalBooleanParam } from "../../../shared/toolParams.js";
 import { getResolvedOptions } from "../helpers.js";
 import {
   getMutatedOptionValue,
   optionValueToStorable
 } from "#blokkli/editor/helpers/options";
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   // Bundle filters
   bundle: z.string().optional().describe("Filter by exact bundle name"),
   bundles: z.array(z.string()).optional().describe("Filter by any of these bundles"),
   // Structure filters
-  hasChildren: booleanParam(
+  hasChildren: optionalBooleanParam(
     "Filter by whether paragraph has child paragraphs"
-  ).optional(),
-  isRootLevel: booleanParam(
+  ),
+  isRootLevel: optionalBooleanParam(
     "Filter to root level paragraphs (nesting 0)"
-  ).optional(),
+  ),
   nestingLevel: z.number().optional().describe("Filter to exact nesting level"),
   parentBundle: z.string().optional().describe("Filter to paragraphs whose parent is this bundle"),
   inField: z.string().optional().describe("Filter to paragraphs in a field with this name"),
@@ -38,7 +38,7 @@ const paragraphResultSchema = z.object({
   nestingLevel: z.number().describe("Nesting depth (0 = root level)"),
   parent: parentSchema.describe("The parent entity containing this paragraph")
 });
-const resultSchema = z.object({
+export const resultSchema = z.object({
   paragraphs: z.array(paragraphResultSchema).describe("paragraphs matching the filters"),
   total: z.number().describe("Total number of matches before pagination"),
   hasMore: z.boolean().describe("Whether there are more results beyond the limit")

package/dist/modules/agent/runtime/app/tools/get_all_fragments/index.d.ts

@@ -1,2 +1,9 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{}, z.core.$strip>;
+export declare const resultSchema: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
 declare const _default: any;
 export default _default;

package/dist/modules/agent/runtime/app/tools/get_all_fragments/index.js

@@ -5,8 +5,8 @@ const fragmentSchema = z.object({
   label: z.string().describe("The display label"),
   description: z.string().optional().describe("A short description of the fragment")
 });
-const paramsSchema = z.object({});
-const resultSchema = z.array(fragmentSchema).describe("All available fragments");
+export const paramsSchema = z.object({});
+export const resultSchema = z.array(fragmentSchema).describe("All available fragments");
 export default defineBlokkliAgentTool({
   name: "get_all_fragments",
   description: "Get all available fragments that can be added to the page",

package/dist/modules/agent/runtime/app/tools/get_all_page_content/index.d.ts

@@ -1,2 +1,12 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{}, z.core.$strip>;
+export declare const resultSchema: z.ZodObject<{
+    content: z.ZodArray<z.ZodObject<{
+        uuid: z.ZodString;
+        bundle: z.ZodString;
+        text: z.ZodString;
+        referenceFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 declare const _default: any;
 export default _default;

package/dist/modules/agent/runtime/app/tools/get_all_page_content/index.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { readBlockContentFields } from "../helpers.js";
-const paramsSchema = z.object({});
+export const paramsSchema = z.object({});
 const blockContentSchema = z.object({
   uuid: z.string().describe("The paragraph UUID"),
   bundle: z.string().describe("The paragraph type"),
@@ -10,7 +10,7 @@ const blockContentSchema = z.object({
     "Names of reference/link content fields on this paragraph (e.g., media fields)"
   )
 });
-const resultSchema = z.object({
+export const resultSchema = z.object({
   content: z.array(blockContentSchema).describe("All paragraphs with their text content, flattened")
 });
 export default defineBlokkliAgentTool({

package/dist/modules/agent/runtime/app/tools/get_bundle_info/index.d.ts

@@ -1,2 +1,37 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    parentUuid: z.ZodString;
+    parentField: z.ZodString;
+    bundles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodObject<{
+    fieldLabel: z.ZodString;
+    cardinality: z.ZodNumber;
+    currentCount: z.ZodNumber;
+    bundles: z.ZodArray<z.ZodObject<{
+        bundle: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        contentFields: z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodString;
+        }, z.core.$strip>>;
+        paragraphFields: z.ZodRecord<z.ZodString, z.ZodObject<{
+            label: z.ZodString;
+            allowedBundles: z.ZodArray<z.ZodString>;
+            cardinality: z.ZodNumber;
+        }, z.core.$strip>>;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            min: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+            max: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+            step: z.ZodOptional<z.ZodNumber>;
+            currentValue: z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber, z.ZodArray<z.ZodString>]>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    nestingInfo: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 declare const _default: any;
 export default _default;

package/dist/modules/agent/runtime/app/tools/get_bundle_info/index.js

@@ -3,7 +3,7 @@ import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { getRuntimeOptionValue } from "#blokkli/runtime-helpers";
 import { blockOptionsMapSchema } from "../schemas.js";
 import { extractOptionLabels, getResolvedOptions } from "../helpers.js";
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   parentUuid: z.string().describe("The parent entity UUID"),
   parentField: z.string().describe("The field name on the parent"),
   bundles: z.array(z.string()).optional().describe(
@@ -36,7 +36,7 @@ const bundleSchema = z.object({
     "Available options for this bundle with their default values (only included when few bundles are returned)"
   )
 });
-const resultSchema = z.object({
+export const resultSchema = z.object({
   fieldLabel: z.string().describe("Human-readable field label"),
   cardinality: z.number().describe("Max paragraphs allowed (-1 = unlimited)"),
   currentCount: z.number().describe("Current number of paragraphs in the field"),

package/dist/modules/agent/runtime/app/tools/get_child_paragraphs/index.d.ts

@@ -1,2 +1,22 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    uuid: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodObject<{
+    parentBundle: z.ZodString;
+    fields: z.ZodRecord<z.ZodString, z.ZodObject<{
+        label: z.ZodString;
+        cardinality: z.ZodNumber;
+        parent: z.ZodObject<{
+            type: z.ZodString;
+            uuid: z.ZodString;
+            field: z.ZodString;
+        }, z.core.$strip>;
+        paragraphs: z.ZodArray<z.ZodObject<{
+            uuid: z.ZodString;
+            bundle: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 declare const _default: any;
 export default _default;

package/dist/modules/agent/runtime/app/tools/get_child_paragraphs/index.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { parentSchema } from "../schemas.js";
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   uuid: z.string().optional().describe(
     "Paragraph UUID to get children for. If not provided, returns page-level paragraphs."
   )
@@ -18,7 +18,7 @@ const fieldWithParagraphsSchema = z.object({
   ),
   paragraphs: z.array(paragraphSchema).describe("Paragraphs in this field")
 });
-const resultSchema = z.object({
+export const resultSchema = z.object({
   parentBundle: z.string().describe("The bundle type of the parent (page or paragraph)"),
   fields: z.record(z.string().describe("Field name"), fieldWithParagraphsSchema).describe("Fields keyed by name, each with parent object and paragraphs")
 });

package/dist/modules/agent/runtime/app/tools/get_content_fields/index.d.ts

@@ -1,2 +1,32 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+    uuids: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>;
+    includeNested: z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>>;
+}, z.core.$strip>>;
+export declare const resultSchema: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"plain">;
+    currentValue: z.ZodString;
+    required: z.ZodBoolean;
+    maxLength: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"markup">;
+    currentValue: z.ZodString;
+    required: z.ZodBoolean;
+    maxLength: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reference">;
+    label: z.ZodString;
+    allowed: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        bundles: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"link">;
+    label: z.ZodString;
+    allowed: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        bundles: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>], "type">>>;
 declare const _default: any;
 export default _default;