@angflow/angular 0.0.17 → 0.0.19

package/README.md

@@ -180,6 +180,59 @@ flowService.screenToFlowPosition({ x: event.clientX, y: event.clientY });
 flowService.toObject(); // { nodes, edges, viewport }
 ```
 
+## Floating Edges
+
+Set `edgeMode="floating"` and edges attach wherever the line to the peer node's
+center crosses each node's border — no handle declarations needed:
+
+```html
+<ng-flow [nodes]="nodes" [edges]="edges" edgeMode="floating" />
+```
+
+Works with nodes that declare zero handles, which makes it ideal for
+programmatic / agent-driven graphs. Note: a node with no handles cannot
+originate an interactive drag-connection — declared handles still work for
+starting connections while rendering stays floating. For per-edge control in
+the default mode, set `floating` on individual handles instead:
+`<ng-flow-handle type="source" [floating]="true" />`.
+
+## Auto-Layout
+
+`layoutNodes` is a pure dagre wrapper — feed it your nodes and edges, get back
+a map of top-left positions:
+
+```ts
+import { layoutNodes } from '@angflow/angular/layout'; // needs @dagrejs/dagre installed
+
+const positions = layoutNodes(flow.getNodes(), flow.getEdges(), { direction: 'LR' });
+flow.setNodePositions(positions);
+
+// or in one call:
+flow.applyLayout(layoutNodes, { direction: 'LR' });
+```
+
+Options: `direction` (`'TB' | 'LR' | 'BT' | 'RL'`, default `'TB'`), `nodeSep`
+(default 50), `rankSep` (default 80). Node dimensions resolve from
+`measured` → `width`/`height` → `initialWidth`/`initialHeight` → 150×40. Any
+function with the same shape plugs
+into `applyLayout` (elk, custom grids, …).
+
+## Animations
+
+Turn on `[animate]` and the flow animates node entries (fade + scale) and
+programmatic position changes (smooth tween, edges tracking mid-flight):
+
+```html
+<ng-flow [nodes]="nodes" [edges]="edges" [animate]="true" />
+<!-- or tune the duration: -->
+<ng-flow [animate]="{ duration: 200 }" />
+```
+
+Animated paths: `setNodePositions`, `applyLayout`, and the agent bridge's
+`layout_nodes` tool. Dragging is never animated, a drag cancels any in-flight
+tween on that node, and everything is disabled under `prefers-reduced-motion`.
+Per-call override: `flow.setNodePositions(positions, { animate: false })`.
+
 ## Architecture
 
 - **Signal-based state** — Angular 17+ signals for fine-grained reactivity (no RxJS in the store)

package/dist/base.css

@@ -955,6 +955,24 @@ svg.xy-flow__connectionline {
 }
 
 
+/* Entry animation — applied by the node renderer when [animate] is enabled.
+   Uses the standalone `scale` property so it composes with the inline
+   translate() transform instead of overriding it. */
+.xy-flow__node-enter {
+  animation: xy-flow-node-enter 300ms ease both;
+  transform-origin: 50% 50%;
+}
+
+@keyframes xy-flow-node-enter {
+  from { opacity: 0; scale: 0.92; }
+  to   { opacity: 1; scale: 1; }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .xy-flow__node-enter { animation: none; }
+}
+
+
 .xy-flow__node-input,
 .xy-flow__node-default,
 .xy-flow__node-output,

package/dist/esm/lib/agent/agent-bridge.service.d.ts

@@ -1,5 +1,6 @@
 import { InjectionToken } from '@angular/core';
 import type { NgFlowService } from '../services/ng-flow.service';
+import type { AgentLayoutFn } from '../types/node-template';
 import type { AgentHistoryOptions } from './history';
 import type { AgentTransport } from './types';
 import * as i0 from "@angular/core";
@@ -13,6 +14,8 @@ export declare const AGENT_ON_ERROR: InjectionToken<(err: unknown, ctx: {
     transport?: AgentTransport;
     method?: string;
 }) => void>;
+/** Optional host-provided layout function backing the `layout_nodes` tool. */
+export declare const AGENT_LAYOUT: InjectionToken<AgentLayoutFn>;
 /**
  * Routes JSON-RPC requests from one or more transports to registered
  * `NgFlowService` instances, and pushes change events back to the agent.
@@ -45,6 +48,7 @@ export declare class AngflowAgentBridge {
     private readonly history;
     private readonly handlers;
     private readonly injector;
+    private readonly layoutFn;
     private started;
     private nextInProcessId;
     private warnedOnBeforeDeleteBypass;
@@ -55,7 +59,7 @@ export declare class AngflowAgentBridge {
         kind: 'transport-start' | 'transport-send' | 'dispatch';
         transport?: AgentTransport;
         method?: string;
-    }) => void) | null);
+    }) => void) | null, layoutFn: AgentLayoutFn | null);
     private reportError;
     /**
      * Register a flow under `id`. The bridge subscribes to its `nodes`,
@@ -85,7 +89,7 @@ export declare class AngflowAgentBridge {
     private resolveFlow;
     private watchFlow;
     private installHandlers;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AngflowAgentBridge, [{ optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AngflowAgentBridge, [{ optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<AngflowAgentBridge>;
 }
 //# sourceMappingURL=agent-bridge.service.d.ts.map

package/dist/esm/lib/agent/agent-bridge.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-bridge.service.d.ts","sourceRoot":"","sources":["../../../../src/lib/agent/agent-bridge.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,cAAc,EAOf,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAGjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAErD,OAAO,KAAK,EAGV,cAAc,EAEf,MAAM,SAAS,CAAC;;AAEjB,6DAA6D;AAC7D,eAAO,MAAM,gBAAgB,kCAAiE,CAAC;AAE/F,4EAA4E;AAC5E,eAAO,MAAM,qBAAqB,6CAEjC,CAAC;AAEF,0FAA0F;AAC1F,eAAO,MAAM,cAAc,uBACnB,OAAO,OAAO;IAAE,IAAI,EAAE,iBAAiB,GAAG,gBAAgB,GAAG,UAAU,CAAC;IAAC,SAAS,CAAC,EAAE,cAAc,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,KAAK,IAAI,CAC/G,CAAC;AAiCzB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBACa,kBAAkB;IAC7B,uFAAuF;IACvF,QAAQ,CAAC,WAAW,sCAAsB;IAE1C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqC;IAC3D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAmB;IAC9C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsB;IAC9C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkC;IAC3D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoB;IAC7C,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,eAAe,CAAK;IAC5B,OAAO,CAAC,0BAA0B,CAAS;IAE3C,8EAA8E;IAC9E,QAAQ,CAAC,eAAe,mDAAwB;IAEhD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAEf;gBAG+B,UAAU,EAAE,cAAc,EAAE,GAAG,IAAI,EAC9B,cAAc,EAAE,mBAAmB,GAAG,KAAK,GAAG,IAAI,EACzD,OAAO,EAAE,CAAC,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE;QAAE,IAAI,EAAE,iBAAiB,GAAG,gBAAgB,GAAG,UAAU,CAAC;QAAC,SAAS,CAAC,EAAE,cAAc,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC,GAAG,IAAI;IAU7L,OAAO,CAAC,WAAW;IASnB;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa,GAAG,MAAM,IAAI;IAuBrD,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAU5B,iCAAiC;IACjC,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAI9C;;;;;OAKG;IACG,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAiBtF,OAAO,CAAC,KAAK;YAiBC,QAAQ;IAqFtB,OAAO,CAAC,UAAU;IAOlB,OAAO,CAAC,WAAW;IAMnB,OAAO,CAAC,IAAI;IAYZ,OAAO,CAAC,WAAW;IAiBnB,OAAO,CAAC,SAAS;IAgDjB,OAAO,CAAC,eAAe;yCAhTZ,kBAAkB;6CAAlB,kBAAkB;CAqrB9B"}
+{"version":3,"file":"agent-bridge.service.d.ts","sourceRoot":"","sources":["../../../../src/lib/agent/agent-bridge.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,cAAc,EAOf,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAEjE,OAAO,KAAK,EAAE,aAAa,EAAoB,MAAM,wBAAwB,CAAC;AAE9E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAErD,OAAO,KAAK,EAGV,cAAc,EAEf,MAAM,SAAS,CAAC;;AAEjB,6DAA6D;AAC7D,eAAO,MAAM,gBAAgB,kCAAiE,CAAC;AAE/F,4EAA4E;AAC5E,eAAO,MAAM,qBAAqB,6CAEjC,CAAC;AAEF,0FAA0F;AAC1F,eAAO,MAAM,cAAc,uBACnB,OAAO,OAAO;IAAE,IAAI,EAAE,iBAAiB,GAAG,gBAAgB,GAAG,UAAU,CAAC;IAAC,SAAS,CAAC,EAAE,cAAc,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,KAAK,IAAI,CAC/G,CAAC;AAEzB,8EAA8E;AAC9E,eAAO,MAAM,YAAY,+BAA0D,CAAC;AAiCpF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBACa,kBAAkB;IAC7B,uFAAuF;IACvF,QAAQ,CAAC,WAAW,sCAAsB;IAE1C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqC;IAC3D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAmB;IAC9C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsB;IAC9C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkC;IAC3D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoB;IAC7C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAuB;IAChD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,eAAe,CAAK;IAC5B,OAAO,CAAC,0BAA0B,CAAS;IAE3C,8EAA8E;IAC9E,QAAQ,CAAC,eAAe,mDAAwB;IAEhD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAEf;gBAG+B,UAAU,EAAE,cAAc,EAAE,GAAG,IAAI,EAC9B,cAAc,EAAE,mBAAmB,GAAG,KAAK,GAAG,IAAI,EACzD,OAAO,EAAE,CAAC,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE;QAAE,IAAI,EAAE,iBAAiB,GAAG,gBAAgB,GAAG,UAAU,CAAC;QAAC,SAAS,CAAC,EAAE,cAAc,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC,GAAG,IAAI,EACzJ,QAAQ,EAAE,aAAa,GAAG,IAAI;IAWlE,OAAO,CAAC,WAAW;IASnB;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa,GAAG,MAAM,IAAI;IAuBrD,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAU5B,iCAAiC;IACjC,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAI9C;;;;;OAKG;IACG,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAiBtF,OAAO,CAAC,KAAK;YAiBC,QAAQ;IAkGtB,OAAO,CAAC,UAAU;IAOlB,OAAO,CAAC,WAAW;IAMnB,OAAO,CAAC,IAAI;IAYZ,OAAO,CAAC,WAAW;IAiBnB,OAAO,CAAC,SAAS;IAgDjB,OAAO,CAAC,eAAe;yCAhUZ,kBAAkB;6CAAlB,kBAAkB;CA20B9B"}

package/dist/esm/lib/agent/agent-bridge.service.js

@@ -8,6 +8,8 @@ export const AGENT_TRANSPORTS = new InjectionToken('AngflowAgentTransports');
 export const AGENT_HISTORY_OPTIONS = new InjectionToken('AngflowAgentHistoryOptions');
 /** Optional error sink. Receives transport/dispatch failures that the bridge swallows. */
 export const AGENT_ON_ERROR = new InjectionToken('AngflowAgentOnError');
+/** Optional host-provided layout function backing the `layout_nodes` tool. */
+export const AGENT_LAYOUT = new InjectionToken('AngflowAgentLayout');
 const ERROR_INVALID_PARAMS = -32602;
 const ERROR_METHOD_NOT_FOUND = -32601;
 const ERROR_FLOW_NOT_FOUND = -32000;
@@ -50,7 +52,7 @@ const MUTATING_TOOLS = new Set([
  * ```
  */
 export class AngflowAgentBridge {
-    constructor(transports, historyOptions, onError) {
+    constructor(transports, historyOptions, onError, layoutFn) {
         /** Schemas for every exposed tool — feed straight to a Claude / OpenAI tools array. */
         this.toolSchemas = AGENT_TOOL_SCHEMAS;
         this.flows = new Map();
@@ -65,6 +67,7 @@ export class AngflowAgentBridge {
         this.history =
             historyOptions === false ? null : new AgentHistory(historyOptions ?? undefined);
         this.onError = onError ?? null;
+        this.layoutFn = layoutFn ?? null;
         this.installHandlers();
         this.start();
     }
@@ -175,12 +178,13 @@ export class AngflowAgentBridge {
             const flow = this.resolveFlow(params['flowId']);
             const flowId = this.findFlowId(flow);
             const isApplyChanges = req.method === 'apply_changes';
+            const isLayout = req.method === 'layout_nodes';
             // Pre-mutation snapshot for history capture. Skipped for non-mutating tools.
             // Shallow-clone each element so subsequent in-place mutations (notably
             // the drag fast-path in FlowStore) can't retroactively corrupt the
             // snapshot we already captured.
             let snapshot = null;
-            if (this.history && (MUTATING_TOOLS.has(req.method) || isApplyChanges)) {
+            if (this.history && (MUTATING_TOOLS.has(req.method) || isApplyChanges || isLayout)) {
                 snapshot = {
                     nodes: flow.getNodes().map((n) => ({ ...n })),
                     edges: flow.getEdges().map((e) => ({ ...e })),
@@ -200,6 +204,15 @@ export class AngflowAgentBridge {
                         this.emitHistory(flowId);
                     }
                 }
+                else if (isLayout) {
+                    // Capture only when at least one position was applied — an empty
+                    // layout pass must not pollute the undo stack.
+                    const positions = result?.positions ?? {};
+                    if (Object.keys(positions).length > 0) {
+                        this.history.capture(flowId, snapshot);
+                        this.emitHistory(flowId);
+                    }
+                }
                 else {
                     this.history.capture(flowId, snapshot);
                     this.emitHistory(flowId);
@@ -211,6 +224,9 @@ export class AngflowAgentBridge {
             if (err instanceof FlowNotFoundError) {
                 return { id: req.id, error: { code: ERROR_FLOW_NOT_FOUND, message: err.message } };
             }
+            if (err instanceof MethodUnavailableError) {
+                return { id: req.id, error: { code: ERROR_METHOD_NOT_FOUND, message: err.message } };
+            }
             if (err instanceof InvalidParamsError) {
                 return { id: req.id, error: { code: ERROR_INVALID_PARAMS, message: err.message } };
             }
@@ -669,11 +685,129 @@ export class AngflowAgentBridge {
             this.history.clear(flowId);
             this.emitHistory(flowId);
         });
+        this.handlers.set('list_node_types', (flow) => ({ types: flow.getNodeTypeNames() }));
+        this.handlers.set('list_edge_types', (flow) => ({ types: flow.getEdgeTypeNames() }));
+        this.handlers.set('register_node_template', (flow, params) => {
+            const name = requireString(params, 'name');
+            if (name.length === 0) {
+                throw new InvalidParamsError('Param "name" must be a non-empty string.');
+            }
+            const spec = validateTemplateSpec(requireObject(params, 'spec'), 'register_node_template');
+            const claimed = flow
+                .getNodeTypeNames()
+                .find((t) => t.name === name && t.source !== 'template');
+            if (claimed) {
+                throw new InvalidParamsError(`register_node_template: "${name}" is already registered by the ` +
+                    `${claimed.source === 'builtin' ? 'library' : 'host application'} and cannot be overridden.`);
+            }
+            flow.registerNodeTemplate(name, spec);
+            return { name };
+        });
+        this.handlers.set('unregister_node_template', (flow, params) => {
+            const name = requireString(params, 'name');
+            return { removed: flow.unregisterNodeTemplate(name) };
+        });
+        this.handlers.set('list_node_templates', (flow) => ({
+            templates: flow.getNodeTemplates(),
+        }));
+        this.handlers.set('layout_nodes', async (flow, params) => {
+            if (!this.layoutFn) {
+                throw new MethodUnavailableError('layout_nodes unavailable: no layout function configured. ' +
+                    'Pass `layout` to provideAgentBridge (e.g. dagreLayout from @angflow/angular/layout).');
+            }
+            const direction = params['direction'] ?? 'TB';
+            if (typeof direction !== 'string' || !['TB', 'LR', 'BT', 'RL'].includes(direction)) {
+                throw new InvalidParamsError('Param "direction" must be one of: TB, LR, BT, RL.');
+            }
+            const nodeSep = typeof params['nodeSep'] === 'number' ? params['nodeSep'] : undefined;
+            const rankSep = typeof params['rankSep'] === 'number' ? params['rankSep'] : undefined;
+            const nodeIds = optionalStringArray(params, 'nodeIds');
+            if (nodeIds) {
+                for (const id of nodeIds) {
+                    if (!flow.getNode(id)) {
+                        throw new InvalidParamsError(`Param "nodeIds" contains unknown node id "${id}".`);
+                    }
+                }
+            }
+            const targetNodes = nodeIds
+                ? nodeIds.map((id) => flow.getNode(id))
+                : flow.getNodes();
+            const idSet = new Set(targetNodes.map((n) => n.id));
+            const layoutNodes = targetNodes.map((n) => {
+                const internal = flow.getInternalNode(n.id);
+                return {
+                    id: n.id,
+                    width: internal?.measured?.width ?? n.width ?? 150,
+                    height: internal?.measured?.height ?? n.height ?? 40,
+                    position: { x: n.position.x, y: n.position.y },
+                };
+            });
+            // Induced subgraph: only edges with BOTH endpoints in the target set.
+            const layoutEdges = flow
+                .getEdges()
+                .filter((e) => idSet.has(e.source) && idSet.has(e.target))
+                .map((e) => ({ source: e.source, target: e.target }));
+            const raw = await this.layoutFn(layoutNodes, layoutEdges, {
+                direction: direction,
+                nodeSep,
+                rankSep,
+            });
+            if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+                throw new Error('layout function must return an object map of nodeId -> {x, y}.');
+            }
+            // Validate the full result BEFORE applying anything so a bad position
+            // rolls back cleanly (nothing applied, no history entry).
+            const applied = {};
+            const unknownIds = [];
+            for (const [id, pos] of Object.entries(raw)) {
+                if (!idSet.has(id)) {
+                    unknownIds.push(id);
+                    continue;
+                }
+                if (!pos ||
+                    typeof pos.x !== 'number' ||
+                    typeof pos.y !== 'number' ||
+                    !Number.isFinite(pos.x) ||
+                    !Number.isFinite(pos.y)) {
+                    throw new Error(`layout function returned an invalid position for node "${id}"`);
+                }
+                applied[id] = { x: pos.x, y: pos.y };
+            }
+            if (unknownIds.length > 0) {
+                // eslint-disable-next-line no-console
+                console.warn(`[angflow] layout_nodes: layout function returned positions for unknown node ids ` +
+                    `(ignored): ${unknownIds.join(', ')}`);
+            }
+            // Re-check existence at apply time: the graph may have changed while the
+            // (possibly async) layout fn ran — e.g. a human deleted a node. Only
+            // nodes that still exist are moved, reported, and counted for history.
+            const actuallyApplied = {};
+            for (const [id, position] of Object.entries(applied)) {
+                if (!flow.getNode(id))
+                    continue;
+                actuallyApplied[id] = position;
+            }
+            // Honors the host's [animate] input: positions tween when it's on, and
+            // the await keeps the subsequent fitView measuring settled positions.
+            await flow.setNodePositions(actuallyApplied);
+            const shouldFit = params['fitView'] !== false;
+            if (shouldFit && Object.keys(actuallyApplied).length > 0) {
+                try {
+                    await flow.fitView({});
+                }
+                catch (err) {
+                    // Best-effort viewport fit: never fail the tool over a cosmetic step,
+                    // but surface the error to hosts observing onError.
+                    this.reportError(err, { kind: 'dispatch', method: 'layout_nodes' });
+                }
+            }
+            return { positions: actuallyApplied };
+        });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.6", ngImport: i0, type: AngflowAgentBridge, deps: [{ token: AGENT_TRANSPORTS, optional: true }, { token: AGENT_HISTORY_OPTIONS, optional: true }, { token: AGENT_ON_ERROR, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.6", ngImport: i0, type: AngflowAgentBridge, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: AngflowAgentBridge, deps: [{ token: AGENT_TRANSPORTS, optional: true }, { token: AGENT_HISTORY_OPTIONS, optional: true }, { token: AGENT_ON_ERROR, optional: true }, { token: AGENT_LAYOUT, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: AngflowAgentBridge, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.6", ngImport: i0, type: AngflowAgentBridge, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: AngflowAgentBridge, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [{ type: undefined, decorators: [{
@@ -691,11 +825,19 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.6", ngImpor
                 }, {
                     type: Inject,
                     args: [AGENT_ON_ERROR]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [AGENT_LAYOUT]
                 }] }] });
 class FlowNotFoundError extends Error {
 }
 class InvalidParamsError extends Error {
 }
+/** Tool exists in the catalog but the deployment lacks a required capability. Maps to -32601. */
+class MethodUnavailableError extends Error {
+}
 class ApplyChangesError extends Error {
     constructor(failedIndex, message) {
         super(message);
@@ -893,6 +1035,87 @@ function optionalStringArray(params, key) {
     }
     return value;
 }
+const BADGE_COLOR_SET = new Set(['slate', 'indigo', 'emerald', 'amber', 'rose']);
+const HANDLE_POSITION_SET = new Set(['top', 'right', 'bottom', 'left']);
+const KNOWN_SPEC_KEYS = new Set(['title', 'icon', 'accent', 'variant', 'badges', 'fields', 'body', 'handles']);
+/** Validate a NodeTemplateSpec payload. Throws InvalidParamsError naming the offending field. */
+function validateTemplateSpec(value, ctx) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new InvalidParamsError(`${ctx}: spec must be an object.`);
+    }
+    const s = value;
+    for (const key of Object.keys(s)) {
+        if (!KNOWN_SPEC_KEYS.has(key)) {
+            throw new InvalidParamsError(`${ctx}: unknown spec key "${key}".`);
+        }
+    }
+    for (const key of ['title', 'icon', 'accent', 'body']) {
+        if (s[key] !== undefined && typeof s[key] !== 'string') {
+            throw new InvalidParamsError(`${ctx}: spec.${key} must be a string.`);
+        }
+    }
+    if (s['variant'] !== undefined && s['variant'] !== 'compact' && s['variant'] !== 'detailed') {
+        throw new InvalidParamsError(`${ctx}: spec.variant must be "compact" or "detailed".`);
+    }
+    if (s['badges'] !== undefined) {
+        if (!Array.isArray(s['badges']))
+            throw new InvalidParamsError(`${ctx}: spec.badges must be an array.`);
+        s['badges'].forEach((raw, i) => {
+            if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+                throw new InvalidParamsError(`${ctx}: spec.badges[${i}] must be an object.`);
+            }
+            const b = raw;
+            if (typeof b['text'] !== 'string') {
+                throw new InvalidParamsError(`${ctx}: spec.badges[${i}].text must be a string.`);
+            }
+            if (b['color'] !== undefined && !BADGE_COLOR_SET.has(b['color'])) {
+                throw new InvalidParamsError(`${ctx}: spec.badges[${i}].color must be one of: ${Array.from(BADGE_COLOR_SET).join(', ')}.`);
+            }
+            if (b['showIf'] !== undefined && typeof b['showIf'] !== 'string') {
+                throw new InvalidParamsError(`${ctx}: spec.badges[${i}].showIf must be a string.`);
+            }
+        });
+    }
+    if (s['fields'] !== undefined) {
+        if (!Array.isArray(s['fields']))
+            throw new InvalidParamsError(`${ctx}: spec.fields must be an array.`);
+        s['fields'].forEach((raw, i) => {
+            if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+                throw new InvalidParamsError(`${ctx}: spec.fields[${i}] must be an object.`);
+            }
+            const f = raw;
+            if (typeof f['label'] !== 'string') {
+                throw new InvalidParamsError(`${ctx}: spec.fields[${i}].label must be a string.`);
+            }
+            if (typeof f['value'] !== 'string') {
+                throw new InvalidParamsError(`${ctx}: spec.fields[${i}].value must be a string.`);
+            }
+            if (f['showIf'] !== undefined && typeof f['showIf'] !== 'string') {
+                throw new InvalidParamsError(`${ctx}: spec.fields[${i}].showIf must be a string.`);
+            }
+        });
+    }
+    if (s['handles'] !== undefined) {
+        if (!Array.isArray(s['handles']))
+            throw new InvalidParamsError(`${ctx}: spec.handles must be an array.`);
+        s['handles'].forEach((raw, i) => {
+            if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+                throw new InvalidParamsError(`${ctx}: spec.handles[${i}] must be an object.`);
+            }
+            const h = raw;
+            if (h['type'] !== 'source' && h['type'] !== 'target') {
+                throw new InvalidParamsError(`${ctx}: spec.handles[${i}].type must be "source" or "target".`);
+            }
+            if (h['position'] !== undefined && !HANDLE_POSITION_SET.has(h['position'])) {
+                throw new InvalidParamsError(`${ctx}: spec.handles[${i}].position must be one of: top, right, bottom, left.`);
+            }
+            if (h['id'] !== undefined && typeof h['id'] !== 'string') {
+                throw new InvalidParamsError(`${ctx}: spec.handles[${i}].id must be a string.`);
+            }
+        });
+    }
+    return value;
+}
 /** Validate that `value` is a structurally valid Node payload for add_*. */
 function validateNodeShape(value, ctx) {
     if (!value || typeof value !== 'object' || Array.isArray(value)) {