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

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

@@ -1,22 +1,11 @@
 import type { McpToolContext } from '#blokkli/agent/app/types';
 import type { ComponentParams } from './index.js';
-import type { UsageTurn } from '#blokkli/agent/shared/types';
 type __VLS_Props = {
     context: McpToolContext;
     params: ComponentParams;
 };
-export type StreamTextFieldsDetailItem = {
-    fieldLabel: string;
-    before: string;
-    after: string;
-    mode: 'full' | 'patch';
-    operations: Array<{
-        search: string;
-        replace: string;
-    }>;
-};
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-    done: (result: {
+    done: (result: ComponentToolResult<{
         acceptedCount: number;
         rejectedByUser: Record<string, Record<string, {
             reasonForRejection: string;
@@ -24,13 +13,9 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
         label: string;
         agentMessage?: string | undefined;
         historyIndex?: number | undefined;
-    } & {
-        _details?: StreamTextFieldsDetailItem[];
-        _usage?: UsageTurn;
-        _skipLlmResponse?: boolean;
-    }) => any;
+    }>) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onDone?: ((result: {
+    onDone?: ((result: ComponentToolResult<{
         acceptedCount: number;
         rejectedByUser: Record<string, Record<string, {
             reasonForRejection: string;
@@ -38,11 +23,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
         label: string;
         agentMessage?: string | undefined;
         historyIndex?: number | undefined;
-    } & {
-        _details?: StreamTextFieldsDetailItem[];
-        _usage?: UsageTurn;
-        _skipLlmResponse?: boolean;
-    }) => any) | undefined;
+    }>) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -1,28 +1,27 @@
 import { z } from 'zod';
+import { fieldDiffResultSchema } from '../schemas.js';
+import { type SkippedField } from '../fieldDiffApproval.js';
 declare const paramsSchema: z.ZodObject<{
-    template: z.ZodEnum<{
-        rewrite: "rewrite";
-        fix_readability: "fix_readability";
-        translate: "translate";
-        generate_content: "generate_content";
-    }>;
-    templateParams: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    request: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        template: z.ZodLiteral<"fix_readability">;
+    }, z.core.$strip>, z.ZodObject<{
+        template: z.ZodLiteral<"translate">;
+        targetLanguage: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        template: z.ZodLiteral<"rewrite">;
+        instruction: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        template: z.ZodLiteral<"generate_content">;
+        instruction: z.ZodString;
+        context: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "template">;
     fields: z.ZodArray<z.ZodObject<{
         uuid: z.ZodString;
         fieldName: z.ZodString;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-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>;
 export type StreamTextFieldsParams = z.infer<typeof paramsSchema>;
-export type StreamTextFieldsResult = z.infer<typeof resultSchema>;
+export type StreamTextFieldsResult = z.infer<typeof fieldDiffResultSchema>;
 export type ResolvedField = {
     uuid: string;
     fieldName: string;
@@ -35,6 +34,8 @@ export type ComponentParams = {
     template: string;
     templateParams: Record<string, unknown>;
     fields: ResolvedField[];
+    /** Field references dropped because the paragraph/field doesn't exist. */
+    skipped: SkippedField[];
 };
 declare const _default: any;
 export default _default;

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

@@ -1,59 +1,62 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import { runReadabilityAnalysis } from "../helpers.js";
+import { resolveHost } from "../helpers.js";
+import { runReadabilityAnalysis } from "../readability.js";
 import {
   requireBundlePermission,
   requireNoRestrictedAncestor
 } from "../../helpers/validation.js";
 import { onlyUnique } from "#blokkli/helpers";
+import { fieldDiffResultSchema } from "../schemas.js";
+import { skippedFieldsMessage } from "../fieldDiffApproval.js";
 import Component from "./Component.vue";
-import DetailsComponent from "./Details/index.vue";
+import DetailsComponent from "../../components/FieldDiffDetails/index.vue";
 const fieldSchema = z.object({
   uuid: z.string().describe("The paragraph UUID"),
   fieldName: z.string().describe("The editable field name")
 });
+const requestSchema = z.discriminatedUnion("template", [
+  z.object({
+    template: z.literal("fix_readability")
+  }),
+  z.object({
+    template: z.literal("translate"),
+    targetLanguage: z.string().describe('The language to translate every field into, e.g. "German".')
+  }),
+  z.object({
+    template: z.literal("rewrite"),
+    instruction: z.string().describe(
+      "Free-form instruction describing how to rewrite the fields."
+    )
+  }),
+  z.object({
+    template: z.literal("generate_content"),
+    instruction: z.string().describe("What content to write for the (typically empty) fields."),
+    context: z.string().optional().describe(
+      "Optional page or topic context to ground the generated content."
+    )
+  })
+]).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({
-  template: z.enum(["fix_readability", "translate", "rewrite", "generate_content"]).describe(
-    "The prompt template to use. fix_readability: fix specific flagged readability issues (requires templateParams.issues). translate: translate all fields to a target language (requires templateParams.targetLanguage). rewrite: general-purpose rewrite with a free-form instruction (requires templateParams.instruction). generate_content: write new content for empty fields (requires templateParams.instruction, optional templateParams.context)."
-  ),
-  templateParams: z.record(z.string(), z.unknown()).describe(
-    "Parameters for the chosen template. fix_readability: {} (no params needed \u2014 issues are resolved automatically). translate: { targetLanguage: string }. rewrite: { instruction: string }. generate_content: { instruction: string, context?: string }."
-  ),
+  request: requestSchema,
   fields: z.array(fieldSchema).describe("The fields to transform (UUIDs and field names only)")
 });
-const resultSchema = z.object({
-  acceptedCount: z.number().describe("Number of changes accepted by the user"),
-  rejectedByUser: z.record(
-    z.string(),
-    z.record(
-      z.string(),
-      z.object({
-        reasonForRejection: z.string().describe(
-          "Reason provided by the user for rejecting, empty if no reason given"
-        )
-      })
-    )
-  ).describe(
-    "Map of rejected paragraph UUID to field name to rejection details"
-  ),
-  label: z.string().describe("Human-readable summary shown in the UI"),
-  agentMessage: z.string().optional().describe(
-    "Detailed message for the agent, replaces label in the LLM context"
-  ),
-  historyIndex: z.number().optional().describe("The mutation history index after applying changes")
-});
 export default defineBlokkliAgentTool({
   name: "delegate_text_rewrite",
-  description: "Rewrite, translate, fix readability, or generate text fields with live streaming preview. Choose a template (fix_readability, translate, rewrite, generate_content) and provide the corresponding templateParams. The content will be streamed live into the page for immediate visual feedback.",
+  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.",
   category: "mutation",
   lazy: true,
   modes: ["editing", "translating"],
   prunedSummary: (r) => `${r.acceptedCount || 0} accepted, ${Object.keys(r.rejectedByUser || {}).length} rejected`,
   label($t) {
-    return $t("aiAgentDelegateRewriteRunning", "Rewriting texts...");
+    return $t("aiAgentDelegateRewriteRunning", "Rewriting texts", {
+      more: true
+    });
   },
   paramsSchema,
-  resultSchema,
+  resultSchema: fieldDiffResultSchema,
   requiredAdapterMethods: ["updateFieldValueBatched"],
   component: Component,
   detailsComponent: DetailsComponent,
@@ -71,24 +74,23 @@ export default defineBlokkliAgentTool({
       if (ancestorDenied) return ancestorDenied;
     }
     const resolvedFields = [];
+    const skipped = [];
     for (const { uuid, fieldName } of params.fields) {
-      let entityType;
-      let bundle;
-      if (uuid === context.value.entityUuid) {
-        entityType = context.value.entityType;
-        bundle = context.value.entityBundle;
-      } else {
-        const block = blocks.getBlock(uuid);
-        if (!block) continue;
-        entityType = ctx.itemEntityType;
-        bundle = block.bundle;
+      const host = resolveHost(ctx.app, uuid);
+      if (!host) {
+        skipped.push({ uuid, fieldName, reason: "paragraph not found" });
+        continue;
       }
+      const { entityType, bundle } = host;
       const fieldType = ctx.app.fieldValue.resolveFieldType(
         entityType,
         bundle,
         fieldName
       );
-      if (!fieldType) continue;
+      if (!fieldType) {
+        skipped.push({ uuid, fieldName, reason: "field not found" });
+        continue;
+      }
       const currentValue = ctx.app.fieldValue.readValue(
         entityType,
         uuid,
@@ -105,8 +107,14 @@ export default defineBlokkliAgentTool({
         entityBundle: bundle
       });
     }
-    let templateParams = params.templateParams;
-    if (params.template === "fix_readability") {
+    if (resolvedFields.length === 0) {
+      return {
+        error: skippedFieldsMessage(skipped) ?? "No valid fields to rewrite were provided."
+      };
+    }
+    const { template, ...inlineParams } = params.request;
+    let templateParams = inlineParams;
+    if (template === "fix_readability") {
       if (!ctx.app.readability.isAvailable.value) {
         return {
           error: "Readability analyzer is not configured for this project. The fix_readability template requires it."
@@ -134,9 +142,10 @@ export default defineBlokkliAgentTool({
       };
     }
     return {
-      template: params.template,
+      template,
       templateParams,
-      fields: resolvedFields
+      fields: resolvedFields,
+      skipped
     };
   }
 });

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

@@ -0,0 +1,64 @@
+import type { McpToolContext } from '#blokkli/agent/app/types';
+import type { ComponentParams } from './index.js';
+export type Phase = 'streaming' | 'approval' | 'error';
+export type FieldState = {
+    uuid: string;
+    fieldName: string;
+    fieldLabel: string;
+    status: 'pending' | 'streaming' | 'done';
+    mode: 'full' | 'patch' | null;
+    fullValue: string;
+    operations: Array<{
+        search: string;
+        replace: string;
+    }>;
+    /** Accumulated operations across all retry attempts (for details display). */
+    allOperations: Array<{
+        search: string;
+        replace: string;
+    }>;
+    currentSearch: string;
+    baseValue: string;
+    /** The original value before any streaming attempts. */
+    originalBaseValue: string;
+};
+type OverrideEntry = {
+    uuid: string;
+    fieldName: string;
+    element: HTMLElement | null;
+    setValue: (value: string) => void;
+    restore: () => void;
+    originalValue: string;
+};
+/**
+ * Owns the streaming subsystem of the `delegate_text_rewrite` tool: SSE transport,
+ * the event state machine, markup buffering, live-DOM overrides, and the readability
+ * retry loop. The component keeps the approval UI and emits.
+ *
+ * `phase`/`errorMessage` live here because the streaming code is their primary
+ * writer (and `phase` doubles as a control-flow signal — e.g. an SSE `error` event
+ * sets `phase='error'` mid-stream); owning them keeps that flow intact. The
+ * composable never calls `emit`: a user cancel surfaces via `start()`'s
+ * `{ cancelled }` result, and the success fall-through invokes the injected
+ * `onComplete` (the component's `transitionToApproval`).
+ */
+export declare function useFieldRewriteStream(options: {
+    context: McpToolContext;
+    params: ComponentParams;
+    onComplete: () => void;
+}): {
+    phase: any;
+    errorMessage: any;
+    streamingTitle: any;
+    streamUsage: any;
+    fieldStates: any;
+    findFieldState: (uuid: string, fieldName: string) => FieldState | undefined;
+    findOverride: (uuid: string, fieldName: string) => OverrideEntry | undefined;
+    start: () => Promise<{
+        cancelled: boolean;
+    }>;
+    restoreAll: () => void;
+    abort: () => void;
+    dispose: () => void;
+};
+export {};