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

package/dist/modules/agent/runtime/app/features/agent/Transcript/index.vue

@@ -1,144 +1,90 @@
 <template>
-  <div class="bk-agent-transcript">
-    <section class="bk-agent-transcript-section">
-      <h3>System Prompts ({{ transcript.system.length }})</h3>
-      <details
+  <div class="_bk_select-text">
+    <PanelSection title="System Prompts">
+      <template #post-title>
+        <Pill :text="transcript.system.length" />
+      </template>
+      <PanelDetails
         v-for="prompt in transcript.system"
         :key="prompt.id"
-        class="bk-agent-transcript-entry"
+        :title="prompt.id"
+        :description="prompt.name"
       >
-        <summary>{{ prompt.name }}</summary>
-        <pre class="bk-agent-transcript-block">{{ prompt.content }}</pre>
-      </details>
-    </section>
+        <pre class="_bk_font-mono _bk_text-sm _bk_whitespace-pre-wrap">{{
+          prompt.content
+        }}</pre>
+      </PanelDetails>
+    </PanelSection>
 
-    <section class="bk-agent-transcript-section">
-      <h3>Tools ({{ transcript.tools.length }})</h3>
-      <details
-        v-for="tool in transcript.tools"
-        :key="tool.name"
-        class="bk-agent-transcript-entry"
-      >
-        <summary>{{ tool.name }}</summary>
-        <div class="bk-agent-transcript-block">
-          <p>{{ tool.description }}</p>
-          <pre>{{ JSON.stringify(tool.input_schema, null, 2) }}</pre>
-        </div>
-      </details>
-    </section>
+    <PanelSection title="Tools">
+      <template #post-title>
+        <Pill :text="transcript.tools.length" />
+      </template>
+      <template v-if="transcript.tools.length">
+        <PanelDetails
+          v-for="tool in transcript.tools"
+          :key="tool.name"
+          :title="tool.name"
+          :description="tool.description"
+        >
+          <pre class="bk-agent-transcript-block">{{
+            JSON.stringify(tool.input_schema, null, 2)
+          }}</pre>
+        </PanelDetails>
+      </template>
+      <div v-else class="_bk_p-panel-gap">No tools loaded.</div>
+    </PanelSection>
 
-    <section class="bk-agent-transcript-section">
-      <h3>Messages ({{ transcript.messages.length }})</h3>
-      <div
-        v-for="(message, i) in transcript.messages"
-        :key="i"
-        class="bk-agent-transcript-message"
-      >
-        <div class="bk-agent-transcript-role">
-          {{ message.type === "agent" ? "AGENT" : "USER" }}
-          <span v-if="message.full" class="bk-agent-transcript-pruned"
-            >(pruned)</span
+    <PanelSection title="Messages">
+      <template #post-title>
+        <Pill :text="transcript.messages.length" />
+      </template>
+      <div>
+        <div
+          v-for="(message, i) in transcript.messages"
+          :key="i"
+          class="_bk_p-panel-gap _bk_border-b _bk_border-b-mono-300 _bk_last:border-b-0"
+        >
+          <div
+            class="_bk_flex _bk_items-center _bk_gap-5 _bk_text-accent-700 _bk_font-bold _bk_text-xs _bk_uppercase _bk_tracking-wider _bk_mb-10"
           >
-        </div>
-        <div class="bk-agent-transcript-content">
-          <template v-if="typeof message.seen === 'string'">
-            <pre class="bk-agent-transcript-block">{{ message.seen }}</pre>
-          </template>
-          <template v-else>
-            <div
-              v-for="(block, j) in message.seen"
-              :key="j"
-              class="bk-agent-transcript-block"
+            {{ message.type === "agent" ? "AGENT" : "USER" }}
+            <span
+              v-if="message.full"
+              class="_bk_font-normal _bk_lowercase _bk_text-yellow-dark"
+              >(pruned)</span
             >
