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

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

@@ -1,11 +1,4 @@
 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.
  */
@@ -33,14 +26,6 @@ export declare const blockOptionsMapSchema: z.ZodRecord<z.ZodString, z.ZodObject
     currentValue: z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber, z.ZodArray<z.ZodString>]>;
 }, z.core.$strip>>;
 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.
@@ -71,32 +56,6 @@ export declare const mutationResultSchema: z.ZodUnion<readonly [z.ZodObject<{
  * Shared schema for option values (used by add_blocks and set_block_options).
  */
 export declare const optionValueSchema: z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber, z.ZodArray<z.ZodString>]>;
-/**
- * Validate a single option value against its definition.
- * Returns an error string or undefined if valid.
- */
-export declare function validateOptionValue(key: string, value: string | boolean | number | string[], optionDef: OptionItem): string | undefined;
-/**
- * Resolve an editable field config to its simplified type.
- * Returns 'plain' for text fields, 'markup' for rich text/frame fields, null for unsupported.
- */
-export declare function getFieldType(app: BlokkliApp, entityType: string, bundle: string, fieldName: string): 'plain' | 'markup' | null;
-/**
- * Read the current value of an editable field on a block or entity.
- * Tries the registered getValue() callback first, falls back to DOM element reading.
- */
-export declare function getEditableValue(app: BlokkliApp, entityType: string, uuid: string, bundle: string, fieldName: string, fieldType: 'plain' | 'markup'): string;
-/**
- * Get all child fields and their paragraphs for a given entity UUID.
- * Walks mutatedFields to find fields belonging to the entity.
- */
-export declare function getParagraphChildren(app: BlokkliApp, uuid: string): {
-    fieldName: string;
-    paragraphs: {
-        uuid: string;
-        bundle: string;
-    }[];
-}[];
 /**
  * Shared schema for the `position` parameter used by mutation tools that insert blocks.
  *
@@ -107,17 +66,6 @@ export declare function getParagraphChildren(app: BlokkliApp, uuid: string): {
  * - `"before:<UUID>"` — insert before the block with the given UUID
  */
 export declare const positionSchema: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-/**
- * Resolve a `position` string to the `afterUuid` value expected by adapter methods.
- *
- * Returns `{ afterUuid: string | null }` on success, or `{ error: string }` if
- * the referenced UUID is not found in the target field.
- */
-export declare function resolvePosition(app: BlokkliApp, parentUuid: string, fieldName: string, position?: string): {
-    afterUuid: string | null;
-} | {
-    error: string;
-};
 /**
  * Schema for the success result sent back to the AI after mutation is applied.
  */

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;