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

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

@@ -1,21 +1,4 @@
 import { z } from "zod";
-import { getMutatedOptionValue } from "#blokkli/editor/helpers/options";
-import { getRuntimeOptionValue } from "#blokkli/runtime-helpers";
-export function extractOptionLabels(option) {
-  if (!("options" in option) || !option.options) return void 0;
-  const raw = option.options;
-  const labels = {};
-  for (const [key, value] of Object.entries(raw)) {
-    if (typeof value === "string") {
-      labels[key] = value;
-    } else if (typeof value === "object" && value !== null && "label" in value) {
-      labels[key] = String(value.label);
-    } else {
-      labels[key] = key;
-    }
-  }
-  return labels;
-}
 export const blockOptionSchema = z.object({
   type: z.string().describe(
     "The option type (checkbox, radios, checkboxes, text, number, range, color, datetime-local)"
@@ -32,54 +15,6 @@ export const blockOptionsMapSchema = z.record(
   z.string().describe("Option property name"),
   blockOptionSchema
 );
-export function buildBlockOptionsMap(availableOptions, mutatedOptions, uuid) {
-  const result = {};
-  for (const opt of availableOptions) {
-    const rawValue = getMutatedOptionValue(
-      mutatedOptions,
-      uuid,
-      opt.property,
-      opt.option.default
-    );
-    const currentValue = getRuntimeOptionValue(opt.option, rawValue);
-    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."
@@ -104,131 +39,9 @@ export const optionValueSchema = z.union([
   z.number(),
   z.array(z.string())
 ]);
-export function validateOptionValue(key, value, optionDef) {
-  const optionType = optionDef.option.type;
-  if (optionType === "checkbox") {
-    if (typeof value !== "boolean" && value !== "1" && value !== "0" && value !== "true" && value !== "false") {
-      return `Option "${key}" expects a boolean value`;
-    }
-  } else if (optionType === "radios") {
-    if (typeof value !== "string") {
-      return `Option "${key}" expects a string value`;
-    }
-    if ("options" in optionDef.option && optionDef.option.options) {
-      const allowedKeys = Object.keys(optionDef.option.options);
-      if (!allowedKeys.includes(value)) {
-        return `Option "${key}" value must be one of: ${allowedKeys.join(", ")}`;
-      }
-    }
-  } else if (optionType === "checkboxes") {
-    if (!Array.isArray(value) && typeof value !== "string") {
-      return `Option "${key}" expects an array of strings or comma-separated string`;
-    }
-    if ("options" in optionDef.option && optionDef.option.options) {
-      const allowedKeys = Object.keys(optionDef.option.options);
-      const values = Array.isArray(value) ? value : value.split(",");
-      for (const v of values) {
-        if (!allowedKeys.includes(v)) {
-          return `Option "${key}" value "${v}" is not allowed. Must be one of: ${allowedKeys.join(", ")}`;
-        }
-      }
-    }
-  } else if (optionType === "number" || optionType === "range") {
-    const numValue = typeof value === "number" ? value : Number.parseFloat(String(value));
-    if (Number.isNaN(numValue)) {
-      return `Option "${key}" expects a numeric value`;
-    }
-    if ("min" in optionDef.option && numValue < optionDef.option.min) {
-      return `Option "${key}" value must be >= ${optionDef.option.min}`;
-    }
-    if ("max" in optionDef.option && numValue > optionDef.option.max) {
-      return `Option "${key}" value must be <= ${optionDef.option.max}`;
-    }
-  }
-  return void 0;
-}
-export function getFieldType(app, entityType, bundle, fieldName) {
-  const config = app.types.editableFieldConfig.forName(
-    entityType,
-    bundle,
-    fieldName
-  );
-  if (!config) return null;
-  if (config.type === "table") return null;
-  if (config.type === "frame" || config.type === "markup") return "markup";
-  return "plain";
-}
-export function getEditableValue(app, entityType, uuid, bundle, fieldName, fieldType) {
-  const editables = app.directive.getEditablesForBlock(uuid);
-  const editable = editables.find((e) => e.fieldName === fieldName);
-  if (editable?.getValue) {
-    return editable.getValue();
-  }
-  const element = app.directive.findEditableElement(fieldName, {
-    type: entityType,
-    uuid,
-    bundle
-  });
-  if (element) {
-    return fieldType === "markup" ? element.innerHTML || "" : element.textContent || "";
-  }
-  return "";
-}
-export function getParagraphChildren(app, uuid) {
-  const result = [];
-  for (const field of app.state.mutatedFields.value) {
-    if (field.entityUuid === uuid && field.list.length > 0) {
-      result.push({
-        fieldName: field.name,
-        paragraphs: field.list.map((item) => ({
-          uuid: item.uuid,
-          bundle: item.bundle
-        }))
-      });
-    }
-  }
-  return result;
-}
 export const positionSchema = z.string().optional().default("end").describe(
   'Where to place the paragraph(s). "start" = beginning, "end" (default) = append at end, "after:<UUID>" = after a specific paragraph, "before:<UUID>" = before a specific paragraph.'
 );
-export function resolvePosition(app, parentUuid, fieldName, position) {
-  const fieldList = app.state.mutatedFields.value.find(
-    (f) => f.entityUuid === parentUuid && f.name === fieldName
-  );
-  const list = fieldList?.list ?? [];
-  if (position === void 0 || position === "end") {
-    const lastBlock = list.at(-1);
-    return { afterUuid: lastBlock?.uuid ?? null };
-  }
-  if (position === "start") {
-    return { afterUuid: null };
-  }
-  if (position.startsWith("after:")) {
-    const uuid = position.slice(6);
-    const found = list.find((b) => b.uuid === uuid);
-    if (!found) {
-      return {
-        error: `Position "after:${uuid}": paragraph not found in field "${fieldName}".`
-      };
-    }
-    return { afterUuid: uuid };
-  }
-  if (position.startsWith("before:")) {
-    const uuid = position.slice(7);
-    const index = list.findIndex((b) => b.uuid === uuid);
-    if (index === -1) {
-      return {
-        error: `Position "before:${uuid}": paragraph not found in field "${fieldName}".`
-      };
-    }
-    const preceding = index > 0 ? list[index - 1] : void 0;
-    return { afterUuid: preceding?.uuid ?? null };
-  }
-  return {
-    error: `Invalid position value: "${position}". Use "start", "end", "after:<UUID>", or "before:<UUID>".`
-  };
-}
 export const mutationSuccessSchema = z.union([
   z.object({
     success: z.literal(true),

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

@@ -13,53 +13,46 @@ const resultSchema = z.array(
   })
 );
 export default defineBlokkliAgentTool({
-  resolve: async (ctx) => {
-    if (!ctx.adapter.getContentSearchTabs || !ctx.adapter.getContentSearchResults) {
-      return [];
-    }
+  name: "search_content",
+  description: 'Search for content items by tab ID and query. The available tab IDs and their entity types are listed in the system prompt under "Content Search Tabs". Use the tab ID that matches the type of content you are looking for.',
+  category: "query",
+  lazy: true,
+  requiredAdapterMethods: ["getContentSearchTabs", "getContentSearchResults"],
+  modes: ["readonly", "editing", "translating", "review"],
+  label($t) {
+    return $t("aiAgentSearchContentRunning", "Searching content...");
+  },
+  paramsSchema: z.object({
+    tab: z.string().describe(
+      "The tab ID to search in. See the system prompt for available tab IDs."
+    ),
+    query: z.string().describe("The search query")
+  }),
+  resultSchema,
+  async execute(ctx, params) {
     const tabs = await ctx.adapter.getContentSearchTabs();
-    return tabs.map((tab) => {
-      const typesDescription = tab.types.map((type) => {
-        return `${type.type} (${type.bundles.join(", ")})`;
-      }).join(", ");
-      const description = `Content search for these entities: ${typesDescription}`;
-      return defineBlokkliAgentTool({
-        name: `search_content_${tab.id}`,
-        description,
-        category: "query",
-        lazy: true,
-        requiredAdapterMethods: [
-          "getContentSearchTabs",
-          "getContentSearchResults"
-        ],
-        modes: ["readonly", "editing", "translating", "review"],
-        label() {
-          return `Searching ${tab.title}...`;
-        },
-        paramsSchema: z.object({
-          query: z.string().describe(`Search query for ${tab.title}`)
-        }),
-        resultSchema,
-        async execute(toolCtx, params) {
-          const items = await toolCtx.adapter.getContentSearchResults(
-            tab.id,
-            params.query
-          );
-          return {
-            label: `Searched ${tab.title} for "${params.query}"`,
-            result: items.map((item) => ({
-              id: item.id,
-              title: item.title,
-              entityType: item.entityType,
-              entityBundle: item.entityBundle,
-              targetBundles: item.targetBundles,
-              context: item.context,
-              text: item.text,
-              imageUrl: item.imageUrl
-            }))
-          };
-        }
-      });
-    });
+    const tab = tabs.find((t) => t.id === params.tab);
+    if (!tab) {
+      return {
+        error: `Invalid tab ID "${params.tab}". Available tabs: ${tabs.map((t) => t.id).join(", ")}`
+      };
+    }
+    const items = await ctx.adapter.getContentSearchResults(
+      params.tab,
+      params.query
+    );
+    return {
+      label: `Searched ${tab.title} for "${params.query}"`,
+      result: items.map((item) => ({
+        id: item.id,
+        title: item.title,
+        entityType: item.entityType,
+        entityBundle: item.entityBundle,
+        targetBundles: item.targetBundles,
+        context: item.context,
+        text: item.text,
+        imageUrl: item.imageUrl
+      }))
+    };
   }
 });

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 */
@@ -32,7 +32,26 @@ export declare class Session {
     private unprunedMessages;
     /** Last generic tool definitions for transcript */
     private lastTools;
-    init(tools: ClientToolDefinition[], pageContext: PageContext): void;
+    /** 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,3 +1,4 @@
+import { z } from "zod";
 import { buildSystemPrompt, buildSystemPromptEntries } from "./agentPrompt.js";
 import { provider, models } from "#blokkli-build/agent-server";
 import {
@@ -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 */
@@ -46,12 +47,73 @@ export class Session {
   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;
@@ -142,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;
@@ -188,7 +250,7 @@ export class Session {
     this.messages = state.messages;
     this.unprunedMessages = [];
     this.lastTools = [];
-    const validLazyToolNames = new Set(this.lazyTools.map((t) => t.name));
+    const validLazyToolNames = new Set(this.lazyToolNames);
     this.activatedLazyTools = new Set(
       state.activatedLazyTools.filter((name) => validLazyToolNames.has(name))
     );
@@ -240,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",
@@ -257,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(
@@ -295,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,
@@ -307,7 +373,7 @@ 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,
@@ -440,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,
@@ -476,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
@@ -695,9 +774,10 @@ 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;
@@ -706,10 +786,9 @@ export class Session {
     const system = this.pageContext ? buildSystemPromptEntries(
       this.pageContext,
       resolveSkills(this.pageContext),
-      this.lazyTools.map((t) => ({
-        name: t.name,
-        description: t.description
-      })),
+      this.lazyToolNames.map((name) => this.getToolSummary(name)).filter(
+        (s) => s !== void 0
+      ),
       this.getActivePlanContext(),
       this.loadedSkills
     ) : [];

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;
     /**