-              <template v-if="block.type === 'text'">
-                <pre>{{ block.text }}</pre>
-              </template>
-              <template v-else-if="block.type === 'skill'">
-                <div class="bk-agent-transcript-label">
-                  Skill: {{ block.name }}
-                </div>
-                <pre>{{ block.text }}</pre>
-              </template>
-              <template v-else-if="block.type === 'tool_use'">
-                <div class="bk-agent-transcript-label">
-                  Tool Use: {{ block.name }} ({{ block.id }})
-                </div>
-                <pre>{{ JSON.stringify(block.input, null, 2) }}</pre>
-              </template>
-              <template v-else-if="block.type === 'tool_result'">
-                <div class="bk-agent-transcript-label">
-                  Tool Result ({{ block.tool_use_id }})
-                  <span v-if="block.is_error" class="bk-agent-transcript-error"
-                    >ERROR</span
-                  >
-                </div>
-                <pre>{{ block.content }}</pre>
-              </template>
-            </div>
-          </template>
-        </div>
-
-        <details v-if="message.full" class="bk-agent-transcript-entry">
-          <summary>Original (before pruning)</summary>
-          <div class="bk-agent-transcript-content">
-            <template v-if="typeof message.full === 'string'">
-              <pre class="bk-agent-transcript-block">{{ message.full }}</pre>
-            </template>
-            <template v-else>
-              <div
-                v-for="(block, j) in message.full"
-                :key="j"
-                class="bk-agent-transcript-block"
-              >
-                <template v-if="block.type === 'text'">
-                  <pre>{{ block.text }}</pre>
-                </template>
-                <template v-else-if="block.type === 'skill'">
-                  <div class="bk-agent-transcript-label">
-                    Skill: {{ block.name }}
-                  </div>
-                  <pre>{{ block.text }}</pre>
-                </template>
-                <template v-else-if="block.type === 'tool_use'">
-                  <div class="bk-agent-transcript-label">
-                    Tool Use: {{ block.name }} ({{ block.id }})
-                  </div>
-                  <pre>{{ JSON.stringify(block.input, null, 2) }}</pre>
-                </template>
-                <template v-else-if="block.type === 'tool_result'">
-                  <div class="bk-agent-transcript-label">
-                    Tool Result ({{ block.tool_use_id }})
-                    <span
-                      v-if="block.is_error"
-                      class="bk-agent-transcript-error"
-                      >ERROR</span
-                    >
-                  </div>
-                  <pre>{{ block.content }}</pre>
-                </template>
-              </div>
-            </template>
           </div>
-        </details>
+          <MessageContent :content="message.seen" />
+          <PanelDetails v-if="message.full" title="Original (before pruning)">
+            <MessageContent :content="message.full" />
+          </PanelDetails>
+        </div>
       </div>
-    </section>
+    </PanelSection>
 
-    <section v-if="transcript.lastRequest" class="bk-agent-transcript-section">
-      <h3>
-        Last Request
-        <button @click="copyLastRequest">
-          {{ copied ? "Copied!" : "Copy JSON" }}
-        </button>
-      </h3>
+    <PanelSection v-if="transcript.lastRequest" title="Last Request" padded>
       <pre class="bk-agent-transcript-block">{{
         JSON.stringify(transcript.lastRequest, null, 2)
       }}</pre>
-    </section>
+      <template #actions>
+        <PanelAction
+          :title="copied ? 'Copied!' : 'Copy JSON'"
+          icon="bk_mdi_content_copy"
+          @click="copyLastRequest"
+        />
+      </template>
+    </PanelSection>
   </div>
 </template>
 
 <script setup>
 import { ref, onBeforeUnmount } from "#imports";
+import PanelSection from "#blokkli/editor/components/Panel/Section/index.vue";
+import PanelDetails from "#blokkli/editor/components/Panel/Details/index.vue";
+import PanelAction from "#blokkli/editor/components/Panel/Action/index.vue";
+import MessageContent from "./MessageContent.vue";
+import { Pill } from "#blokkli/editor/components";
 const props = defineProps({
   transcript: { type: Object, required: true }
 });
@@ -169,3 +115,18 @@ export default {
   name: "AgentTranscript"
 };
 </script>
+
+<style>/*! tailwindcss v4.2.4 | MIT License | https://tailwindcss.com */
+.bk-agent-transcript-block {
+  margin: 0px;
+  border-radius: 4px;
+  background-color: rgb(var(--bk-theme-mono-100) / 1);
+  padding: 10px;
+  font-family: monospace;
+  font-size: var(--text-xs, 12px);
+  line-height: var(--bk-tw-leading, var(--text-xs--line-height, calc(1 / 0.75)));
+  overflow-wrap: break-word;
+  white-space: pre-wrap;
+  color: rgb(var(--bk-theme-mono-900) / 1);
+}
+</style>

