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

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

@@ -4,11 +4,8 @@ import {
   getAvailableOptions,
   optionValueToStorable
 } from "#blokkli/editor/helpers/options";
-import {
-  mutationResultSchema,
-  optionValueSchema,
-  validateOptionValue
-} from "../schemas.js";
+import { mutationResultSchema, optionValueSchema } from "../schemas.js";
+import { validateOptionValue } from "../helpers.js";
 import { onlyUnique } from "#blokkli/helpers";
 const paragraphOptionsSchema = z.object({
   uuid: z.string().describe("The paragraph UUID"),

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

@@ -200,67 +200,6 @@ export type McpToolDefinition<TParamsSchema extends z.ZodType = z.ZodType, TResu
      */
     mockParamsVariants?: () => z.infer<TParamsSchema>[];
 };
-/**
- * A tool definition with a relaxed execute signature.
- *
- * Used as the return type for factory resolve callbacks. Preserves structural
- * checking on all other properties (catches typos and excess properties) while
- * allowing each tool to have its own specific execute signature via
- * defineBlokkliAgentTool().
- */
-export type FactoryResolvedTool = {
-    name: string;
-    description: string;
-    icon?: string;
-    category: McpToolCategory;
-    label: ($t: TranslationFunction) => string;
-    paramsSchema: z.ZodType;
-    resultSchema: z.ZodType;
-    requiredAdapterMethods?: readonly AdapterMethods[];
-    modes: EditMode[];
-    component?: Component;
-    requiresApproval?: boolean;
-    lazy?: boolean;
-    volatile?: boolean;
-    prunedSummary?: (result: any) => string;
-    execute: (...args: any[]) => any;
-    mockParams?: () => any;
-    mockParamsVariants?: () => any[];
-};
-/**
- * Input for a tool factory that dynamically creates tools at runtime.
- *
- * Instead of defining a single static tool, a factory uses a `resolve` callback
- * that is called when the agent connects. The callback returns an array of
- * McpToolDefinition objects, allowing tools to be created based on runtime state
- * (e.g., available content search tabs from the adapter).
- */
-export type McpToolFactoryInput = {
-    /**
-     * Called once when the agent connects. Returns an array of tool definitions
-     * that are registered as if they were statically defined.
-     *
-     * Each returned tool is a full McpToolDefinition with its own
-     * requiredAdapterMethods, execute function, and schemas. Use
-     * defineBlokkliAgentTool() for each tool to get full type inference.
-     *
-     * The context provides access to the app and adapter so the factory can
-     * query runtime state (e.g., available content search tabs) to decide
-     * which tools to create. If adapter methods are optional, check for their
-     * existence before calling them (or return an empty array).
-     */
-    resolve: (context: McpToolContext) => Promise<FactoryResolvedTool[]> | FactoryResolvedTool[];
-};
-/**
- * A tool factory with the __factory marker for runtime identification.
- */
-export type McpToolFactory = McpToolFactoryInput & {
-    __factory: true;
-};
-/**
- * A tool item is either a static tool definition or a factory that produces tools.
- */
-export type McpToolItem = McpToolDefinition | McpToolFactory;
 /**
  * A pre-defined agent prompt that users can select.
  */

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

@@ -1,5 +1,5 @@
 import type { Peer } from 'crossws';
-import type { PageContext, ClientToolDefinition, ConversationStateSnapshot, GenericMessage } from '../shared/types.js';
+import type { PageContext, ClientToolDefinition, ServerToolMetadata, ConversationStateSnapshot, GenericMessage } from '../shared/types.js';
 import type { ServerPlan } from './server-tools/index.js';
 export declare class Session {
     messages: GenericMessage[];
@@ -12,10 +12,10 @@ export declare class Session {
     }>;
     abortController: AbortController | null;
     isProcessing: boolean;
-    /** Eager tools sent to the LLM on every turn */
-    tools: ClientToolDefinition[];
-    /** Lazy tools held back until activated via load_tools */
-    lazyTools: ClientToolDefinition[];
+    /** Names of eager tools sent to the LLM on every turn */
+    toolNames: string[];
+    /** Names of lazy tools held back until activated via load_tools */
+    lazyToolNames: string[];
     /** Names of lazy tools that have been activated via load_tools */
     activatedLazyTools: Set<string>;
     /** Names of skills that have been loaded via load_skill */
@@ -28,9 +28,30 @@ export declare class Session {
     pendingPlanApproval: {
         resolve: (approved: boolean) => void;
     } | null;
-    /** Last tools payload sent to the provider (for transcript debugging) */
-    private lastProviderTools;
-    init(tools: ClientToolDefinition[], pageContext: PageContext): void;
+    /** Pre-pruned messages snapshot for transcript (captured before pruneMessages) */
+    private unprunedMessages;
+    /** Last generic tool definitions for transcript */
+    private lastTools;
+    /** Bundled tool metadata map for server-side resolution */
+    private bundledToolMap;
+    /** Cache for resolved JSON Schemas (Zod→JSON Schema is deterministic) */
+    private jsonSchemaCache;
+    constructor(toolDefinitions: ServerToolMetadata[]);
+    /**
+     * Resolve a single tool name into a ClientToolDefinition.
+     * Resolves from bundled metadata. Caches the JSON Schema conversion.
+     */
+    resolveToolDefinition(name: string): ClientToolDefinition | undefined;
+    /**
+     * Resolve multiple tool names into ClientToolDefinition objects.
+     * Skips names that cannot be resolved.
+     */
+    resolveToolDefinitions(names: string[]): ClientToolDefinition[];
+    /**
+     * Look up name + description for a tool.
+     */
+    private getToolSummary;
+    init(toolNames: string[], pageContext: PageContext): void;
     start(peer: Peer, prompt: string, apiKey: string, authSecret: string, selectedUuids?: string[]): void;
     resolveToolResult(callId: string, result: {
         result: unknown;

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

@@ -1,4 +1,5 @@
-import { buildSystemPrompt, buildSystemPromptText } from "./agentPrompt.js";
+import { z } from "zod";
+import { buildSystemPrompt, buildSystemPromptEntries } from "./agentPrompt.js";
 import { provider, models } from "#blokkli-build/agent-server";
 import {
   send,
@@ -12,7 +13,7 @@ import {
   verifyStateHash,
   validateMessages
 } from "./helpers.js";
-import { buildDefinition } from "./server-tools/index.js";
+import { buildDefinition, stripSchemaOverhead } from "./server-tools/index.js";
 import loadSkillTool from "./server-tools/load_skill/index.js";
 import loadToolsTool from "./server-tools/load_tools/index.js";
 import createPlanTool from "./server-tools/create_plan/index.js";
@@ -28,10 +29,10 @@ export class Session {
   pendingToolCalls = /* @__PURE__ */ new Map();
   abortController = null;
   isProcessing = false;
-  /** Eager tools sent to the LLM on every turn */
-  tools = [];
-  /** Lazy tools held back until activated via load_tools */
-  lazyTools = [];
+  /** Names of eager tools sent to the LLM on every turn */
+  toolNames = [];
+  /** Names of lazy tools held back until activated via load_tools */
+  lazyToolNames = [];
   /** Names of lazy tools that have been activated via load_tools */
   activatedLazyTools = /* @__PURE__ */ new Set();
   /** Names of skills that have been loaded via load_skill */
@@ -42,14 +43,77 @@ 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 = [];
+  /** Bundled tool metadata map for server-side resolution */
+  bundledToolMap;
+  /** Cache for resolved JSON Schemas (Zod→JSON Schema is deterministic) */
+  jsonSchemaCache = /* @__PURE__ */ new Map();
+  constructor(toolDefinitions) {
+    this.bundledToolMap = new Map(toolDefinitions.map((t) => [t.name, t]));
+  }
+  /**
+   * Resolve a single tool name into a ClientToolDefinition.
+   * Resolves from bundled metadata. Caches the JSON Schema conversion.
+   */
+  resolveToolDefinition(name) {
+    const bundled = this.bundledToolMap.get(name);
+    if (!bundled) return void 0;
+    let inputSchema = this.jsonSchemaCache.get(name);
+    if (!inputSchema) {
+      inputSchema = stripSchemaOverhead(
+        z.toJSONSchema(bundled.paramsSchema)
+      );
+      this.jsonSchemaCache.set(name, inputSchema);
+    }
+    return {
+      name: bundled.name,
+      description: bundled.description,
+      input_schema: inputSchema,
+      ...bundled.lazy ? { lazy: true } : {},
+      category: bundled.category,
+      ...bundled.volatile ? { volatile: true } : {}
+    };
+  }
+  /**
+   * Resolve multiple tool names into ClientToolDefinition objects.
+   * Skips names that cannot be resolved.
+   */
+  resolveToolDefinitions(names) {
+    const result = [];
+    for (const name of names) {
+      const def = this.resolveToolDefinition(name);
+      if (def) {
+        result.push(def);
+      }
+    }
+    return result;
+  }
+  /**
+   * Look up name + description for a tool.
+   */
+  getToolSummary(name) {
+    const bundled = this.bundledToolMap.get(name);
+    if (!bundled) return void 0;
+    return { name: bundled.name, description: bundled.description };
+  }
   // --------------------------------------------------------------------------
   // Public methods
   // --------------------------------------------------------------------------
-  init(tools, pageContext) {
-    this.tools = tools.filter((t) => !t.lazy);
-    this.lazyTools = tools.filter((t) => !!t.lazy);
+  init(toolNames, pageContext) {
+    this.toolNames = [];
+    this.lazyToolNames = [];
+    for (const name of toolNames) {
+      const bundled = this.bundledToolMap.get(name);
+      const isLazy = bundled?.lazy ?? false;
+      if (isLazy) {
+        this.lazyToolNames.push(name);
+      } else {
+        this.toolNames.push(name);
+      }
+    }
     this.activatedLazyTools = /* @__PURE__ */ new Set();
     this.loadedSkills = /* @__PURE__ */ new Set();
     this.pageContext = pageContext;
@@ -110,12 +174,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;
@@ -138,8 +204,8 @@ export class Session {
     }
     this.plan = null;
     this.messages = [];
-    this.tools = [];
-    this.lazyTools = [];
+    this.toolNames = [];
+    this.lazyToolNames = [];
     this.activatedLazyTools.clear();
     this.loadedSkills.clear();
     this.pageContext = void 0;
@@ -182,7 +248,9 @@ export class Session {
       return { success: false, reason: "Invalid message structure" };
     }
     this.messages = state.messages;
-    const validLazyToolNames = new Set(this.lazyTools.map((t) => t.name));
+    this.unprunedMessages = [];
+    this.lastTools = [];
+    const validLazyToolNames = new Set(this.lazyToolNames);
     this.activatedLazyTools = new Set(
       state.activatedLazyTools.filter((name) => validLazyToolNames.has(name))
     );
@@ -234,7 +302,7 @@ export class Session {
     });
   }
   async runAgentLoop(peer, prompt, apiKey, authSecret, selectedUuids) {
-    if (this.tools.length === 0) {
+    if (this.toolNames.length === 0) {
       send(peer, {
         type: "error",
         errorType: "bad_request",
@@ -251,10 +319,9 @@ export class Session {
       return;
     }
     const resolvedSkills = resolveSkills(this.pageContext);
-    const lazyToolSummaries = this.lazyTools.map((t) => ({
-      name: t.name,
-      description: t.description
-    }));
+    const lazyToolSummaries = this.lazyToolNames.map((name) => this.getToolSummary(name)).filter(
+      (s) => s !== void 0
+    );
     const userParts = [];
     if (selectedUuids?.length) {
       userParts.push(
@@ -273,6 +340,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) {
@@ -286,11 +356,16 @@ export class Session {
         let currentToolUse = null;
         let currentTextContent = "";
         let inTextBlock = false;
-        const activatedTools = this.lazyTools.filter(
-          (t) => this.activatedLazyTools.has(t.name)
+        const eagerTools = this.resolveToolDefinitions(this.toolNames);
+        const activatedToolNames = this.lazyToolNames.filter(
+          (name) => this.activatedLazyTools.has(name)
+        );
+        const activatedTools = this.resolveToolDefinitions(activatedToolNames);
+        const unloadedLazyToolNames = this.lazyToolNames.filter(
+          (name) => !this.activatedLazyTools.has(name)
         );
-        const unloadedLazyTools = this.lazyTools.filter(
-          (t) => !this.activatedLazyTools.has(t.name)
+        const unloadedLazyTools = unloadedLazyToolNames.map((name) => this.getToolSummary(name)).filter(
+          (s) => s !== void 0
         );
         const defCtx = {
           resolvedSkills,
@@ -298,7 +373,8 @@ export class Session {
           unloadedLazyTools
         };
         const serverToolDefs = serverTools.map((t) => buildDefinition(t, defCtx)).filter((d) => d !== null);
-        const allTools = [...serverToolDefs, ...this.tools, ...activatedTools];
+        const allTools = [...serverToolDefs, ...eagerTools, ...activatedTools];
+        this.lastTools = allTools;
         const systemPrompt = buildSystemPrompt(
           this.pageContext,
           resolvedSkills,
@@ -326,7 +402,6 @@ export class Session {
             }
             switch (event.type) {
               case "debug_request":
-                this.lastProviderTools = event.tools;
                 break;
               case "text_start":
                 inTextBlock = true;
@@ -392,6 +467,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
                   );
@@ -412,7 +506,7 @@ export class Session {
                       toolUseId: currentToolUse.id,
                       send: (msg) => send(peer, msg),
                       resolvedSkills,
-                      lazyTools: this.lazyTools,
+                      lazyToolNames: this.lazyToolNames,
                       activatedLazyTools: this.activatedLazyTools,
                       loadedSkills: this.loadedSkills,
                       plan: this.plan,
@@ -448,7 +542,20 @@ export class Session {
                       }
                     };
                     try {
-                      const parsed = matchedServerTool.inputSchema(defCtx).parse(input);
+                      const coercedInput = {};
+                      for (const key of Object.keys(input)) {
+                        const value = input[key];
+                        if (typeof value === "string" && (value[0] === "[" || value[0] === "{")) {
+                          try {
+                            coercedInput[key] = JSON.parse(value);
+                          } catch {
+                            coercedInput[key] = value;
+                          }
+                        } else {
+                          coercedInput[key] = value;
+                        }
+                      }
+                      const parsed = matchedServerTool.inputSchema(defCtx).parse(coercedInput);
                       const result = await matchedServerTool.handle(
                         handlerCtx,
                         parsed
@@ -600,6 +707,7 @@ export class Session {
     } finally {
       this.isProcessing = false;
       this.abortController = null;
+      this.unprunedMessages = structuredClone(this.messages);
       pruneMessages(
         this.messages,
         KEEP_RECENT_TURNS,
@@ -666,69 +774,44 @@ export class Session {
    */
   buildToolMetadataMap() {
     const map = /* @__PURE__ */ new Map();
-    for (const tool of [...this.tools, ...this.lazyTools]) {
-      if (tool.volatile) {
-        map.set(tool.name, { volatile: true });
+    for (const name of [...this.toolNames, ...this.lazyToolNames]) {
+      const bundled = this.bundledToolMap.get(name);
+      if (bundled?.volatile) {
+        map.set(name, { volatile: true });
       }
     }
     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) => ({
-        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);
-            }
-          }
+    const system = this.pageContext ? buildSystemPromptEntries(
+      this.pageContext,
+      resolveSkills(this.pageContext),
+      this.lazyToolNames.map((name) => this.getToolSummary(name)).filter(
+        (s) => s !== void 0
+      ),
+      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 };
   }
 }

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

@@ -1,9 +1,12 @@
 import { Session } from './Session.js';
+import type { ServerToolMetadata } from '../shared/types.js';
 export declare class SessionManager {
+    private toolDefinitions;
     private sessions;
     /** Maps used token strings to their embedded timestamp (seconds). */
     private usedTokens;
     private pruneTimer;
+    constructor(toolDefinitions: ServerToolMetadata[]);
     create(peerId: string): Session;
     get(peerId: string): Session | undefined;
     /**

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

@@ -3,6 +3,9 @@ import { Session } from "./Session.js";
 const TOKEN_EXPIRY_SECONDS = 300;
 const SESSION_IDLE_TIMEOUT_MS = 5 * 60 * 1e3;
 export class SessionManager {
+  constructor(toolDefinitions) {
+    this.toolDefinitions = toolDefinitions;
+  }
   sessions = /* @__PURE__ */ new Map();
   /** Maps used token strings to their embedded timestamp (seconds). */
   usedTokens = /* @__PURE__ */ new Map();
@@ -11,7 +14,7 @@ export class SessionManager {
     this.pruneTokens();
   }, 6e4);
   create(peerId) {
-    const session = new Session();
+    const session = new Session(this.toolDefinitions);
     this.sessions.set(peerId, { session, lastActivity: Date.now() });
     return session;
   }

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

@@ -2,7 +2,8 @@ import { defineWebSocketHandler, useRuntimeConfig } from "#imports";
 import { clientMessageSchema } from "../shared/types.js";
 import { SessionManager } from "./SessionManager.js";
 import { send } from "./helpers.js";
-const sessionManager = new SessionManager();
+import { toolDefinitions } from "#blokkli-build/agent-server";
+const sessionManager = new SessionManager(toolDefinitions);
 const config = useRuntimeConfig();
 const authSecret = config.blokkli?.agent?.authSecret || "";
 const apiKey = config.blokkli?.agent?.apiKey || "";
@@ -69,7 +70,7 @@ export default defineWebSocketHandler({
       }
       switch (data.type) {
         case "init":
-          session.init(data.tools, data.pageContext);
+          session.init(data.toolNames, data.pageContext);
           break;
         case "start":
           if (!apiKey) {

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

@@ -1,4 +1,4 @@
-import type { PageContext } from '../shared/types.js';
+import type { PageContext, TranscriptSystemPrompt } from '../shared/types.js';
 import type { ResolvedSkill } from './skills/types.js';
 import type { ActivePlanContext, SystemPromptBlock } from './system-prompts/types.js';
 /**
@@ -20,3 +20,11 @@ export declare function buildSystemPromptText(context: PageContext, resolvedSkil
     name: string;
     description: string;
 }[], activePlan?: ActivePlanContext, loadedSkills?: ReadonlySet<string>): string;
+/**
+ * Build structured system prompt entries for the transcript.
+ * Returns one entry per prompt definition with id, name, and content.
+ */
+export declare function buildSystemPromptEntries(context: PageContext, resolvedSkills: ResolvedSkill[], lazyTools?: {
+    name: string;
+    description: string;
+}[], activePlan?: ActivePlanContext, loadedSkills?: ReadonlySet<string>): TranscriptSystemPrompt[];

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

@@ -51,3 +51,29 @@ export function buildSystemPromptText(context, resolvedSkills, lazyTools = [], a
     loadedSkills
   ).map((b) => b.text).join("\n\n");
 }
+export function buildSystemPromptEntries(context, resolvedSkills, lazyTools = [], activePlan, loadedSkills = /* @__PURE__ */ new Set()) {
+  const promptContext = {
+    pageContext: context,
+    resolvedSkills,
+    lazyTools,
+    isDebugMode: !!(import.meta.dev && debugPrompt),
+    activePlan,
+    loadedSkills
+  };
+  const sorted = systemPrompts.filter((sp) => !sp.modes?.length || sp.modes.includes(context.editMode)).sort((a, b) => {
+    const groupDiff = getCacheGroupOrder(a) - getCacheGroupOrder(b);
+    if (groupDiff !== 0) return groupDiff;
+    return a.weight - b.weight;
+  });
+  const entries = [];
+  for (const sp of sorted) {
+    const text = sp.getPrompt(promptContext)?.trim();
+    if (!text) continue;
+    entries.push({
+      id: sp.id,
+      name: sp.title,
+      content: text
+    });
+  }
+  return entries;
+}

package/dist/modules/agent/runtime/server/default-skills/fixReadability.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../skills/index.js").SkillDefinition;
+export default _default;