@book.dev/sdk 3.8.0 → 3.10.0

package/dist/ai.d.ts

@@ -19,6 +19,7 @@
  *               only provider that sends content off the machine.
  */
 import type { StoredSuggestion } from './suggestions';
+import type { TableOpKind } from './tableSnapshot';
 export type AiProvider = 'off' | 'mock' | 'llama' | 'mlx' | 'openai' | 'claude';
 /**
  * How hard the agent works on a turn. One knob maps (server-side, in one
@@ -231,8 +232,17 @@ export interface AgentChatMessage {
 export interface AgentProposal {
     /** Stable id within the turn's change set. */
     id: string;
-    /** Which write tool produced it (drives how the bridge applies it). */
-    kind: 'set_kit_value' | 'set_db_cell' | 'update_block' | 'append_blocks' | 'set_page_theme' | 'delete_block' | 'set_block_props';
+    /**
+     * Which write tool produced it (drives how the bridge applies it). The
+     * `table_*` kinds (API-3) are the TABLE STRUCTURE ops — the bridge replays each
+     * by calling the editor's own `model.ts` op inside the proposal's single CRDT
+     * transaction, so an accepted table suggestion is one undo step and behaves
+     * exactly like the context-menu item. Their payloads carry SORTED (render-order)
+     * coordinates — `{tableId, rowIndex}` / `{tableId, colIndex}` / `{tableId,
+     * rowIndex, toIndex}` / `{tableId, rowIndex, colIndex, text}` — or a `cellId`
+     * (which resolves both indices), matching `cellPosition`.
+     */
+    kind: 'set_kit_value' | 'set_db_cell' | 'update_block' | 'append_blocks' | 'set_page_theme' | 'delete_block' | 'set_block_props' | TableOpKind;
     /** One-line human summary, e.g. `Set "budget" = 1200`. */
     summary: string;
     /** The page this change targets (for block/kit writes). */

package/dist/ai.js.map

