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

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

@@ -5,8 +5,12 @@ import {
   requireNoRestrictedAncestor
 } from "../../helpers/validation.js";
 import { onlyUnique } from "#blokkli/helpers";
+import { fieldDiffResultSchema } from "../schemas.js";
+import { booleanParam } from "#blokkli/agent/shared/toolParams";
+import { resolveHost } from "../helpers.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 operationSchema = z.object({
   uuid: z.string().describe("The paragraph UUID"),
   fieldName: z.string().describe("The editable field name"),
@@ -16,90 +20,118 @@ const operationSchema = z.object({
   replace: z.string().describe(
     "The replacement text (or innerHTML when search is a CSS selector)"
   ),
-  selector: z.boolean().optional().describe(
+  selector: booleanParam(
     "Set to true when search is a CSS selector instead of a text search"
-  )
+  ).optional()
+});
+const updateSchema = z.object({
+  uuid: z.string().describe("The paragraph UUID"),
+  fieldName: z.string().describe("The editable field name"),
+  value: z.string().describe("The complete new field value \u2014 overwrites the entire field")
 });
 const paramsSchema = z.object({
-  uuids: z.record(z.string(), z.record(z.string(), z.string())).optional().describe(
-    "Full value replacements: map of paragraph UUID \u2192 field name \u2192 new value."
+  updates: z.array(updateSchema).optional().describe(
+    "Full-replacement mode: a list of { uuid, fieldName, value } entries. Each overwrites the entire field with the given value. Use when the value changes substantially or you already have the final text."
   ),
   operations: z.array(operationSchema).optional().describe(
-    "Patch operations: search/replace pairs applied to current field values. Use for small targeted edits like typo fixes."
+    "Patch mode: search/replace operations applied to each field's CURRENT value, so `search` must match the existing content exactly. Best for small targeted edits like typo fixes \u2014 avoids re-sending the whole value. If `search` is not found, that field is left unchanged."
   ),
-  requireApproval: z.boolean().optional().describe("Whether to show the approval UI.")
-});
-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")
+  requireApproval: booleanParam(
+    "The approval UI is shown by default. Set to false to apply the changes immediately without confirmation \u2014 only when the user supplied the exact text themselves."
+  ).optional()
 });
 export default defineBlokkliAgentTool({
   name: "update_text_fields",
-  description: 'Update text content fields on one or more paragraphs. Supports two modes: (1) Full replacement via "uuids" \u2014 provide complete new values. (2) Patch via "operations" \u2014 search/replace pairs applied to current values, ideal for small edits like typo fixes. Set "selector" to true to use a CSS selector instead of text search. Set requireApproval to true when the user should confirm the changes first.',
+  description: "Update text content fields on one or more paragraphs. Two modes, which may be combined in a single call:\n- Full replacement via `updates`: a list of { uuid, fieldName, value } entries, each overwriting the entire field with a complete new value. Use when the value changes substantially or you already have the final text.\n- Patch via `operations`: search/replace pairs applied to each field's CURRENT value (so `search` must match the existing content). Best for small edits like typo fixes, since you only send the changed part. Set `selector: true` on an operation to treat `search` as a CSS selector (e.g. \"p:nth-child(3)\") and `replace` as the matched element's innerHTML.\nThe approval UI is shown by default; set requireApproval to false to apply immediately (only when the user supplied the exact text).",
   category: "mutation",
   lazy: true,
   prunedSummary: (r) => `${r.acceptedCount || 0} accepted, ${Object.keys(r.rejectedByUser || {}).length} rejected`,
   modes: ["editing", "translating"],
   label($t) {
-    return $t("aiAgentBatchRewriteTextRunning", "Rewriting multiple texts...");
+    return $t("aiAgentBatchRewriteTextRunning", "Rewriting multiple texts", {
+      more: true
+    });
   },
   paramsSchema,
-  resultSchema,
+  resultSchema: fieldDiffResultSchema,
   requiredAdapterMethods: ["updateFieldValueBatched"],
   component: Component,
   detailsComponent: DetailsComponent,
   buildDetails: (result) => result,
   execute(ctx, params) {
-    const blockUuids = [];
-    if (params.uuids) {
-      blockUuids.push(...Object.keys(params.uuids));
-    }
-    if (params.operations) {
-      blockUuids.push(...params.operations.map((op) => op.uuid));
+    const skipped = [];
+    const skipReason = (uuid, fieldName) => {
+      const host = resolveHost(ctx.app, uuid);
+      if (!host) return "paragraph not found";
+      const field = ctx.app.types.editableFieldConfig.forName(
+        host.entityType,
+        host.bundle,
+        fieldName
+      );
+      if (!field) return "field not found";
+      return void 0;
+    };
+    const keep = (entries) => entries?.filter((entry) => {
+      const reason = skipReason(entry.uuid, entry.fieldName);
+      if (reason) {
+        skipped.push({ uuid: entry.uuid, fieldName: entry.fieldName, reason });
+        return false;
+      }
+      return true;
+    });
+    const updates = keep(params.updates);
+    const operations = keep(params.operations);
+    if (!updates?.length && !operations?.length) {
+      return {
+        error: skippedFieldsMessage(skipped) ?? "No updates or operations were provided."
+      };
     }
-    const bundles = blockUuids.filter(onlyUnique).map((uuid) => ctx.app.blocks.getBlock(uuid)?.bundle).filter((b) => !!b).filter(onlyUnique);
+    const blockUuids = [
+      ...updates?.map((u) => u.uuid) ?? [],
+      ...operations?.map((op) => op.uuid) ?? []
+    ].filter(onlyUnique);
+    const bundles = blockUuids.map((uuid) => ctx.app.blocks.getBlock(uuid)?.bundle).filter((b) => !!b).filter(onlyUnique);
     if (bundles.length) {
       const denied = requireBundlePermission(ctx.app, bundles, "edit");
       if (denied) return denied;
     }
-    const uniqueUuids = blockUuids.filter(onlyUnique);
-    const ancestorDenied = requireNoRestrictedAncestor(ctx.app, uniqueUuids);
+    const ancestorDenied = requireNoRestrictedAncestor(ctx.app, blockUuids);
     if (ancestorDenied) return ancestorDenied;
-    return params;
+    return {
+      updates,
+      operations,
+      requireApproval: params.requireApproval,
+      skipped
+    };
   },
   mockParams: () => ({
-    uuids: {
-      "4526d2d0-f122-4093-902f-e2f00a433981": {
-        title: "Seamlessly integrates in any Nuxt setup",
-        tagline: "Great Developer Experience"
+    updates: [
+      {
+        uuid: "4526d2d0-f122-4093-902f-e2f00a433981",
+        fieldName: "title",
+        value: "Seamlessly integrates in any Nuxt setup"
+      },
+      {
+        uuid: "4526d2d0-f122-4093-902f-e2f00a433981",
+        fieldName: "tagline",
+        value: "Great Developer Experience"
       },
-      "9485812c-0ecd-4699-85b2-3a031d47a0a1": {
-        text: "<ul><li>Fully responsive design</li><li>Touch gestures and smooth interactions</li><li>All editing features available on mobile</li><li>Optimized for tablets</li></ul>"
+      {
+        uuid: "9485812c-0ecd-4699-85b2-3a031d47a0a1",
+        fieldName: "text",
+        value: "<ul><li>Fully responsive design</li><li>Touch gestures and smooth interactions</li><li>All editing features available on mobile</li><li>Optimized for tablets</li></ul>"
       },
-      "67a9e26f-8028-4283-8b7d-8f836355b949": {
-        text: "<p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.</p><p>Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.</p><p>Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.</p><p>Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.</p><p>Curabitur pretium tincidunt lacus. Nulla gravida orci a odio. Nullam varius, turpis et commodo pharetra.</p>"
+      {
+        uuid: "67a9e26f-8028-4283-8b7d-8f836355b949",
+        fieldName: "text",
+        value: "<p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.</p><p>Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.</p><p>Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.</p><p>Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.</p><p>Curabitur pretium tincidunt lacus. Nulla gravida orci a odio. Nullam varius, turpis et commodo pharetra.</p>"
       },
-      "3a2617ed-6844-4d39-859c-82869f4ea5aa": {
-        text: "<ul><li>Auto import block components</li><li>Directly define options inside the component</li><li>Support for import chunks</li></ul>"
+      {
+        uuid: "3a2617ed-6844-4d39-859c-82869f4ea5aa",
+        fieldName: "text",
+        value: "<ul><li>Auto import block components</li><li>Directly define options inside the component</li><li>Support for import chunks</li></ul>"
       }
-    },
+    ],
     requireApproval: true
   })
 });

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

@@ -20,7 +20,7 @@ export default defineBlokkliAgentTool({
   lazy: true,
   modes: ["readonly", "editing", "translating", "review"],
   label($t) {
-    return $t("aiAgentWebFetchRunning", "Fetching web page...");
+    return $t("aiAgentWebFetchRunning", "Fetching web page", { more: true });
   },
   paramsSchema,
   resultSchema,

package/dist/modules/agent/runtime/app/types/index.d.ts

@@ -5,10 +5,7 @@ import { type UsageTurn } from '#blokkli/agent/shared/types';
 import { z } from 'zod';
 import type { Component } from 'vue';
 import type { AgentToolName, AgentSkillName, AgentToolMap } from '#blokkli-build/agent-client';
-/**
- * Translation function type (matches $t from BlokkliApp).
- */
-export type TranslationFunction = (key: string, defaultValue: string) => string;
+import type { TextProvider } from '#blokkli/editor/providers/texts';
 /**
  * A host entity (parent of a block).
  * Used consistently across tools for specifying block locations.
@@ -171,7 +168,7 @@ export type McpToolDefinition<TParamsSchema extends z.ZodType = z.ZodType, TResu
      * Returns the label to display while the tool is executing.
      * This is shown before the tool completes and provides its final label.
      */
-    label: ($t: TranslationFunction) => string;
+    label: ($t: TextProvider) => string;
     /** Zod schema for input parameters */
     paramsSchema: TParamsSchema;
     /** Zod schema for the result */
@@ -356,13 +353,32 @@ declare const userConversationItemSchema: z.ZodObject<{
         id: z.ZodString;
         content: z.ZodString;
         format: z.ZodEnum<{
-            html: "html";
             code: "code";
+            html: "html";
             markdown: "markdown";
             csv: "csv";
             plaintext: "plaintext";
         }>;
     }, z.core.$strip>>>;
+    historyIndexAtSend: z.ZodOptional<z.ZodNumber>;
+    historySignatureAtSend: z.ZodOptional<z.ZodString>;
+    sendContext: z.ZodOptional<z.ZodObject<{
+        promptId: z.ZodOptional<z.ZodString>;
+        serverPrompt: z.ZodOptional<z.ZodString>;
+        selectedUuids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        autoLoadTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        autoLoadSkills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        preSeededResults: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            toolName: z.ZodString;
+            params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            result: z.ZodUnknown;
+            label: z.ZodString;
+        }, z.core.$strip>>>;
+        autoExecuteTools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            toolName: z.ZodString;
+            params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 /**
  * An assistant text message in the conversation history.
@@ -390,6 +406,19 @@ declare const toolConversationItemSchema: z.ZodObject<{
         error: "error";
     }>;
 }, z.core.$strip>;
+/**
+ * Names of server-side tools, plus `plan_completed` which is synthesized
+ * client-side (not a wire value). Single source for the conversation item and
+ * the components that render it.
+ */
+export declare const serverToolNameSchema: z.ZodEnum<{
+    load_skills: "load_skills";
+    load_tools: "load_tools";
+    create_plan: "create_plan";
+    complete_plan_step: "complete_plan_step";
+    plan_completed: "plan_completed";
+}>;
+export type ServerToolName = z.infer<typeof serverToolNameSchema>;
 /**
  * A server-side tool call result in the conversation history.
  */
@@ -429,13 +458,32 @@ export declare const conversationItemSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
         id: z.ZodString;
         content: z.ZodString;
         format: z.ZodEnum<{
-            html: "html";
             code: "code";
+            html: "html";
             markdown: "markdown";
             csv: "csv";
             plaintext: "plaintext";
         }>;
     }, z.core.$strip>>>;
+    historyIndexAtSend: z.ZodOptional<z.ZodNumber>;
+    historySignatureAtSend: z.ZodOptional<z.ZodString>;
+    sendContext: z.ZodOptional<z.ZodObject<{
+        promptId: z.ZodOptional<z.ZodString>;
+        serverPrompt: z.ZodOptional<z.ZodString>;
+        selectedUuids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        autoLoadTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        autoLoadSkills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        preSeededResults: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            toolName: z.ZodString;
+            params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            result: z.ZodUnknown;
+            label: z.ZodString;
+        }, z.core.$strip>>>;
+        autoExecuteTools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            toolName: z.ZodString;
+            params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     id: z.ZodString;
     timestamp: z.ZodNumber;

package/dist/modules/agent/runtime/app/types/index.js

@@ -16,7 +16,53 @@ const userConversationItemSchema = conversationItemBase.extend({
       content: z.string(),
       format: z.enum(["plaintext", "markdown", "html", "csv", "code"])
     })
-  ).optional()
+  ).optional(),
+  /**
+   * Editor history index at the moment this message was sent. Used by
+   * retry/edit to restore the editor state before re-running the prompt.
+   * Optional for back-compat with conversations persisted before this field
+   * existed.
+   */
+  historyIndexAtSend: z.number().optional(),
+  /**
+   * Identity of the mutation at `historyIndexAtSend` when the snapshot was
+   * taken. Compared against the current mutation at that index to detect
+   * staleness — if the user manually undid + re-mutated, the snapshot is no
+   * longer reachable and retry/edit must be disabled.
+   */
+  historySignatureAtSend: z.string().optional(),
+  /**
+   * Original send parameters captured so retry produces byte-identical
+   * execution — important for prompt-definition-driven sends where the
+   * displayed text is a friendly label but the real work was driven by
+   * `selectedUuids`, pre-computed tool results, auto-executed tools, and
+   * auto-loaded tools/skills.
+   *
+   * Retry replays this context as-is. Edit discards `preSeededResults` and
+   * `autoExecuteTools` (the intent has changed) but preserves selection,
+   * tools, and skills — the edited prompt runs through a normal LLM round.
+   */
+  sendContext: z.object({
+    promptId: z.string().optional(),
+    serverPrompt: z.string().optional(),
+    selectedUuids: z.array(z.string()).optional(),
+    autoLoadTools: z.array(z.string()).optional(),
+    autoLoadSkills: z.array(z.string()).optional(),
+    preSeededResults: z.array(
+      z.object({
+        toolName: z.string(),
+        params: z.record(z.string(), z.unknown()),
+        result: z.unknown(),
+        label: z.string()
+      })
+    ).optional(),
+    autoExecuteTools: z.array(
+      z.object({
+        toolName: z.string(),
+        params: z.record(z.string(), z.unknown())
+      })
+    ).optional()
+  }).optional()
 });
 const assistantConversationItemSchema = conversationItemBase.extend({
   type: z.literal("assistant"),
@@ -29,15 +75,16 @@ const toolConversationItemSchema = conversationItemBase.extend({
   label: z.string(),
   status: z.enum(["active", "success", "error"])
 });
+export const serverToolNameSchema = z.enum([
+  "load_skills",
+  "load_tools",
+  "create_plan",
+  "complete_plan_step",
+  "plan_completed"
+]);
 const serverToolConversationItemSchema = conversationItemBase.extend({
   type: z.literal("server_tool"),
-  tool: z.enum([
-    "load_skills",
-    "load_tools",
-    "create_plan",
-    "complete_plan_step",
-    "plan_completed"
-  ]),
+  tool: serverToolNameSchema,
   label: z.string()
 });
 const errorConversationItemSchema = conversationItemBase.extend({

package/dist/modules/agent/runtime/server/agent.js

@@ -1,7 +1,7 @@
 import { defineWebSocketHandler, useRuntimeConfig } from "#imports";
 import { clientMessageSchema } from "../shared/types.js";
-import { SessionManager } from "./SessionManager.js";
-import { send } from "./helpers.js";
+import { SessionManager } from "./classes/SessionManager/index.js";
+import { send } from "./helpers/socket.js";
 import { toolDefinitions } from "#blokkli-build/agent-server";
 const sessionManager = new SessionManager(toolDefinitions);
 const config = useRuntimeConfig();
@@ -58,7 +58,6 @@ export default defineWebSocketHandler({
           case "init":
           case "accept":
           case "reject":
-          case "new_conversation":
           case "restore_conversation":
             send(peer, {
               type: "error",
@@ -90,7 +89,8 @@ export default defineWebSocketHandler({
             data.autoLoadTools,
             data.autoLoadSkills,
             data.preSeededResults,
-            data.autoExecuteTools
+            data.autoExecuteTools,
+            data.rollbackToUserMessageIndex
           );
           break;
         case "tool_result":

package/dist/modules/agent/runtime/server/classes/ConversationHistory/index.d.ts

@@ -0,0 +1,93 @@
+import type { GenericMessage, TranscriptMessage } from '../../../shared/types.js';
+import type { ToolResult } from '../../../shared/toolResult.js';
+import { ConversationMessage, AssistantMessage, ToolRelayMessage } from '../ConversationMessage/index.js';
+/** Looks up whether a tool's results go stale after a mutation. */
+export type VolatileLookup = (toolName: string | undefined) => boolean;
+export type LiveProjectionOptions = {
+    keepRecentTurns?: number;
+    tokenBudget?: number;
+};
+/**
+ * The single, append-only source of truth for a conversation.
+ *
+ * Canonical messages are never mutated for pruning — the views fed to the LLM,
+ * persistence, and the transcript are produced by **pure, deterministic**
+ * projections that compress copies. This replaces the old in-place pruning of
+ * `Session.messages` (and its `unprunedMessages` snapshot side-channel).
+ *
+ * The mutators here represent legitimate conversation construction (append a
+ * turn, merge a system note, finalise a placeholder, rollback, restore); none
+ * of them is pruning.
+ */
+export declare class ConversationHistory {
+    /** Recent user turns kept uncompressed (age ceiling). */
+    static readonly KEEP_RECENT_TURNS = 8;
+    /** Token budget for full tool-result content kept live (size ceiling). */
+    static readonly DEFAULT_LIVE_TOKEN_BUDGET = 6000;
+    /** User turns kept when projecting for persistence. */
+    static readonly PERSISTENCE_KEEP_TURNS = 7;
+    private messages;
+    get length(): number;
+    append(message: ConversationMessage): void;
+    /** Append a synthetic assistant `tool_use` + the matching tool-result relay. */
+    appendToolExchange(assistant: AssistantMessage, relay: ToolRelayMessage): void;
+    /**
+     * Append user text, merging into the last message when it is already a
+     * user-role message (the API rejects consecutive same-role messages).
+     */
+    mergeOrAppendUserText(text: string): void;
+    /**
+     * Replace one result in the last relay (a server tool finalising a
+     * placeholder it committed earlier — e.g. create_plan after approval).
+     */
+    replaceLastResult(toolUseId: string, result: ToolResult): void;
+    peekLast(): ConversationMessage | undefined;
+    popLast(): void;
+    /**
+     * Remove the Nth real user turn (0-based) and everything after it. Throws if
+     * the index is out of range.
+     */
+    truncateAtUserTurn(index: number): void;
+    /** Replace the whole history from a persisted wire snapshot (restore). */
+    replaceAll(wire: GenericMessage[]): void;
+    clear(): void;
+    countUserTurns(): number;
+    /** Canonical messages as wire form — the "full" (uncompressed) view. */
+    toWireAll(): GenericMessage[];
+    /**
+     * Pure, deterministic projection of the conversation for the LLM. Returns a
+     * fresh `GenericMessage[]` exactly as long as the canonical history (1:1, so
+     * tool_use/tool_result pairing, turn indexing, and the cache-stable prefix
+     * are preserved). Never mutates canonical.
+     *
+     * Two ceilings combine (compress the union of both):
+     *  - age: user turns older than `keepRecentTurns` are compressed;
+     *  - size: tool-result rounds beyond `tokenBudget` (newest always kept full).
+     * Plus eager volatile staleness: a volatile query result with a later
+     * mutation collapses to `{ stale }` regardless of recency.
+     */
+    projectForLlm(isVolatile: VolatileLookup, opts?: LiveProjectionOptions): GenericMessage[];
+    /**
+     * Pure projection for persistence: trim to the last `keepTurns` user turns and
+     * aggressively compress (all tool results compressed, aux + old tool_use inputs
+     * stripped). No volatile metadata. Output is hashed + stored by the caller.
+     */
+    projectForPersistence(opts?: {
+        keepTurns?: number;
+    }): GenericMessage[];
+    /**
+     * Transcript rows: `seen` is the projected (compressed) content the LLM sees,
+     * `full` the canonical content — included only when it differs.
+     */
+    buildTranscriptMessages(isVolatile: VolatileLookup, opts?: LiveProjectionOptions): TranscriptMessage[];
+    private userTurnStartIndices;
+    /** Index before which messages are compressed by the age ceiling (0 = none). */
+    private ageCompressBoundary;
+    /** Index before which messages are compressed by the token-budget ceiling. */
+    private budgetCompressBoundary;
+    /**
+     * Tool-use ids of volatile query results that a later mutation made stale.
+     * Single backward scan tracking whether a mutation has been seen yet.
+     */
+    private computeStaleToolUseIds;
+}