package/dist/modules/agent/runtime/app/features/agent/index.vue

@@ -20,7 +20,6 @@
       <AgentContainer
         v-if="shouldRender"
         :is-shown
-        :agent-name
         :adapter
         :pending-prompt-request="pendingPromptRequest"
         @consumed="pendingPromptRequest = null"
@@ -42,6 +41,15 @@
       <p v-html="popupText" />
     </Popup>
   </Teleport>
+
+  <Teleport v-if="canManageConversations" :to="ui.mainLayoutElement.value">
+    <BlokkliTransition name="slide-up">
+      <ConversationsAdminDialog
+        v-if="showConversationsAdmin"
+        @cancel="closeConversationsAdmin"
+      />
+    </BlokkliTransition>
+  </Teleport>
 </template>
 
 <script setup>
@@ -54,10 +62,16 @@ import {
   defineAsyncComponent
 } from "#imports";
 import { PluginSidebar } from "#blokkli/editor/plugins";
-import { Icon, Popup } from "#blokkli/editor/components";
+import { Icon, Popup, BlokkliTransition } from "#blokkli/editor/components";
 import { agentPrompts, agentName } from "#blokkli-build/agent-prompts";
-import { defineItemDropdownAction } from "#blokkli/editor/composables";
+import {
+  defineItemDropdownAction,
+  defineMenuButton
+} from "#blokkli/editor/composables";
 const AgentContainer = defineAsyncComponent(() => import("./Container.vue"));
+const ConversationsAdminDialog = defineAsyncComponent(
+  () => import("./ConversationsAdmin/index.vue")
+);
 const { adapter } = defineBlokkliFeature({
   id: "agent",
   icon: "stars",
@@ -72,7 +86,31 @@ const { adapter } = defineBlokkliFeature({
   ]
 });
 const app = useBlokkli();
-const { $t, ui } = app;
+const { $t, ui, permissions } = app;
+const canManageConversations = permissions.hasPermission(
+  "manage_agent_conversations"
+);
+const showConversationsAdmin = computed(
+  () => ui.currentDialog.value?.id === "agentConversations"
+);
+function closeConversationsAdmin() {
+  ui.closeDialog("agentConversations");
+}
+defineMenuButton(() => {
+  if (!canManageConversations) return void 0;
+  if (!adapter.agentConversations?.queryConversations) return void 0;
+  return {
+    id: "agentConversations",
+    title: $t("agentConversations", "Agent conversations"),
+    description: $t(
+      "agentConversationsMenuDescription",
+      "Browse and manage all agent conversations."
+    ),
+    icon: "bk_mdi_forum",
+    secondary: true,
+    callback: () => ui.openDialog({ id: "agentConversations", alignment: "center" })
+  };
+});
 const popup = useTemplateRef("popup");
 const pendingPromptRequest = shallowRef(null);
 function closeAgentPopup() {
@@ -125,3 +163,62 @@ export default {
   name: "Agent"
 };
 </script>
+
+<style>/*! tailwindcss v4.2.4 | MIT License | https://tailwindcss.com */
+@keyframes bk-sparkle {
+  0%,
+  100% {
+    opacity: 1;
+    transform: scale(1);
+  }
+  50% {
+    opacity: 0.7;
+    transform: scale(0.6);
+  }
+}
+.bk #bk-sidebar-button-agent {
+  color: white;
+}
+:is(.bk #bk-sidebar-button-agent) svg {
+  width: 30px;
+  height: 30px;
+  --bk-tw-translate-x: -7%;
+  translate: var(--bk-tw-translate-x) var(--bk-tw-translate-y);
+}
+:is(.bk .bk-icon-stars.bk-is-animated) svg path {
+  animation: bk-sparkle 3s ease-in-out infinite;
+}
+:is(:is(.bk .bk-icon-stars.bk-is-animated) svg path):nth-child(1) {
+  transform-origin: 19px 19px;
+  animation-delay: 0.6s;
+}
+:is(:is(.bk .bk-icon-stars.bk-is-animated) svg path):nth-child(2) {
+  transform-origin: 9px 12px;
+  animation-delay: 0s;
+}
+:is(:is(.bk .bk-icon-stars.bk-is-animated) svg path):nth-child(3) {
+  transform-origin: 19px 5px;
+  animation-delay: 1.2s;
+}
+:is(.bk-popup.bk-is-agent .bk-popup-content-text) .bk-icon {
+  float: right;
+  margin-left: 2px;
+}
+:is(:is(.bk-popup.bk-is-agent .bk-popup-content-text) .bk-icon) svg {
+  width: 60px;
+  height: 60px;
+  fill: rgb(var(--bk-theme-accent-600) / 1);
+}
+:is(.bk-popup.bk-is-agent .bk-popup-content-text) p {
+  -webkit-hyphens: auto;
+  hyphens: auto;
+}
+:is(:is(.bk-popup.bk-is-agent .bk-popup-content-text) p) em {
+  --bk-tw-font-weight: var(--font-weight-bold, 700);
+  font-weight: var(--font-weight-bold, 700);
+  -webkit-hyphens: none;
+  hyphens: none;
+  color: rgb(var(--bk-theme-accent-600) / 1);
+  font-style: normal;
+}
+</style>

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

@@ -1,4 +1,7 @@
 import type { AgentPromptDefinition } from '#blokkli/agent/app/types';
+import type { BlokkliUser } from '#blokkli/editor/types/user';
+import type { AdapterSearchArguments } from '#blokkli/editor/adapter';
+import type { PluginConfigInput } from '#blokkli/editor/types/pluginConfig';
 /**
  * A pending request from the outer feature's item-dropdown action that the
  * inner container consumes on mount (or on change if already mounted).
@@ -7,20 +10,30 @@ export type PendingPromptRequest = {
     prompt: AgentPromptDefinition;
     selectedUuids: string[];
 };
-export type AgentConversationData = {
+export type AgentConversationHostInfo = {
+    entityType: string;
+    entityUuid: string;
+    label?: string | null;
+    editUrl?: string | null;
+};
+export type AgentConversationItem = {
     uuid: string;
     title: string;
+    createdAt: string;
+    updatedAt: string;
+    host: AgentConversationHostInfo | null;
+    /** The conversation's creator, or `null` when their account has been deleted. */
+    author: BlokkliUser | null;
+};
+export type AgentConversationItemSummary = Omit<AgentConversationItem, 'host' | 'author'>;
+export type AgentConversationData = AgentConversationItem & {
     clientState: string;
     serverState: string;
     hash: string;
     feedbackItemIds?: string[];
+    feedback?: AgentConversationFeedbackItem[];
 };
