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

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

@@ -1,2 +1,83 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    includeParentChain: z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>>;
+    includeSiblings: z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>>;
+    includeChildren: z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>>;
+    includeContentFields: z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>>;
+    includeOptions: z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    bundle: z.ZodString;
+    label: z.ZodString;
+    fragmentName: z.ZodOptional<z.ZodString>;
+    nestingLevel: z.ZodNumber;
+    parent: z.ZodNullable<z.ZodObject<{
+        type: z.ZodString;
+        uuid: z.ZodString;
+        field: z.ZodString;
+    }, z.core.$strip>>;
+    parentChain: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        uuid: z.ZodString;
+        bundle: z.ZodString;
+        label: z.ZodString;
+        field: z.ZodString;
+    }, z.core.$strip>>>;
+    siblings: z.ZodOptional<z.ZodObject<{
+        total: z.ZodNumber;
+        position: z.ZodNumber;
+        prev: z.ZodNullable<z.ZodObject<{
+            uuid: z.ZodString;
+            bundle: z.ZodString;
+        }, z.core.$strip>>;
+        next: z.ZodNullable<z.ZodObject<{
+            uuid: z.ZodString;
+            bundle: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    childFields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        label: z.ZodString;
+        count: z.ZodNumber;
+        cardinality: z.ZodNumber;
+        bundles: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>>;
+    contentFields: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        field: z.ZodString;
+        type: z.ZodLiteral<"plain">;
+        currentValue: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        field: z.ZodString;
+        type: z.ZodLiteral<"markup">;
+        currentValue: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        field: z.ZodString;
+        label: z.ZodString;
+        type: z.ZodLiteral<"reference">;
+        allowed: z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            bundles: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        field: z.ZodString;
+        label: z.ZodString;
+        type: z.ZodLiteral<"link">;
+        allowed: z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            bundles: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>], "type">>>;
+    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>;
 declare const _default: any;
 export default _default;

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

@@ -1,24 +1,32 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { parentSchema, blockOptionsMapSchema } from "../schemas.js";
-import { booleanParam } from "#blokkli/agent/shared/toolParams";
+import { booleanParamWithDefault } from "../../../shared/toolParams.js";
 import {
   buildBlockOptionsMap,
   getResolvedOptions,
   readBlockContentFields
 } from "../helpers.js";
 import { fragmentBlockBundle } from "#blokkli-build/config";
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   uuid: z.string().describe("The paragraph UUID"),
-  includeParentChain: booleanParam(
-    "Include ancestor parent paragraphs up to the page"
-  ).optional().default(true),
-  includeSiblings: booleanParam("Include sibling paragraphs in the same field").optional().default(false),
-  includeChildren: booleanParam("Include child fields summary").optional().default(true),
-  includeContentFields: booleanParam(
-    "Include content fields (text, media, links) with values"
-  ).optional().default(true),
-  includeOptions: booleanParam("Include paragraph options").optional().default(true)
+  includeParentChain: booleanParamWithDefault(
+    "Include ancestor parent paragraphs up to the page",
+    true
+  ),
+  includeSiblings: booleanParamWithDefault(
+    "Include sibling paragraphs in the same field",
+    false
+  ),
+  includeChildren: booleanParamWithDefault(
+    "Include child fields summary",
+    true
+  ),
+  includeContentFields: booleanParamWithDefault(
+    "Include content fields (text, media, links) with values",
+    true
+  ),
+  includeOptions: booleanParamWithDefault("Include paragraph options", true)
 });
 const parentChainItemSchema = z.object({
   uuid: z.string().describe("The parent paragraph UUID"),
@@ -79,7 +87,7 @@ const contentFieldSchema = z.discriminatedUnion("type", [
     ).describe("Entity types and bundles this field accepts")
   })
 ]);
