@blokkli/editor 2.0.0-alpha.35 → 2.0.0-alpha.36

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

@@ -0,0 +1,138 @@
+<template>
+  <div class="bk-agent-transcript">
+    <section class="bk-agent-transcript-section">
+      <h3>System Prompts ({{ transcript.system.length }})</h3>
+      <details
+        v-for="prompt in transcript.system"
+        :key="prompt.id"
+        class="bk-agent-transcript-entry"
+      >
+        <summary>{{ prompt.name }}</summary>
+        <pre class="bk-agent-transcript-block">{{ prompt.content }}</pre>
+      </details>
+    </section>
+
+    <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>
+
+    <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
+          >
+        </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"
+            >
+              <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>
+      </div>
+    </section>
+  </div>
+</template>
+
+<script setup>
+defineProps({
+  transcript: { type: Object, required: true }
+});
+</script>
+
+<script>
+export default {
+  name: "AgentTranscript"
+};
+</script>

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

@@ -0,0 +1,8 @@
+import type { Transcript } from '#blokkli/agent/shared/types';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{
+    transcript: Transcript;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    transcript: Transcript;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

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

@@ -58,7 +58,10 @@
         full-screen
         @cancel="showTranscript = false"
       >
-        <pre class="bk-agent-transcript">{{ transcriptContent }}</pre>
+        <AgentTranscript
+          v-if="transcriptContent"
+          :transcript="transcriptContent"
+        />
       </DialogModal>
     </BlokkliTransition>
   </Teleport>
@@ -71,6 +74,7 @@ import { DialogModal, BlokkliTransition } from "#blokkli/editor/components";
 import agentProvider from "#blokkli/agent/app/composables/agentProvider";
 import { agentPrompts, agentName } from "#blokkli-build/agent-client";
 import AgentPanel from "./Panel/index.vue";
+import AgentTranscript from "./Transcript/index.vue";
 import { defineItemDropdownAction } from "#blokkli/editor/composables";
 const DEBUG_STYLING = false;
 const { adapter } = defineBlokkliFeature({

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

@@ -0,0 +1,175 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { getAvailableOptions } from "#blokkli/editor/helpers/options";
+import { getRuntimeOptionValue } from "#blokkli/runtime-helpers";
+import { blockOptionsMapSchema, extractOptionLabels } from "../schemas.js";
+const paramsSchema = z.object({
+  parentUuid: z.string().describe("The parent entity UUID"),
+  field: z.string().describe("The field name"),
+  bundles: z.array(z.string()).optional().describe(
+    "Optional list of bundle names to filter by. If omitted, returns all allowed bundles."
+  )
+});
+const bundleSchema = z.object({
+  bundle: z.string().describe("The paragraph type identifier"),
+  label: z.string().describe("Human-readable label"),
+  description: z.string().optional().describe("Bundle description if available"),
+  contentFields: z.record(
+    z.string(),
+    z.object({
+      type: z.string().describe("Field type: plain, markup, reference, or link")
+    })
+  ).describe(
+    "Content fields (text, media, links) on this bundle, keyed by field name"
+  ),
+  paragraphFields: z.record(
+    z.string(),
+    z.object({
+      label: z.string().describe("Human-readable label"),
+      allowedBundles: z.array(z.string()).describe("Paragraph types allowed in this field"),
+      cardinality: z.number().describe("Max paragraphs allowed (-1 = unlimited)")
+    })
+  ).describe(
+    "Paragraph fields (for nested paragraphs) on this bundle, keyed by field name"
+  ),
+  options: blockOptionsMapSchema.optional().describe(
+    "Available options for this bundle with their default values (only included when few bundles are returned)"
+  )
+});
+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"),
+  bundles: z.array(bundleSchema).describe("Available paragraph types"),
+  nestingInfo: z.string().optional().describe(
+    "Summary of which bundles have paragraph fields for nested paragraphs. Use get_child_paragraphs after adding these bundles to populate their nested fields."
+  )
+});
+export default defineBlokkliAgentTool({
+  name: "get_bundle_info",
+  description: "Get detailed information about which paragraph types can be added to a specific field, including their content fields and paragraph fields (for nested paragraphs).",
+  category: "query",
+  modes: ["readonly", "editing", "translating", "review"],
+  label($t) {
+    return $t("aiAgentGetBundleInfoRunning", "Getting bundle info...");
+  },
+  paramsSchema,
+  resultSchema,
+  execute(ctx, params) {
+    const { fields, types, state, definitions, $t } = ctx.app;
+    const label = $t(
+      "aiAgentGetBundleInfoDone",
+      "Got bundle info for @field"
+    ).replace("@field", params.field);
+    const field = fields.find(params.parentUuid, params.field);
+    if (!field) {
+      return {
+        label,
+        result: {
+          fieldLabel: params.field,
+          cardinality: -1,
+          currentCount: 0,
+          bundles: []
+        }
+      };
+    }
+    const fieldKey = `${params.parentUuid}:${params.field}`;
+    const currentCount = state.getFieldBlockCount(fieldKey);
+    const allowedBundles = params.bundles ? field.allowedBundles.filter((b) => params.bundles.includes(b)) : field.allowedBundles;
+    const includeOptions = allowedBundles.length < 3;
+    const bundles = allowedBundles.map((bundle) => {
+      const bundleDefinition = types.getBlockBundleDefinition(bundle);
+      const contentFields = {};
+      for (const c of types.editableFieldConfig.forEntityTypeAndBundle(ctx.itemEntityType, bundle).filter((c2) => c2.type !== "table")) {
+        contentFields[c.name] = {
+          type: c.type === "frame" || c.type === "markup" ? "markup" : "plain"
+        };
+      }
+      for (const c of types.droppableFieldConfig.forEntityTypeAndBundle(
+        ctx.itemEntityType,
+        bundle
+      )) {
+        contentFields[c.name] = { type: c.type };
+      }
+      const paragraphFields = {};
+      for (const c of types.fieldConfig.forEntityTypeAndBundle(
+        ctx.itemEntityType,
+        bundle
+      )) {
+        paragraphFields[c.name] = {
+          label: c.label,
+          allowedBundles: c.allowedBundles,
+          cardinality: c.cardinality
+        };
+      }
+      let options;
+      if (includeOptions) {
+        const definition = definitions.getBlockDefinition(bundle, "default");
+        if (definition) {
+          const availableOptions = getAvailableOptions(
+            definition.options,
+            definition.globalOptions,
+            definitions.globalOptions.value
+          );
+          if (availableOptions.length > 0) {
+            options = {};
+            for (const opt of availableOptions) {
+              const currentValue = getRuntimeOptionValue(
+                opt.option,
+                opt.option.default
+              );
+              const entry = {
+                type: opt.option.type,
+                label: opt.option.label,
+                currentValue
+              };
+              if (opt.option.description) {
+                entry.description = opt.option.description;
+              }
+              const labels = extractOptionLabels(opt.option);
+              if (labels) {
+                entry.options = labels;
+              }
+              if ("min" in opt.option) {
+                entry.min = opt.option.min;
+              }
+              if ("max" in opt.option) {
+                entry.max = opt.option.max;
+              }
+              if ("step" in opt.option && opt.option.type === "range") {
+                entry.step = opt.option.step;
+              }
+              options[opt.property] = entry;
+            }
+          }
+        }
+      }
+      return {
+        bundle,
+        label: bundleDefinition?.label ?? bundle,
+        description: bundleDefinition?.description,
+        contentFields,
+        paragraphFields,
+        options
+      };
+    });
+    const nestingBundles = bundles.filter(
+      (b) => Object.keys(b.paragraphFields).length > 0
+    );
+    const nestingInfo = nestingBundles.length ? nestingBundles.map(
+      (b) => `${b.bundle} has paragraph fields: ${Object.entries(
+        b.paragraphFields
+      ).map(([name, f]) => `${name} (${f.allowedBundles.join(", ")})`).join(", ")}`
+    ).join("; ") : void 0;
+    return {
+      label,
+      result: {
+        fieldLabel: field.label,
+        cardinality: field.cardinality,
+        currentCount,
+        bundles,
+        nestingInfo
+      }
+    };
+  }
+});

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

@@ -6,6 +6,7 @@ import {
   buildBlockOptionsMap
 } from "../schemas.js";
 import { getAvailableOptions } from "#blokkli/editor/helpers/options";
+import { fragmentBlockBundle } from "#blokkli-build/config";
 const paramsSchema = z.object({
   uuid: z.string().describe("The paragraph UUID"),
   includeParentChain: z.boolean().optional().default(true).describe("Include ancestor parent paragraphs up to the page"),
@@ -77,6 +78,7 @@ 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"),
+  fragmentName: z.string().optional().describe("The fragment name, if this paragraph is a fragment block"),
   nestingLevel: z.number().describe("Nesting depth (0 = root level)"),
   parent: parentSchema.nullable().describe("The parent entity containing this paragraph"),
   parentChain: z.array(parentChainItemSchema).optional().describe("Ancestor parent paragraphs from immediate parent to page"),
@@ -132,6 +134,9 @@ export default defineBlokkliAgentTool({
       nestingLevel: state.getNestingLevel(params.uuid),
       parent
     };
+    if (block.bundle === fragmentBlockBundle && block.fragment?.name) {
+      result.fragmentName = block.fragment.name;
+    }
     if (params.includeParentChain) {
       const parentChain = [];
       let currentUuid = state.getParentEntityUuid(params.uuid);

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

@@ -1,6 +1,11 @@
 import { z } from 'zod';
 import type { OptionItem } from '#blokkli/editor/helpers/options';
 import type { BlokkliApp } from '#blokkli/editor/types/app';
+/**
+ * Extract a simple key→label map from the various radios/checkboxes option formats.
+ * Handles plain strings, icon objects, color objects, grid objects, etc.
+ */
+export declare function extractOptionLabels(option: Record<string, unknown>): Record<string, string> | undefined;
 /**
  * Shared schema for a single block option with its current value.
  */
@@ -32,6 +37,10 @@ export type BlockOptionsMap = z.infer<typeof blockOptionsMapSchema>;
  * Build a block options map from available options and mutated state.
  */
 export declare function buildBlockOptionsMap(availableOptions: OptionItem[], mutatedOptions: Record<string, Record<string, string>>, uuid: string): BlockOptionsMap;
+/**
+ * Build a block options map from option definitions, using defaults as current values.
+ */
+export declare function buildBlockOptionsMapFromDefinitions(options: Record<string, Record<string, unknown>>): BlockOptionsMap;
 /**
  * Schema for a parent entity (the container of a block).
  * A parent is an entity + field combination where blocks can be placed.
@@ -50,9 +59,9 @@ export declare const mutationResultSchema: z.ZodUnion<readonly [z.ZodObject<{
     type: z.ZodEnum<{
         add: "add";
         delete: "delete";
-        options: "options";
         move: "move";
         rewrite: "rewrite";
+        options: "options";
     }>;
     label: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { getMutatedOptionValue } from "#blokkli/editor/helpers/options";
 import { getRuntimeOptionValue } from "#blokkli/runtime-helpers";
-function extractOptionLabels(option) {
+export function extractOptionLabels(option) {
   if (!("options" in option) || !option.options) return void 0;
   const raw = option.options;
   const labels = {};
@@ -42,31 +42,44 @@ export function buildBlockOptionsMap(availableOptions, mutatedOptions, uuid) {
       opt.option.default
     );
     const currentValue = getRuntimeOptionValue(opt.option, rawValue);
-    const entry = {
-      type: opt.option.type,
-      label: opt.option.label,
-      currentValue
-    };
-    if (opt.option.description) {
-      entry.description = opt.option.description;
-    }
-    const labels = extractOptionLabels(opt.option);
-    if (labels) {
-      entry.options = labels;
-    }
-    if ("min" in opt.option) {
-      entry.min = opt.option.min;
-    }
-    if ("max" in opt.option) {
-      entry.max = opt.option.max;
-    }
-    if ("step" in opt.option && opt.option.type === "range") {
-      entry.step = opt.option.step;
-    }
-    result[opt.property] = entry;
+    result[opt.property] = buildBlockOptionEntry(opt.option, currentValue);
   }
   return result;
 }
+export function buildBlockOptionsMapFromDefinitions(options) {
+  const result = {};
+  for (const [key, opt] of Object.entries(options)) {
+    result[key] = buildBlockOptionEntry(
+      opt,
+      opt.default
+    );
+  }
+  return result;
+}
+function buildBlockOptionEntry(opt, currentValue) {
+  const entry = {
+    type: opt.type,
+    label: opt.label,
+    currentValue
+  };
+  if (opt.description) {
+    entry.description = opt.description;
+  }
+  const labels = extractOptionLabels(opt);
+  if (labels) {
+    entry.options = labels;
+  }
+  if ("min" in opt) {
+    entry.min = opt.min;
+  }
+  if ("max" in opt) {
+    entry.max = opt.max;
+  }
+  if ("step" in opt && opt.type === "range") {
+    entry.step = opt.step;
+  }
+  return entry;
+}
 export const parentSchema = z.object({
   type: z.string().describe(
     "The entity type of the parent. Do NOT guess this - always use the parent object returned by get_child_paragraphs."

package/dist/modules/agent/runtime/server/Session.d.ts

@@ -28,8 +28,10 @@ export declare class Session {
     pendingPlanApproval: {
         resolve: (approved: boolean) => void;
     } | null;
-    /** Last tools payload sent to the provider (for transcript debugging) */
-    private lastProviderTools;
+    /** Pre-pruned messages snapshot for transcript (captured before pruneMessages) */
+    private unprunedMessages;
+    /** Last generic tool definitions for transcript */
+    private lastTools;
     init(tools: ClientToolDefinition[], pageContext: PageContext): void;
     start(peer: Peer, prompt: string, apiKey: string, authSecret: string, selectedUuids?: string[]): void;
     resolveToolResult(callId: string, result: {