-export type AgentConversationSummary = {
-    uuid: string;
-    title: string;
-    createdAt: string;
-    updatedAt: string;
-};
+export type AgentConversationUpsert = Pick<AgentConversationData, 'uuid' | 'title' | 'clientState' | 'serverState' | 'hash'>;
 export type AgentConversationFeedbackRating = 'bad' | 'fine' | 'good';
 export type AgentConversationFeedback = {
     conversationId: string;
@@ -28,9 +41,32 @@ export type AgentConversationFeedback = {
     lastItemId: string;
     comment?: string;
 };
+export type AgentConversationFeedbackItem = {
+    id: string;
+    createdAt: string;
+    rating: AgentConversationFeedbackRating;
+    comment: string | null;
+    itemId: string;
+    /** Who left the feedback, or `null` when their account has been deleted. */
+    author: BlokkliUser | null;
+    conversationUuid: string;
+};
+export type AgentConversationQueryResult = {
+    filters: PluginConfigInput[];
+    items: AgentConversationItem[];
+    total: number;
+    perPage: number;
+};
+export type AgentConversationFeedbackQueryResult = {
+    filters: PluginConfigInput[];
+    items: AgentConversationFeedbackItem[];
+    total: number;
+    perPage: number;
+};
 declare module '#blokkli/editor/types/permissions' {
     interface UserPermissionMap {
         use_agent: 'Use the AI agent.';
+        manage_agent_conversations: 'Browse and delete agent conversations across all entities and users.';
     }
 }
 declare module '#blokkli/editor/adapter' {
@@ -54,26 +90,57 @@ declare module '#blokkli/editor/adapter' {
          */
         getAgentAuthToken?: () => Promise<string | null>;
         /**
-         * Manage persisted agent conversations for the current entity.
+         * Manage persisted agent conversations.
          *
          * Each conversation is stored as a structured record with separate
          * fields for client state, server state, and the HMAC hash.
          * Timestamps (createdAt, updatedAt) are managed by the backend.
          */
         agentConversations?: {
-            upsert: (data: AgentConversationData) => Promise<boolean>;
+            upsert: (data: AgentConversationUpsert) => Promise<boolean>;
+            /**
+             * Load a conversation by its globally unique UUID. The backend
+             * authorizes based on conversation ownership or the
+             * `manage_agent_conversations` permission.
+             */
             load: (uuid: string) => Promise<AgentConversationData | null>;
+            /**
+             * Load the most recently updated conversation for the current host
+             * entity (the entity the editor is open on).
+             */
             loadLatest: () => Promise<AgentConversationData | null>;
-            list: () => Promise<AgentConversationSummary[]>;
+            /**
+             * List conversations for the current host entity.
+             */
+            list: () => Promise<AgentConversationItemSummary[]>;
             delete: (uuid: string) => Promise<boolean>;
+            /**
+             * Submit user feedback for a conversation item. Feedback is stored
+             * separately from conversation data and should survive conversation
+             * deletion. The `lastItemId` references the item visible when the
+             * user submitted the rating.
+             */
+            submitFeedback?: (feedback: AgentConversationFeedback) => Promise<boolean>;
+            /**
+             * Query conversations across all host entities and users, with
+             * pagination. Ordered newest first. The shape mirrors
+             * `mediaLibraryGetResults` so the same paginated-list pattern can
+             * be reused on the consumer side.
+             *
+             * Backends must enforce the `manage_agent_conversations` permission
+             * server-side. The frontend gates the UI but never trusts it.
+             */
+            queryConversations?: (e: AdapterSearchArguments) => Promise<AgentConversationQueryResult>;
+            /**
+             * Query feedback ratings across all conversations and users, with
+             * pagination. Ordered newest first. Each entry is joined with its
+             * parent conversation so the consumer can render without a second
+             * roundtrip per row. The shape mirrors `mediaLibraryGetResults`.
+             *
+             * Backends must enforce the `manage_agent_conversations` permission
+             * server-side.
+             */
+            queryFeedback?: (e: AdapterSearchArguments) => Promise<AgentConversationFeedbackQueryResult>;
         };
-        /**
-         * Submit user feedback for an agent conversation.
-         *
-         * Feedback is stored separately from the conversation data and should
-         * survive conversation deletion. The lastItemId references the
-         * conversation item visible when the user gave feedback.
-         */
-        submitConversationFeedback?: (feedback: AgentConversationFeedback) => Promise<boolean>;
     }
 }

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

@@ -0,0 +1,14 @@
+import type { MutationItem } from '#blokkli/editor/types/state';
+/**
+ * A snapshot identifier for the mutation at a given history index. Used to
+ * detect whether a previously snapshotted rollback target is still reachable —
+ * the index alone is not enough because manual undo + new edits can replace
+ * mutations in place while keeping the array length similar.
+ */
+export declare function computeHistorySignature(mutations: MutationItem[], index: number): string;
+/**
+ * Returns true when `index` still exists in `mutations` AND the mutation at
+ * that position still matches the recorded `signature`. Used to decide
+ * whether to show retry/edit on a user message.
+ */
+export declare function isHistorySnapshotReachable(mutations: MutationItem[], index: number | undefined, signature: string | undefined): boolean;

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

@@ -0,0 +1,13 @@
+export function computeHistorySignature(mutations, index) {
+  if (index < 0) return "pristine";
+  const m = mutations[index];
+  if (!m) return "unknown";
+  return `${m.timestamp ?? ""}|${m.pluginId ?? ""}|${m.plugin?.label ?? ""}`;
+}
+export function isHistorySnapshotReachable(mutations, index, signature) {
+  if (index === void 0 || signature === void 0) return false;
+  if (index < -1) return false;
+  if (index === -1) return signature === "pristine";
+  if (index >= mutations.length) return false;
+  return computeHistorySignature(mutations, index) === signature;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Generate a short, unique-enough id for client-side conversation items and
+ * tool calls. Not cryptographic — use `generateUUID` for anything persisted as
+ * a stable identity.
+ */
+export declare function generateId(): string;

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

@@ -0,0 +1,3 @@
+export function generateId() {
+  return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}

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

@@ -29,15 +29,6 @@ export declare function createToolMap(tools: McpToolDefinition[]): Record<string
  * 3. `tool.isAvailable(app)` (if defined) must return (or resolve to) true.
  */
 export declare function getToolInfoForServer(tools: McpToolDefinition[], editMode: EditMode, app: BlokkliApp, adapter?: BlokkliAdapter<unknown>): Promise<string[]>;
-/**
- * Coerce stringified JSON values back to their actual types.
- *
- * LLMs sometimes double-serialize array or object parameters, sending e.g.
- * `"[\"readability\"]"` (a string) instead of `["readability"]` (an array).
- * This walks the params and attempts JSON.parse on any string that looks like
- * a JSON array or object.
- */
-export declare function coerceStringifiedParams(params: Record<string, unknown>): Record<string, unknown>;
 /**
  * Execute a tool by name with the given context and parameters.
  * Validates parameters with Zod before executing.
@@ -63,8 +54,3 @@ export declare function isQueryResult(result: unknown): result is QueryResult;
  * Check if a result is a ToolError.
  */
 export declare function isToolError(result: unknown): result is ToolError;
-/**
- * Resolve an array of tool definitions into a flat array.
- * All tools are now static — no factory resolution needed.
- */
-export declare function resolveTools(tools: McpToolDefinition[], _context: McpToolContext): Promise<McpToolDefinition[]>;

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

@@ -1,3 +1,4 @@
+import { coerceStringifiedParams } from "#blokkli/agent/shared/toolParams";
 export function asRecord(value) {
   return typeof value === "object" && value !== null ? value : null;
 }
@@ -33,22 +34,6 @@ export async function getToolInfoForServer(tools, editMode, app, adapter) {
   );
   return staticFiltered.filter((_, index) => availability[index]).map((t) => t.name);
 }
-export function coerceStringifiedParams(params) {
-  const result = {};
-  for (const key of Object.keys(params)) {
-    const value = params[key];
-    if (typeof value === "string" && (value[0] === "[" || value[0] === "{")) {
-      try {
-        result[key] = JSON.parse(value);
-      } catch {
-        result[key] = value;
-      }
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
 export async function executeTool(toolMap, name, context, params) {
   const tool = toolMap[name];
   if (!tool) {
@@ -81,6 +66,3 @@ export function isQueryResult(result) {
 export function isToolError(result) {
   return typeof result === "object" && result !== null && "error" in result && typeof result.error === "string";
 }
-export async function resolveTools(tools, _context) {
-  return tools;
-}

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

@@ -0,0 +1,7 @@
+/** Shared marked options for all agent markdown rendering. */
+export declare const markedOptions: {
+    readonly gfm: true;
+    readonly breaks: true;
+};
+/** Render markdown to an HTML string using the shared options. */
+export declare function renderMarkdown(content: string): string;

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

@@ -0,0 +1,5 @@
+import { marked } from "marked";
+export const markedOptions = { gfm: true, breaks: true };
+export function renderMarkdown(content) {
+  return marked.parse(content, markedOptions);
+}

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

@@ -1,4 +1,7 @@
-import { getParagraphChildren } from "#blokkli/agent/app/tools/helpers";
+import {
+  getParagraphChildren,
+  readBlockContentFields
+} from "#blokkli/agent/app/tools/helpers";
 import { itemEntityType } from "#blokkli-build/config";
 const MAX_CONTENT_LENGTH = 150;
 function truncate(text) {
@@ -8,26 +11,11 @@ function truncate(text) {
 }
 export function buildBlock(app, uuid, bundle) {
   const block = { uuid, bundle };
-  const editables = app.directive.getEditablesForBlock(uuid);
   const content = {};
-  for (const editable of editables) {
-    const fieldType = app.fieldValue.resolveFieldType(
-      itemEntityType,
-      bundle,
-      editable.fieldName
-    );
-    if (!fieldType) continue;
-    const raw = app.fieldValue.readValue(
-      itemEntityType,
-      uuid,
-      bundle,
-      editable.fieldName,
-      fieldType
-    );
-    const text = raw;
-    const truncated = truncate(text);
+  for (const f of readBlockContentFields(app, uuid, itemEntityType, bundle)) {
+    const truncated = truncate(f.value);
     if (truncated) {
-      content[editable.fieldName] = truncated;
+      content[f.fieldName] = truncated;
     }
   }
   if (Object.keys(content).length > 0) {