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

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,12 +10,12 @@ 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({
   name: "get_all_page_content",
-  description: "Get all text content from the entire page in a single call. Returns a flat list of all paragraphs with their concatenated text. Use this as the first tool when reviewing or analyzing page content.",
+  description: "Get a flat list of every paragraph on the page with its uuid, bundle, and the concatenated text of its OWN editable fields (does NOT follow references \u2014 a teaser appears with empty text). Use this when you need per-block uuids to act on specific blocks (translate, rewrite, delete). For any question about what the page SAYS \u2014 summarising, writing an intro that matches the content, translating the page, reviewing meaning \u2014 call `get_page_text` instead; it reads the actual rendered DOM (so teaser/referenced content is included) and returns Markdown the LLM can reason about directly.",
   category: "query",
   lazy: true,
   volatile: true,

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;

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

@@ -1,16 +1,20 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { readBlockContentFields } from "../helpers.js";
-import { stringArrayParam } from "../schemas.js";
-import { booleanParam } from "#blokkli/agent/shared/toolParams";
-const paramsSchema = z.object({
-  uuids: stringArrayParam(
-    "One or more paragraph UUIDs (or the page UUID to get page-level fields)"
-  ),
-  includeNested: booleanParam(
-    "Recursively include content fields from all nested child paragraphs (default: true). Set to false to only get direct fields."
-  ).optional().default(true)
-});
+import { stringArrayParam, tolerantSingularKeys } from "../schemas.js";
+import { booleanParamWithDefault } from "../../../shared/toolParams.js";
+export const paramsSchema = tolerantSingularKeys(
+  z.object({
+    uuids: stringArrayParam(
+      "Array of paragraph UUIDs. To get page-level fields, pass the page UUID in this array."
+    ),
+    includeNested: booleanParamWithDefault(
+      "Recursively include content fields from all nested child paragraphs (default: true). Set to false to only get direct fields.",
+      true
+    )
+  }),
+  { uuid: "uuids" }
+);
 const fieldSchema = z.discriminatedUnion("type", [
   z.object({
     type: z.literal("plain").describe("Plain text field"),
@@ -45,7 +49,7 @@ const fieldSchema = z.discriminatedUnion("type", [
     ).describe("Entity types and bundles this field accepts")
   })
 ]);
-const resultSchema = z.record(
+export const resultSchema = z.record(
   z.string().describe("Paragraph UUID"),
   z.record(z.string().describe("Field name"), fieldSchema)
 );

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

@@ -1,2 +1,27 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    before: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    after: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodObject<{
+    currentIndex: z.ZodNumber;
+    totalCount: z.ZodNumber;
+    canUndo: z.ZodBoolean;
+    canRedo: z.ZodBoolean;
+    currentMutation: z.ZodNullable<z.ZodObject<{
+        index: z.ZodNumber;
+        label: z.ZodString;
+        pluginId: z.ZodOptional<z.ZodString>;
+        affectedParagraphUuid: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    mutationsBefore: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        label: z.ZodString;
+    }, z.core.$strip>>>;
+    mutationsAfter: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        label: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
 declare const _default: any;
 export default _default;

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   before: z.coerce.number().optional().describe("How many mutations before current to include"),
   after: z.coerce.number().optional().describe("How many mutations after current to include (redo-able)")
 });
@@ -14,7 +14,7 @@ const currentMutationSchema = z.object({
   pluginId: z.string().optional().describe("Internal plugin ID"),
   affectedParagraphUuid: z.string().optional().describe("UUID of the paragraph that was affected")
 });
-const resultSchema = z.object({
+export const resultSchema = z.object({
   currentIndex: z.number().describe("Current position in history (-1 = pristine state)"),
   totalCount: z.number().describe("Total mutations in history"),
   canUndo: z.boolean().describe("Whether undo is possible"),

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

@@ -1,2 +1,10 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{
+    uuid: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const resultSchema: z.ZodObject<{
+    totalParagraphs: z.ZodNumber;
+    structure: z.ZodString;
+}, z.core.$strip>;
 declare const _default: any;
 export default _default;

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

@@ -5,12 +5,12 @@ import {
   buildBlock,
   countBlocks
 } from "#blokkli/agent/app/helpers/pageStructure";
-const paramsSchema = z.object({
+export const paramsSchema = z.object({
   uuid: z.string().optional().describe(
     "UUID of a specific paragraph. When provided, returns only that paragraph and its subtree. Omit to get the full page structure."
   )
 });
-const resultSchema = z.object({
+export const resultSchema = z.object({
   totalParagraphs: z.number().describe(
     "Total number of paragraphs in scope (full page or subtree when uuid is given)"
   ),

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

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export declare const paramsSchema: z.ZodObject<{}, z.core.$strip>;
+export declare const resultSchema: z.ZodObject<{
+    text: z.ZodString;
+    truncated: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+export const paramsSchema = z.object({});
+export const resultSchema = z.object({
+  text: z.string().describe(
+    "The page rendered as Markdown \u2014 exactly what the user sees, in reading order"
+  ),
+  truncated: z.boolean().optional().describe("True when the Markdown exceeded the size cap and was cut off")
+});
+const MAX_LENGTH = 5e4;
+const STRIP_SELECTOR = [
+  "[hidden]",
+  '[aria-hidden="true"]',
+  '[data-bk-is-muted="true"]',
+  "style",
+  "script"
+].join(", ");
+export default defineBlokkliAgentTool({
+  name: "get_page_text",
+  description: 'Get the rendered page as Markdown \u2014 exactly what the user sees, in reading order, with headings/lists/tables preserved and content from referenced entities (teasers, etc.) included because it reads from the actual DOM. ALWAYS PREFER this over `get_all_page_content` for any question about page meaning or content ("what does this page say", "summarize the page", "write an intro that matches the content", "translate the page"). Reach for `get_all_page_content` only when you need per-block UUIDs to act on specific blocks.',
+  category: "query",
+  lazy: true,
+  volatile: true,
+  prunedSummary: (r) => `${r.text?.length ?? 0} chars of page text`,
+  modes: ["readonly", "editing", "translating", "review"],
+  label($t) {
+    return $t("aiAgentGetPageTextRunning", "Reading page content", {
+      more: true
+    });
+  },
+  paramsSchema,
+  resultSchema,
+  async execute(ctx) {
+    const { ui, $t } = ctx.app;
+    const clone = ui.providerElement.cloneNode(true);
+    for (const el of Array.from(clone.querySelectorAll(STRIP_SELECTOR))) {
+      el.remove();
+    }
+    const { default: TurndownService } = await import("turndown");
+    const turndown = new TurndownService({
+      headingStyle: "atx",
+      codeBlockStyle: "fenced",
+      bulletListMarker: "-"
+    });
+    const REMOVED_TAGS = /* @__PURE__ */ new Set([
+      "SVG",
+      "IFRAME",
+      "PICTURE",
+      "VIDEO",
+      "AUDIO",
+      "CANVAS"
+    ]);
+    turndown.remove((node) => REMOVED_TAGS.has(node.nodeName));
+    let text = turndown.turndown(clone.innerHTML).trim();
+    let truncated = false;
+    if (text.length > MAX_LENGTH) {
+      text = text.slice(0, MAX_LENGTH) + "\n\n[TRUNCATED]";
+      truncated = true;
+    }
+    return {
+      label: $t("aiAgentGetPageTextDone", "Read page content"),
+      result: truncated ? { text, truncated } : { text }
+    };
+  }
+});