-const resultSchema = z.object({
+export const resultSchema = z.object({
   uuid: z.string().describe("The paragraph UUID"),
   bundle: z.string().describe("The paragraph type"),
   label: z.string().describe("Human-readable paragraph label"),

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

@@ -1,2 +1,16 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    uuids: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodRecord<z.ZodString, 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>>>;
 declare const _default: any;
 export default _default;

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

@@ -2,10 +2,10 @@ import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { blockOptionsMapSchema } from "../schemas.js";
 import { buildBlockOptionsMap, getResolvedOptions } from "../helpers.js";
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   uuids: z.array(z.string()).describe("The paragraph UUIDs to get options for")
 });
-const resultSchema = z.record(
+export const resultSchema = z.record(
   z.string().describe("Paragraph UUID"),
   blockOptionsMapSchema.describe("Options for this paragraph")
 );

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

@@ -1,2 +1,40 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    maxNestingLevel: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    includeDimensions: z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>>;
+}, z.core.$strip>;
+type BlockDimensions = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+type NestedBlock = {
+    uuid: string;
+    bundle: string;
+    label: string;
+    dimensions?: BlockDimensions;
+    children?: Record<string, NestedBlock[]>;
+};
+export declare const resultSchema: z.ZodObject<{
+    paragraphs: z.ZodArray<z.ZodObject<{
+        uuid: z.ZodString;
+        bundle: z.ZodString;
+        label: z.ZodString;
+        dimensions: z.ZodOptional<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, z.core.$strip>>;
+        visibilityPercent: z.ZodNumber;
+        parent: z.ZodObject<{
+            type: z.ZodString;
+            uuid: z.ZodString;
+            field: z.ZodString;
+        }, z.core.$strip>;
+        children: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodType<NestedBlock, unknown, z.core.$ZodTypeInternals<NestedBlock, unknown>>>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 declare const _default: any;
 export default _default;

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

@@ -1,13 +1,14 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import { booleanParam } from "#blokkli/agent/shared/toolParams";
-const paramsSchema = z.object({
+import { booleanParamWithDefault } from "../../../shared/toolParams.js";
+export const paramsSchema = z.object({
   maxNestingLevel: z.coerce.number().optional().describe(
     "Maximum nesting depth to include (0 = only root paragraphs, 1 = root + direct children, etc.). Omit for unlimited depth."
   ),
-  includeDimensions: booleanParam(
-    "Include x, y, width, height for each paragraph (default: false)"
-  ).optional().default(false)
+  includeDimensions: booleanParamWithDefault(
+    "Include x, y, width, height for each paragraph (default: false)",
+    false
+  )
 });
 const dimensionsSchema = z.object({
   x: z.number().describe("X position in artboard coordinates"),
@@ -35,7 +36,7 @@ const rootBlockSchema = z.object({
   }).describe("Parent field information"),
   children: z.record(z.string(), z.array(nestedBlockSchema)).optional().describe("Child paragraphs organized by field name")
 });
-const resultSchema = z.object({
+export const resultSchema = z.object({
   paragraphs: z.array(rootBlockSchema).describe("Root-level paragraphs currently visible in the viewport")
 });
 function getDimensions(app, uuid) {

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

@@ -1,2 +1,14 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    uuids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+    fieldValue: z.ZodOptional<z.ZodString>;
+    issues: z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+        impact: z.ZodOptional<z.ZodString>;
+        score: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>>;
 declare const _default: any;
 export default _default;

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

@@ -10,12 +10,12 @@ const fieldResultSchema = z.object({
   fieldValue: z.string().optional(),
   issues: z.array(issueSchema)
 });
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   uuids: z.array(z.string()).optional().describe(
     "Optional list of paragraph UUIDs to return results for. If omitted, returns results for all paragraphs."
   )
 });
-const resultSchema = z.record(
+export const resultSchema = z.record(
   z.string(),
   z.record(z.string(), fieldResultSchema)
 );

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    uuids: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodObject<{
+    entities: z.ZodArray<z.ZodObject<{
+        entityUuid: z.ZodString;
+        entityType: z.ZodString;
+        entityBundle: z.ZodString;
+        label: z.ZodString;
+        editUrl: z.ZodString;
+        referencedBy: 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_referenced_entities/index.js

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { stringArrayParam } from "../schemas.js";
+export const paramsSchema = z.object({
+  uuids: stringArrayParam(
+    "Paragraph UUIDs to resolve references for. Returns the entities (media, nodes, taxonomy terms, ...) currently referenced by these paragraphs via any of their reference fields."
+  )
+});
+export const resultSchema = z.object({
+  entities: z.array(
+    z.object({
+      entityUuid: z.string().describe(
+        'UUID of the referenced entity. Pass this as `mediaId` to replace_media_field when the entityType is "media".'
+      ),
+      entityType: z.string().describe('e.g. "media", "node", "taxonomy_term"'),
+      entityBundle: z.string().describe(
+        'e.g. "image", "canto". Pass this as `mediaBundle` to replace_media_field when the entityType is "media".'
+      ),
+      label: z.string().describe("Human-readable label of the entity"),
+      editUrl: z.string().describe("Backend edit URL of the entity"),
+      referencedBy: z.array(z.string()).describe(
+        "Paragraph UUIDs (from the input) that reference this entity"
+      )
+    })
+  )
+});
+export default defineBlokkliAgentTool({
+  name: "get_referenced_entities",
+  description: "Resolve which entities (media items, referenced nodes, taxonomy terms, etc.) are currently referenced by one or more paragraphs. Use this when get_content_fields shows a paragraph has a reference field but you need the actual referenced entity ID \u2014 for example, to copy a media reference from one paragraph into another field via replace_media_field.",
+  category: "query",
+  lazy: false,
+  volatile: true,
+  prunedSummary: (r) => `${r.entities?.length ?? 0} referenced entities`,
+  modes: ["readonly", "editing", "translating", "review"],
+  requiredAdapterMethods: ["getReferencedEntities"],
+  label($t) {
+    return $t("aiAgentGetReferencedEntitiesRunning", "Resolving references", {
+      more: true
+    });
+  },
+  paramsSchema,
+  resultSchema,
+  async execute(ctx, params) {
+    const { $t } = ctx.app;
+    const raw = await ctx.adapter.getReferencedEntities(params.uuids);
+    const result = {
+      entities: raw.map((e) => ({
+        entityUuid: e.entityUuid,
+        entityType: e.entityType,
+        entityBundle: e.entityBundle,
+        label: e.label,
+        editUrl: e.editUrl,
+        referencedBy: e.uuids
+      }))
+    };
+    const label = $t(
+      "aiAgentGetReferencedEntitiesDone",
+      "Resolved @count referenced entities"
+    ).replace("@count", String(result.entities.length));
+    return { label, result, affectedUuids: params.uuids };
+  }
+});

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

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

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

@@ -1,12 +1,12 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-const paramsSchema = z.object({});
+export const paramsSchema = z.object({});
 const paragraphSchema = z.object({
   uuid: z.string().describe("The paragraph UUID"),
   bundle: z.string().describe("The paragraph type"),
   label: z.string().describe("Human-readable paragraph label")
 });
-const resultSchema = z.object({
+export const resultSchema = z.object({
   paragraphs: z.array(paragraphSchema).describe("Currently selected paragraphs")
 });
 export default defineBlokkliAgentTool({

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

@@ -1,2 +1,18 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    index: z.ZodCoercedNumber<unknown>;
+}, 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/go_to_history_index/index.js

@@ -1,13 +1,14 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { mutationResultSchema } from "../schemas.js";
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   // Coerce so a numeric string (e.g. "5") is accepted — the LLM often sends the
   // index as a string. A non-numeric string is still rejected.
   index: z.coerce.number().describe(
     "History index to navigate to (-1 = pristine state, 0+ = mutation index)"
   )
 });
+export const resultSchema = mutationResultSchema;
 export default defineBlokkliAgentTool({
   name: "go_to_history_index",
   description: `Navigate to a specific point in mutation history (undo/redo). -1 = pristine state, 0 = first mutation, etc.`,
@@ -21,7 +22,7 @@ export default defineBlokkliAgentTool({
     });
   },
   paramsSchema,
-  resultSchema: mutationResultSchema,
+  resultSchema,
   requiredAdapterMethods: ["setHistoryIndex"],
   execute(ctx, params) {
     const { $t, state } = ctx.app;

package/dist/modules/agent/runtime/app/tools/helpers.d.ts

@@ -77,8 +77,14 @@ export declare function resolveHost(app: BlokkliApp, uuid: string): {
  */
 export declare function getResolvedOptions(app: BlokkliApp, bundleOrBlock: Parameters<BlokkliApp['definitions']['getBlockDefinition']>[0], fieldListType: Parameters<BlokkliApp['definitions']['getBlockDefinition']>[1], parentBundle: Parameters<BlokkliApp['definitions']['getBlockDefinition']>[2]): OptionItem[] | null;
 /**
- * Read every editable content field of a block (or entity), skipping fields
- * with no resolvable type. Callers map the result into their own output shape.
+ * Read every editable content field of a block (or entity), skipping `table`
+ * fields (no text payload). Iterates the declared `editableFieldConfig` rather
+ * than the runtime `v-blokkli-editable` directive registry — the former is the
+ * canonical declaration (it sees fields exposed via `propsFieldMapping` even
+ * when no directive is present in the template), while the latter only sees
+ * fields whose template marks them with the directive. `fieldValue.readValue`
+ * already knows how to resolve a value through `propsFieldMapping`, so this
+ * one swap surfaces all editable fields to every caller.
  */
 export declare function readBlockContentFields(app: BlokkliApp, uuid: string, entityType: string, bundle: string): Array<{
     fieldName: string;

package/dist/modules/agent/runtime/app/tools/helpers.js

@@ -257,21 +257,21 @@ export function getResolvedOptions(app, bundleOrBlock, fieldListType, parentBund
 }
 export function readBlockContentFields(app, uuid, entityType, bundle) {
   const result = [];
-  for (const editable of app.directive.getEditablesForBlock(uuid)) {
-    const fieldType = app.fieldValue.resolveFieldType(
-      entityType,
-      bundle,
-      editable.fieldName
-    );
-    if (!fieldType) continue;
+  const configs = app.types.editableFieldConfig.forEntityTypeAndBundle(
+    entityType,
+    bundle
+  );
+  for (const cfg of configs) {
+    if (cfg.type === "table") continue;
+    const fieldType = cfg.type === "frame" || cfg.type === "markup" ? "markup" : "plain";
     const value = app.fieldValue.readValue(
       entityType,
       uuid,
       bundle,
-      editable.fieldName,
+      cfg.name,
       fieldType
     );
-    result.push({ fieldName: editable.fieldName, fieldType, value });
+    result.push({ fieldName: cfg.name, fieldType, value });
   }
   return result;
 }

package/dist/modules/agent/runtime/app/tools/move_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.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/move_paragraphs/index.js

@@ -8,11 +8,12 @@ import {
   validateFieldCardinality
 } from "../../helpers/validation.js";
 import { getFieldKey } from "#blokkli/helpers";
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   uuids: z.array(z.string()).describe("The UUIDs of the paragraphs to move"),
   parent: parentSchema.describe("The target parent entity"),
   position: positionSchema
 });
+export const resultSchema = mutationResultSchema;
 export default defineBlokkliAgentTool({
   name: "move_paragraphs",
   description: "Move one or more paragraphs to a different parent field. All paragraphs are moved to the same location and they KEEP their UUIDs!!",
@@ -24,7 +25,7 @@ export default defineBlokkliAgentTool({
     return $t("aiAgentMoveBlocksRunning", "Moving blocks", { more: true });
   },
   paramsSchema,
-  resultSchema: mutationResultSchema,
+  resultSchema,
   requiredAdapterMethods: ["moveMultipleBlocks"],
   execute(ctx, params) {
     const { blocks, types } = ctx.app;

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

@@ -1,2 +1,23 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    parent: z.ZodObject<{
+        type: z.ZodString;
+        uuid: z.ZodString;
+        field: z.ZodString;
+    }, z.core.$strip>;
+    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/rearrange_paragraphs/index.js

@@ -6,12 +6,13 @@ import {
   requireBundlePermission,
   requireNoRestrictedAncestor
 } from "../../helpers/validation.js";
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   parent: parentSchema.describe("The parent field containing the paragraphs"),
   uuids: z.array(z.string()).min(2).describe(
     "The UUIDs of the paragraphs in the desired order. Must include ALL paragraphs currently in the field."
   )
 });
+export const resultSchema = mutationResultSchema;
 export default defineBlokkliAgentTool({
   name: "rearrange_paragraphs",
   description: "Rearrange paragraphs within a single field by specifying the desired order. You must provide ALL paragraph UUIDs that are currently in the field \u2014 use get_child_paragraphs to get them. This only reorders, it does not add or remove paragraphs.",
@@ -25,7 +26,7 @@ export default defineBlokkliAgentTool({
     });
   },
   paramsSchema,
-  resultSchema: mutationResultSchema,
+  resultSchema,
   requiredAdapterMethods: ["rearrangeBlocks"],
   execute(ctx, params) {
     const { blocks, types, state, $t } = ctx.app;

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

@@ -1,2 +1,22 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    field: z.ZodString;
+    itemId: z.ZodString;
+    itemEntityType: z.ZodString;
+    itemEntityBundle: 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/replace_content_search_item/index.js

@@ -5,13 +5,14 @@ import {
   requireBundlePermission,
   requireNoRestrictedAncestor
 } from "../../helpers/validation.js";
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   uuid: z.string().describe("The paragraph UUID containing the content reference field"),
   field: z.string().describe("The content field name (reference type)"),
   itemId: z.string().describe("Content item ID from search_content_* results"),
   itemEntityType: z.string().describe("Entity type of the content item"),
   itemEntityBundle: z.string().describe("Entity bundle of the content item")
 });
+export const resultSchema = mutationResultSchema;
 export default defineBlokkliAgentTool({
   name: "replace_content_search_item",
   description: "Replace a content reference on an existing paragraph field. Use get_content_fields first to see available reference fields, then search_content_* to find content items.",
@@ -27,7 +28,7 @@ export default defineBlokkliAgentTool({
   },
   lazy: true,
   paramsSchema,
-  resultSchema: mutationResultSchema,
+  resultSchema,
   requiredAdapterMethods: ["replaceContentSearchItem"],
   execute(ctx, params) {
     const { blocks, types, $t } = ctx.app;

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

@@ -1,2 +1,21 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    field: z.ZodString;
+    mediaId: z.ZodString;
+    mediaBundle: 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;