@blokkli/editor 2.0.0-alpha.34 → 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.

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: {

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

@@ -1,4 +1,4 @@
-import { buildSystemPrompt, buildSystemPromptText } from "./agentPrompt.js";
+import { buildSystemPrompt, buildSystemPromptEntries } from "./agentPrompt.js";
 import { provider, models } from "#blokkli-build/agent-server";
 import {
   send,
@@ -42,8 +42,10 @@ export class Session {
   plan = null;
   /** Pending plan approval promise resolver */
   pendingPlanApproval = null;
-  /** Last tools payload sent to the provider (for transcript debugging) */
-  lastProviderTools = null;
+  /** Pre-pruned messages snapshot for transcript (captured before pruneMessages) */
+  unprunedMessages = [];
+  /** Last generic tool definitions for transcript */
+  lastTools = [];
   // --------------------------------------------------------------------------
   // Public methods
   // --------------------------------------------------------------------------
@@ -110,12 +112,14 @@ export class Session {
   getTranscript(peer) {
     send(peer, {
       type: "transcript",
-      content: this.buildTranscript()
+      transcript: this.buildTranscript()
     });
   }
   newConversation(peer, authSecret) {
     this.abortController?.abort();
     this.messages = [];
+    this.unprunedMessages = [];
+    this.lastTools = [];
     this.activatedLazyTools.clear();
     this.loadedSkills.clear();
     this.plan = null;
@@ -182,6 +186,8 @@ export class Session {
       return { success: false, reason: "Invalid message structure" };
     }
     this.messages = state.messages;
+    this.unprunedMessages = [];
+    this.lastTools = [];
     const validLazyToolNames = new Set(this.lazyTools.map((t) => t.name));
     this.activatedLazyTools = new Set(
       state.activatedLazyTools.filter((name) => validLazyToolNames.has(name))
@@ -273,6 +279,9 @@ export class Session {
     let planRetryCount = 0;
     let streamRetryCount = 0;
     const MAX_STREAM_RETRIES = 1;
+    let lastToolCallKey = "";
+    let consecutiveIdenticalCalls = 0;
+    const MAX_IDENTICAL_CALLS = 2;
     try {
       while (true) {
         if (this.abortController.signal.aborted) {
@@ -299,6 +308,7 @@ export class Session {
         };
         const serverToolDefs = serverTools.map((t) => buildDefinition(t, defCtx)).filter((d) => d !== null);
         const allTools = [...serverToolDefs, ...this.tools, ...activatedTools];
+        this.lastTools = allTools;
         const systemPrompt = buildSystemPrompt(
           this.pageContext,
           resolvedSkills,
@@ -326,7 +336,6 @@ export class Session {
             }
             switch (event.type) {
               case "debug_request":
-                this.lastProviderTools = event.tools;
                 break;
               case "text_start":
                 inTextBlock = true;
@@ -392,6 +401,25 @@ export class Session {
                     name: currentToolUse.name,
                     input
                   });
+                  const toolCallKey = currentToolUse.name + ":" + currentToolUse.inputJson;
+                  if (toolCallKey === lastToolCallKey) {
+                    consecutiveIdenticalCalls++;
+                  } else {
+                    lastToolCallKey = toolCallKey;
+                    consecutiveIdenticalCalls = 1;
+                  }
+                  if (consecutiveIdenticalCalls > MAX_IDENTICAL_CALLS) {
+                    toolResults.push({
+                      type: "tool_result",
+                      tool_use_id: currentToolUse.id,
+                      content: JSON.stringify({
+                        error: `You have called "${currentToolUse.name}" ${consecutiveIdenticalCalls} times in a row with identical parameters and received the same result each time. Stop repeating this call. Use the information you already have or try a different approach.`
+                      }),
+                      is_error: true
+                    });
+                    currentToolUse = null;
+                    break;
+                  }
                   const matchedServerTool = serverTools.find(
                     (t) => t.name === currentToolUse.name
                   );
@@ -600,6 +628,7 @@ export class Session {
     } finally {
       this.isProcessing = false;
       this.abortController = null;
+      this.unprunedMessages = structuredClone(this.messages);
       pruneMessages(
         this.messages,
         KEEP_RECENT_TURNS,
@@ -674,61 +703,36 @@ export class Session {
     return map;
   }
   buildTranscript() {
-    const lines = [];
-    let systemPrompt = "(No page context available)";
-    if (this.pageContext) {
-      const resolvedSkills = resolveSkills(this.pageContext);
-      const lazyToolSummaries = this.lazyTools.map((t) => ({
+    const system = this.pageContext ? buildSystemPromptEntries(
+      this.pageContext,
+      resolveSkills(this.pageContext),
+      this.lazyTools.map((t) => ({
         name: t.name,
         description: t.description
-      }));
-      systemPrompt = buildSystemPromptText(
-        this.pageContext,
-        resolvedSkills,
-        lazyToolSummaries,
-        this.getActivePlanContext()
-      );
-    }
-    lines.push("=".repeat(80));
-    lines.push("SYSTEM PROMPT");
-    lines.push("=".repeat(80));
-    lines.push(systemPrompt);
-    lines.push("");
-    if (this.lastProviderTools) {
-      lines.push("=".repeat(80));
-      lines.push("TOOLS (exact payload sent to provider)");
-      lines.push("=".repeat(80));
-      lines.push(JSON.stringify(this.lastProviderTools, null, 2));
-      lines.push("");
-    }
-    for (const message of this.messages) {
-      lines.push("=".repeat(80));
-      lines.push(`${message.role.toUpperCase()}`);
-      lines.push("=".repeat(80));
-      if (typeof message.content === "string") {
-        lines.push(message.content);
-      } else if (Array.isArray(message.content)) {
-        for (const block of message.content) {
-          if (block.type === "text") {
-            lines.push(block.text);
-          } else if (block.type === "skill") {
-            lines.push(`[Skill: ${block.name}]`);
-            lines.push(block.text);
-          } else if (block.type === "tool_use") {
-            lines.push(`[Tool Call: ${block.name}]`);
-            lines.push(JSON.stringify(block.input, null, 2));
-          } else if (block.type === "tool_result") {
-            lines.push(`[Tool Result: ${block.tool_use_id}]`);
-            try {
-              lines.push(JSON.stringify(JSON.parse(block.content), null, 2));
-            } catch {
-              lines.push(block.content);
-            }
-          }
+      })),
+      this.getActivePlanContext(),
+      this.loadedSkills
+    ) : [];
+    const messages = this.messages.map((msg, i) => {
+      const entry = {
+        type: msg.role === "assistant" ? "agent" : "user",
+        seen: msg.content
+      };
+      const unpruned = this.unprunedMessages[i];
+      if (unpruned) {
+        const seenJson = JSON.stringify(msg.content);
+        const fullJson = JSON.stringify(unpruned.content);
+        if (seenJson !== fullJson) {
+          entry.full = unpruned.content;
         }
       }
-      lines.push("");
-    }
-    return lines.join("\n");
+      return entry;
+    });
+    const tools = this.lastTools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.input_schema
+    }));
+    return { system, messages, tools };
   }
 }