@@ -1 +1 @@
-{"version":3,"file":"ai.js","sourceRoot":"","sources":["../src/ai.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAkEH;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAAgB,EAAE,QAAoB;IACrE,MAAM,KAAK,GAAG,MAAM,CAAC,SAAS,EAAE,CAAC,QAAQ,CAAC,CAAC;IAC3C,IAAI,KAAK;QAAE,OAAO,KAAK,CAAC;IACxB,IAAI,QAAQ,KAAK,MAAM,CAAC,QAAQ,EAAE,CAAC;QACjC,OAAO,EAAC,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAC,CAAC;IACzI,CAAC;IACD,OAAO,EAAE,CAAC;AACZ,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,cAAc,CAAC,QAAoB;IACjD,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,KAAK,QAAQ,CAAC;AACxD,CAAC"}
+{"version":3,"file":"ai.js","sourceRoot":"","sources":["../src/ai.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAmEH;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAAgB,EAAE,QAAoB;IACrE,MAAM,KAAK,GAAG,MAAM,CAAC,SAAS,EAAE,CAAC,QAAQ,CAAC,CAAC;IAC3C,IAAI,KAAK;QAAE,OAAO,KAAK,CAAC;IACxB,IAAI,QAAQ,KAAK,MAAM,CAAC,QAAQ,EAAE,CAAC;QACjC,OAAO,EAAC,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAC,CAAC;IACzI,CAAC;IACD,OAAO,EAAE,CAAC;AACZ,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,cAAc,CAAC,QAAoB;IACjD,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,KAAK,QAAQ,CAAC;AACxD,CAAC"}

package/dist/blockCatalogue.d.ts

@@ -0,0 +1,560 @@
+/**
+ * The block-type catalogue — the ONE types-only description of every block the
+ * editor can render, shared by every layer that must reason about block types
+ * without importing React:
+ *
+ *  - the UI's block model derives `BlockType`, `TEXT_BLOCKS` and
+ *    `CONTAINER_BLOCKS` FROM this file (packages/ui/src/blockeditor/model.ts),
+ *    so the core union cannot drift from the catalogue by construction;
+ *  - the UI's runtime registry (registry.tsx + kit) is pinned to the `kit`
+ *    entries by a drift-guard test (packages/ui/src/blockeditor/
+ *    registryCatalogue.test.tsx) that registers every built-in custom block and
+ *    fails when the registry and the catalogue disagree in either direction;
+ *  - the server agent and the MCP server validate `add_blocks` /
+ *    `create_artifact_page` / `update_block_props` payloads against it and
+ *    serve it via their `list_block_types` tools.
+ *
+ * History: before this file the agent kept a hand-written `KNOWN_BLOCK_TYPES`
+ * and the MCP server a hand-written `ARTIFACT_TYPES`; the two disagreed with
+ * each other AND with the real registry (table/row/cell, image, notes, and
+ * several kit blocks were missing from one or both). Those lists are gone —
+ * everything reads this catalogue.
+ *
+ * Plugin blocks are NOT enumerated here (they are installed per library, not
+ * compiled in). They are namespaced `<pluginId>/<type>` (plugins/api.ts), a
+ * plugin declares its block types in its manifest (`PluginManifest.blocks`),
+ * and validators accept them by pattern + an installed-plugin lookup where one
+ * is available — see {@link isPluginBlockType} and {@link findUnknownBlockType}.
+ */
+/** How a block stores content: `container` blocks carry child blocks in
+ *  `children`, `text` blocks carry rich text in `text`, `void` blocks carry
+ *  only `props` (all kit widgets are void). */
+export type BlockNature = 'container' | 'text' | 'void';
+/** The value shapes per-type prop validation understands. Deliberately coarse
+ *  — a permissive-but-typed check, not a schema language. */
+export type BlockPropType = 'string' | 'number' | 'boolean' | 'array' | 'object';
+export interface BlockTypeInfo {
+    /** The block `type` discriminator as stored in the document. */
+    readonly type: string;
+    /** `core` renders natively in the editor; `kit` is registered through the
+     *  custom-block registry at startup (artifact kit, reactive blocks, dbview).
+     *  Installed plugins contribute a third, per-library `plugin` category — see
+     *  the module note. */
+    readonly category: 'core' | 'kit';
+    readonly nature: BlockNature;
+    /** For child-only types: the ONE container this type must sit directly
+     *  inside (column→columns, row→table, cell→row, tab→tabs,
+     *  accordionsection→accordion). */
+    readonly parent?: string;
+    /** Well-known props → expected value type. Validation is permissive: props
+     *  NOT declared here always pass (the editor ignores what it doesn't know);
+     *  declared ones must match, `null` always passes (it removes the key). */
+    readonly props?: Readonly<Record<string, BlockPropType>>;
+    /** Publishes a named value into the page's reactive kit scope (mirrors
+     *  `INPUT_TYPES` in packages/ui/src/blockeditor/kit/scope.ts). */
+    readonly kitValue?: boolean;
+    /** One-line usage hint surfaced in tool descriptions / list_block_types. */
+    readonly hint?: string;
+}
+declare const CATALOGUE_LITERAL: readonly [{
+    readonly type: "paragraph";
+    readonly category: "core";
+    readonly nature: "text";
+    readonly hint: "plain rich text";
+}, {
+    readonly type: "heading";
+    readonly category: "core";
+    readonly nature: "text";
+    readonly props: {
+        readonly level: "number";
+    };
+    readonly hint: "{level:1|2|3}";
+}, {
+    readonly type: "list";
+    readonly category: "core";
+    readonly nature: "text";
+    readonly props: {
+        readonly kind: "string";
+    };
+    readonly hint: "{kind:\"bullet\"|\"number\"} — one block per item";
+}, {
+    readonly type: "todo";
+    readonly category: "core";
+    readonly nature: "text";
+    readonly props: {
+        readonly checked: "boolean";
+    };
+    readonly hint: "{checked?}";
+}, {
+    readonly type: "quote";
+    readonly category: "core";
+    readonly nature: "text";
+}, {
+    readonly type: "callout";
+    readonly category: "core";
+    readonly nature: "text";
+    readonly props: {
+        readonly variant: "string";
+    };
+    readonly hint: "{variant:\"info\"|\"warn\"|\"success\"}";
+}, {
+    readonly type: "code";
+    readonly category: "core";
+    readonly nature: "text";
+    readonly props: {
+        readonly language: "string";
+        readonly live: "boolean";
+        readonly name: "string";
+        readonly collapsed: "boolean";
+    };
+    readonly hint: "{language?,live?,name?,collapsed?}";
+}, {
+    readonly type: "notes";
+    readonly category: "core";
+    readonly nature: "text";
+    readonly hint: "speaker note — presenter view only, never exported";
+}, {
+    readonly type: "divider";
+    readonly category: "core";
+    readonly nature: "void";
+}, {
+    readonly type: "image";
+    readonly category: "core";
+    readonly nature: "void";
+    readonly props: {
+        readonly assetId: "string";
+        readonly src: "string";
+        readonly alt: "string";
+        readonly width: "string";
+    };
+    readonly hint: "{assetId|src,alt?,width?:\"60%\"}";
+}, {
+    readonly type: "htmlArtifact";
+    readonly category: "core";
+    readonly nature: "void";
+    readonly props: {
+        readonly assetId: "string";
+        readonly name: "string";
+        readonly height: "number";
+    };
+    readonly hint: "sandboxed HTML document {assetId,name?,height?}";
+}, {
+    readonly type: "columns";
+    readonly category: "core";
+    readonly nature: "container";
+    readonly hint: "side-by-side layout → column children (spans sum to 12)";
+}, {
+    readonly type: "column";
+    readonly category: "core";
+    readonly nature: "container";
+    readonly parent: "columns";
+    readonly props: {
+        readonly span: "number";
+    };
+    readonly hint: "{span:1-12}";
+}, {
+    readonly type: "table";
+    readonly category: "core";
+    readonly nature: "container";
+    readonly hint: "table → row → cell; give every row the same number of cells";
+}, {
+    readonly type: "row";
+    readonly category: "core";
+    readonly nature: "container";
+    readonly parent: "table";
+    readonly props: {
+        readonly header: "boolean";
+    };
+    readonly hint: "{header?} for the header row";
+}, {
+    readonly type: "cell";
+    readonly category: "core";
+    readonly nature: "text";
+    readonly parent: "row";
+    readonly hint: "one table cell (rich text)";
+}, {
+    readonly type: "group";
+    readonly category: "core";
+    readonly nature: "container";
+    readonly props: {
+        readonly name: "string";
+        readonly locked: "boolean";
+    };
+    readonly hint: "{name?,locked?}";
+}, {
+    readonly type: "tabs";
+    readonly category: "core";
+    readonly nature: "container";
+    readonly hint: "tabs → tab children";
+}, {
+    readonly type: "tab";
+    readonly category: "core";
+    readonly nature: "container";
+    readonly parent: "tabs";
+    readonly props: {
+        readonly label: "string";
+    };
+    readonly hint: "{label}";
+}, {
+    readonly type: "accordion";
+    readonly category: "core";
+    readonly nature: "container";
+    readonly props: {
+        readonly name: "string";
+        readonly gated: "boolean";
+    };
+    readonly hint: "{name?,gated?} → accordionsection children";
+}, {
+    readonly type: "accordionsection";
+    readonly category: "core";
+    readonly nature: "container";
+    readonly parent: "accordion";
+    readonly props: {
+        readonly label: "string";
+        readonly collapsed: "boolean";
+    };
+    readonly hint: "{label,collapsed?}";
+}, {
+    readonly type: "slider";
+    readonly category: "kit";
+    readonly nature: "void";
+    readonly kitValue: true;
+    readonly props: {
+        readonly name: "string";
+        readonly label: "string";
+        readonly value: "number";
+        readonly min: "number";
+        readonly max: "number";
+        readonly step: "number";
+    };
+    readonly hint: "{name,label?,value,min,max,step?}";
+}, {
+    readonly type: "number";
+    readonly category: "kit";
+    readonly nature: "void";
+    readonly kitValue: true;
+    readonly props: {
+        readonly name: "string";
+        readonly label: "string";
+        readonly value: "number";
+        readonly min: "number";
+        readonly max: "number";
+        readonly step: "number";
+    };
+    readonly hint: "{name,label?,value,min?,max?,step?}";
+}, {
+    readonly type: "textfield";
+    readonly category: "kit";
+    readonly nature: "void";
+    readonly kitValue: true;
+    readonly props: {
+        readonly name: "string";
+        readonly label: "string";
+        readonly value: "string";
+        readonly placeholder: "string";
+    };
+    readonly hint: "{name,label?,value?,placeholder?}";
+}, {
+    readonly type: "longtext";
+    readonly category: "kit";
+    readonly nature: "void";
+    readonly kitValue: true;
+    readonly props: {
+        readonly name: "string";
+        readonly label: "string";
+        readonly value: "string";
+        readonly placeholder: "string";
+    };
+    readonly hint: "{name,label?,value?,placeholder?}";
+}, {
+    readonly type: "richtext";
+    readonly category: "kit";
+    readonly nature: "void";
+    readonly kitValue: true;
+    readonly props: {
+        readonly name: "string";
+        readonly label: "string";
+        readonly runs: "array";
+    };
+    readonly hint: "{name,label?} — formatted long text";
+}, {
+    readonly type: "toggle";
+    readonly category: "kit";
+    readonly nature: "void";
+    readonly kitValue: true;
+    readonly props: {
+        readonly name: "string";
+        readonly label: "string";
+        readonly value: "boolean";
+    };
+    readonly hint: "{name,label?,value:boolean}";
+}, {
+    readonly type: "radio";
+    readonly category: "kit";
+    readonly nature: "void";
+    readonly kitValue: true;
+    readonly props: {
+        readonly name: "string";
+        readonly label: "string";
+        readonly opts: "array";
+    };
+    readonly hint: "{name,label?,value,opts:[{label,value}]}";
+}, {
+    readonly type: "dropdown";
+    readonly category: "kit";
+    readonly nature: "void";
+    readonly kitValue: true;
+    readonly props: {
+        readonly name: "string";
+        readonly label: "string";
+        readonly opts: "array";
+    };
+    readonly hint: "{name,label?,value,opts:[{label,value}]}";
+}, {
+    readonly type: "checklist";
+    readonly category: "kit";
+    readonly nature: "void";
+    readonly kitValue: true;
+    readonly props: {
+        readonly name: "string";
+        readonly label: "string";
+        readonly selected: "array";
+        readonly opts: "array";
+    };
+    readonly hint: "{name,label?,selected:[],opts}";
+}, {
+    readonly type: "choicecards";
+    readonly category: "kit";
+    readonly nature: "void";
+    readonly kitValue: true;
+    readonly props: {
+        readonly name: "string";
+        readonly label: "string";
+        readonly opts: "array";
+        readonly multi: "boolean";
+    };
+    readonly hint: "{name,label?,value,opts:[{label,value,icon?}],multi?}";
+}, {
+    readonly type: "searchselect";
+    readonly category: "kit";
+    readonly nature: "void";
+    readonly kitValue: true;
+    readonly props: {
+        readonly name: "string";
+        readonly label: "string";
+        readonly opts: "array";
+        readonly multi: "boolean";
+    };
+    readonly hint: "{name,label?,value,opts,multi?}";
+}, {
+    readonly type: "tagfield";
+    readonly category: "kit";
+    readonly nature: "void";
+    readonly kitValue: true;
+    readonly props: {
+        readonly name: "string";
+        readonly label: "string";
+        readonly selected: "array";
+        readonly freeEntry: "boolean";
+    };
+    readonly hint: "{name,label?,selected:[],freeEntry?}";
+}, {
+    readonly type: "location";
+    readonly category: "kit";
+    readonly nature: "void";
+    readonly kitValue: true;
+    readonly props: {
+        readonly name: "string";
+        readonly label: "string";
+    };
+    readonly hint: "{name,label?}";
+}, {
+    readonly type: "actionbutton";
+    readonly category: "kit";
+    readonly nature: "void";
+    readonly props: {
+        readonly btnlabel: "string";
+        readonly action: "string";
+        readonly target: "string";
+        readonly amount: "number";
+        readonly url: "string";
+    };
+    readonly hint: "{btnlabel,action:\"increment\"|\"set\"|\"toggle\"|\"link\",target?,amount?,url?}";
+}, {
+    readonly type: "kitchart";
+    readonly category: "kit";
+    readonly nature: "void";
+    readonly props: {
+        readonly kind: "string";
+        readonly title: "string";
+        readonly labels: "string";
+        readonly source: "string";
+    };
+    readonly hint: "{kind:\"line\"|\"area\"|\"bar\"|\"pie\"|\"donut\"|\"scatter\"|\"funnel\",title?,labels?,source}";
+}, {
+    readonly type: "statuslight";
+    readonly category: "kit";
+    readonly nature: "void";
+    readonly props: {
+        readonly label: "string";
+        readonly source: "string";
+        readonly okAt: "number";
+        readonly warnAt: "number";
+    };
+    readonly hint: "{label?,source,okAt,warnAt}";
+}, {
+    readonly type: "progressbar";
+    readonly category: "kit";
+    readonly nature: "void";
+    readonly props: {
+        readonly label: "string";
+        readonly source: "string";
+        readonly max: "number";
+        readonly format: "string";
+    };
+    readonly hint: "{label?,source,max?,format?}";
+}, {
+    readonly type: "formula";
+    readonly category: "kit";
+    readonly nature: "void";
+    readonly props: {
+        readonly source: "string";
+    };
+    readonly hint: "{source} — a JS expression over input names";
+}, {
+    readonly type: "linkcard";
+    readonly category: "kit";
+    readonly nature: "void";
+    readonly props: {
+        readonly title: "string";
+        readonly url: "string";
+        readonly description: "string";
+    };
+    readonly hint: "{title,url,description?}";
+}, {
+    readonly type: "tooltipcard";
+    readonly category: "kit";
+    readonly nature: "void";
+    readonly props: {
+        readonly term: "string";
+        readonly tip: "string";
+    };
+    readonly hint: "{term,tip}";
+}, {
+    readonly type: "dbview";
+    readonly category: "kit";
+    readonly nature: "void";
+    readonly props: {
+        readonly pageId: "string";
+    };
+    readonly hint: "embedded live database view {pageId} — the page hosting the database";
+}];
+/** The core block `type` union — the UI's `BlockType` is THIS type, so the
+ *  editor model and the catalogue cannot disagree about the core set. */
+export type CoreBlockType = Extract<(typeof CATALOGUE_LITERAL)[number], {
+    category: 'core';
+}>['type'];
+/** The catalogue, widened to the interface type for consumers (the `as const`
+ *  literal view above exists only for {@link CoreBlockType} extraction). */
+export declare const BLOCK_TYPE_CATALOGUE: readonly BlockTypeInfo[];
+/** The catalogue entry for a type, or undefined (plugin/unknown types). */
+export declare const blockTypeInfo: (type: string) => BlockTypeInfo | undefined;
+/** Every catalogued (core + kit) type id. */
+export declare const KNOWN_BLOCK_TYPE_IDS: ReadonlySet<string>;
+/** Core types whose `children` hold ordinary blocks. */
+export declare const CONTAINER_BLOCK_TYPES: ReadonlySet<CoreBlockType>;
+/** Core types that carry editable rich text. */
+export declare const TEXT_BLOCK_TYPES: ReadonlySet<CoreBlockType>;
+/** Child-only types → the one container each must sit directly inside. */
+export declare const CHILD_ONLY_PARENT: Readonly<Record<string, string>>;
+/**
+ * Whether `type` is plugin-NAMESPACED: `<pluginId>/<blockType>` (plugins/api.ts
+ * prefixes every registered plugin block with its manifest id). Pattern only —
+ * says nothing about whether such a plugin is installed.
+ */
+export declare const isPluginBlockType: (type: string) => boolean;
+/** The `<pluginId>` prefix of a plugin-namespaced type, or null. */
+export declare const pluginIdOfBlockType: (type: string) => string | null;
+/** Why {@link findUnknownBlockType} rejected a type. */
+export interface UnknownBlockType {
+    type: string;
+    reason: 'unknown' | 'plugin-not-installed';
+}
+/**
+ * The first block type (anywhere in the tree) that is neither catalogued nor an
+ * acceptable plugin type, or null when every type is fine.
+ *
+ * Plugin types (`<pluginId>/<type>`) validate by pattern, then — when the
+ * caller CAN enumerate installed plugins — by an installed-plugin lookup on the
+ * id prefix. Pass `installedPluginIds: undefined` when no plugin listing is
+ * available (older server, no client): pattern-valid plugin types are then
+ * accepted opaquely, as the apply layer always has (never crash on them).
+ */
+export declare function findUnknownBlockType(blocks: readonly unknown[], opts?: {
+    installedPluginIds?: ReadonlySet<string>;
+}, depth?: number): UnknownBlockType | null;
+/** A caller-facing message for an {@link UnknownBlockType}, or null. */
+export declare function unknownBlockTypeMessage(bad: UnknownBlockType | null): string | null;
+/**
+ * Max nesting depth for one write. Deep enough for every real layout —
+ * `columns → column → table → row → cell → group → tabs → tab → paragraph` is
+ * 9 with room to spare at 8 for the practical trees — and shallow enough that a
+ * runaway/recursive model response can't build a pathological tree the editor
+ * then has to render.
+ */
+export declare const MAX_BLOCK_DEPTH = 8;
+/**
+ * Max TOTAL blocks (all levels) in one write. A 20×8 table is 180 nodes, so
+ * this fits any sane single write while bounding one request's cost; a bigger
+ * document is several appends.
+ */
+export declare const MAX_BLOCK_NODES = 400;
+/**
+ * Validate a nested block payload's STRUCTURE against the catalogue: a
+ * `children` array only on a container-nature type (anything else silently
+ * drops the children at apply time), a child-only type only directly inside its
+ * matching container, every `table` square (each `row` holding the same number
+ * of `cell` children — a ragged table renders holes), and the depth/node caps.
+ * Returns an actionable message, or null when the payload is fine.
+ *
+ * Block TYPES are not this function's business ({@link findUnknownBlockType}
+ * covers those) — plugin/unknown leaf types walk through untouched.
+ */
+export declare function blockTreeError(blocks: readonly unknown[], opts?: {
+    maxDepth?: number;
+    maxNodes?: number;
+}): string | null;
+/**
+ * Per-type prop VALUE validation for one block's props patch. Permissive but
+ * typed: only props the catalogue declares for `type` (plus the common block
+ * props) are checked; unknown props pass, `null` passes (it removes the key),
+ * and plugin/unknown types pass entirely. Returns a message, or null.
+ */
+export declare function invalidBlockProps(type: string, props: Record<string, unknown>): string | null;
+/** The manifest-declared blocks of an installed plugin, as the catalogue
+ *  listing consumes them (a structural subset of the SDK's `StoredPlugin`). */
+export interface PluginBlockSource {
+    manifest: {
+        id: string;
+        name?: string;
+        blocks?: ReadonlyArray<{
+            type: string;
+            description?: string;
+        }>;
+    };
+    enabled?: boolean;
+}
+/**
+ * The full catalogue as `list_block_types` text: every core + kit entry, then
+ * one `plugin` entry per block each installed plugin DECLARES in its manifest
+ * (`PluginManifest.blocks`). Pass the installed plugins where a listing is
+ * available; omit it and the plugin section says so instead of guessing.
+ */
+export declare function blockCatalogueText(plugins?: readonly PluginBlockSource[]): string;
+/**
+ * The `add_blocks` tool description, generated from the catalogue so the type
+ * list in the model's guidance can never drift from what validation accepts
+ * (this replaces the old hand-written BLOCK_CATALOGUE prose in the agent).
+ */
+export declare function addBlocksGuidance(): string;
+export {};