@angflow/angular 0.0.14 → 0.0.17

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

@@ -0,0 +1,935 @@
+import { Inject, Injectable, InjectionToken, Injector, Optional, effect, inject, runInInjectionContext, signal, } from '@angular/core';
+import { AgentHistory } from './history';
+import { AGENT_TOOL_SCHEMAS } from './tool-schemas';
+import * as i0 from "@angular/core";
+/** Provider token holding the user-supplied transport(s). */
+export const AGENT_TRANSPORTS = new InjectionToken('AngflowAgentTransports');
+/** Provider token for history config. `false` disables history entirely. */
+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');
+const ERROR_INVALID_PARAMS = -32602;
+const ERROR_METHOD_NOT_FOUND = -32601;
+const ERROR_FLOW_NOT_FOUND = -32000;
+const ERROR_INTERNAL = -32603;
+const MUTATING_TOOLS = new Set([
+    'add_node',
+    'add_nodes',
+    'add_edge',
+    'add_edges',
+    'update_node',
+    'update_node_data',
+    'update_edge',
+    'update_edge_data',
+    'delete_elements',
+    'set_nodes',
+    'set_edges',
+]);
+/**
+ * Routes JSON-RPC requests from one or more transports to registered
+ * `NgFlowService` instances, and pushes change events back to the agent.
+ *
+ * Provide via {@link provideAgentBridge}; register a flow by calling
+ * `register(id, ngFlowService)` from `(init)` on `<ng-flow>`.
+ *
+ * @example
+ * ```ts
+ * // appConfig.ts
+ * providers: [
+ *   provideAgentBridge({
+ *     transports: [new WindowTransport({ namespace: 'angflow' })],
+ *   }),
+ * ]
+ *
+ * // some-component.ts
+ * bridge = inject(AngflowAgentBridge);
+ *
+ * onInit(flow: NgFlowService) {
+ *   this.bridge.register('main', flow);
+ * }
+ * ```
+ */
+export class AngflowAgentBridge {
+    constructor(transports, historyOptions, onError) {
+        /** Schemas for every exposed tool — feed straight to a Claude / OpenAI tools array. */
+        this.toolSchemas = AGENT_TOOL_SCHEMAS;
+        this.flows = new Map();
+        this.handlers = new Map();
+        this.injector = inject(Injector);
+        this.started = false;
+        this.nextInProcessId = 1;
+        this.warnedOnBeforeDeleteBypass = false;
+        /** Bumped every time a flow registers/unregisters. Useful for diagnostics. */
+        this.registeredFlows = signal([], ...(ngDevMode ? [{ debugName: "registeredFlows" }] : /* istanbul ignore next */ []));
+        this.transports = transports ?? [];
+        this.history =
+            historyOptions === false ? null : new AgentHistory(historyOptions ?? undefined);
+        this.onError = onError ?? null;
+        this.installHandlers();
+        this.start();
+    }
+    reportError(err, ctx) {
+        if (!this.onError)
+            return;
+        try {
+            this.onError(err, ctx);
+        }
+        catch {
+            // An onError handler must not crash the bridge.
+        }
+    }
+    /**
+     * Register a flow under `id`. The bridge subscribes to its `nodes`,
+     * `edges`, and `viewport` signals and emits change events to all
+     * transports.
+     *
+     * Returns a disposer; if not called manually, registration leaks until
+     * the bridge itself is torn down. In Angular components, call from
+     * `(init)` on `<ng-flow>` and pair with `OnDestroy`.
+     */
+    register(id, flow) {
+        const existing = this.flows.get(id);
+        if (existing) {
+            // Idempotent re-register: same id + same service is a no-op so callers
+            // can safely call from (init) without tracking lifecycle.
+            if (existing.service === flow) {
+                return () => this.unregister(id);
+            }
+            // Different service under the same id: tear down the old watcher and
+            // drop history (the previous snapshots refer to a different graph and
+            // restoring them into this service would corrupt it).
+            existing.dispose();
+            this.history?.dropFlow(id);
+        }
+        const dispose = this.watchFlow(id, flow);
+        this.flows.set(id, { service: flow, dispose });
+        this.registeredFlows.set(Array.from(this.flows.keys()));
+        this.emit({ event: 'flow.registered', params: { flowId: id } });
+        return () => this.unregister(id);
+    }
+    unregister(id) {
+        const entry = this.flows.get(id);
+        if (!entry)
+            return;
+        entry.dispose();
+        this.flows.delete(id);
+        this.history?.dropFlow(id);
+        this.registeredFlows.set(Array.from(this.flows.keys()));
+        this.emit({ event: 'flow.unregistered', params: { flowId: id } });
+    }
+    /** Look up a registered flow. */
+    getFlow(id) {
+        return this.flows.get(id)?.service;
+    }
+    /**
+     * Invoke a tool directly without going through a transport. Behaves
+     * identically to a JSON-RPC request: captures a history snapshot, emits
+     * `flow.history` / `flow.state` events, and throws a structured error
+     * (with `code` and `data` attached) on failure.
+     */
+    async callTool(method, params = {}) {
+        const response = await this.dispatch({
+            id: `in-process:${this.nextInProcessId++}`,
+            method,
+            params,
+        });
+        if ('error' in response) {
+            const err = new Error(response.error.message);
+            err.code = response.error.code;
+            err.data = response.error.data;
+            throw err;
+        }
+        return response.result;
+    }
+    // ── Internals ────────────────────────────────────────────────────────
+    start() {
+        if (this.started)
+            return;
+        this.started = true;
+        for (const t of this.transports) {
+            try {
+                const maybePromise = t.start((req) => this.dispatch(req));
+                if (maybePromise && typeof maybePromise.then === 'function') {
+                    maybePromise.catch((err) => this.reportError(err, { kind: 'transport-start', transport: t }));
+                }
+            }
+            catch (err) {
+                this.reportError(err, { kind: 'transport-start', transport: t });
+            }
+        }
+    }
+    async dispatch(req) {
+        const handler = this.handlers.get(req.method);
+        if (!handler) {
+            return {
+                id: req.id,
+                error: { code: ERROR_METHOD_NOT_FOUND, message: `Unknown method: ${req.method}` },
+            };
+        }
+        try {
+            const params = req.params ?? {};
+            if (req.method === 'list_flows') {
+                const result = await handler(null, params);
+                return { id: req.id, result };
+            }
+            const flow = this.resolveFlow(params['flowId']);
+            const flowId = this.findFlowId(flow);
+            const isApplyChanges = req.method === 'apply_changes';
+            // 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)) {
+                snapshot = {
+                    nodes: flow.getNodes().map((n) => ({ ...n })),
+                    edges: flow.getEdges().map((e) => ({ ...e })),
+                };
+            }
+            const result = await handler(flow, params);
+            // Commit the captured snapshot to history. For apply_changes, the handler
+            // either succeeded entirely or threw and was rolled back already.
+            if (snapshot && flowId && this.history) {
+                if (isApplyChanges) {
+                    const ops = params['ops'] ?? [];
+                    const hasNonSelection = ops.some((o) => o['op'] !== 'select_nodes' &&
+                        o['op'] !== 'select_edges' &&
+                        o['op'] !== 'deselect_all');
+                    if (hasNonSelection) {
+                        this.history.capture(flowId, snapshot);
+                        this.emitHistory(flowId);
+                    }
+                }
+                else {
+                    this.history.capture(flowId, snapshot);
+                    this.emitHistory(flowId);
+                }
+            }
+            return { id: req.id, result: result ?? null };
+        }
+        catch (err) {
+            if (err instanceof FlowNotFoundError) {
+                return { id: req.id, error: { code: ERROR_FLOW_NOT_FOUND, message: err.message } };
+            }
+            if (err instanceof InvalidParamsError) {
+                return { id: req.id, error: { code: ERROR_INVALID_PARAMS, message: err.message } };
+            }
+            if (err instanceof ApplyChangesError) {
+                return {
+                    id: req.id,
+                    error: {
+                        code: ERROR_INTERNAL,
+                        message: err.message,
+                        data: { failedIndex: err.failedIndex },
+                    },
+                };
+            }
+            // Anything that lands here is an unexpected throw inside a handler — a
+            // bug or an underlying service failure. Surface it via onError so the
+            // host can log / report it; the wire response is still -32603.
+            this.reportError(err, { kind: 'dispatch', method: req.method });
+            return {
+                id: req.id,
+                error: {
+                    code: ERROR_INTERNAL,
+                    message: err instanceof Error ? err.message : String(err),
+                },
+            };
+        }
+    }
+    findFlowId(flow) {
+        for (const [id, entry] of this.flows.entries()) {
+            if (entry.service === flow)
+                return id;
+        }
+        return null;
+    }
+    emitHistory(flowId) {
+        if (!this.history)
+            return;
+        const status = this.history.status(flowId);
+        this.emit({ event: 'flow.history', params: { flowId, ...status } });
+    }
+    emit(evt) {
+        for (const t of this.transports) {
+            try {
+                t.send(evt);
+            }
+            catch (err) {
+                // Transport errors are isolated per-transport; never let one break the
+                // bridge. Forward to onError if the host wants to observe them.
+                this.reportError(err, { kind: 'transport-send', transport: t });
+            }
+        }
+    }
+    resolveFlow(rawId) {
+        if (typeof rawId === 'string' && rawId.length > 0) {
+            const entry = this.flows.get(rawId);
+            if (!entry)
+                throw new FlowNotFoundError(`No flow registered with id "${rawId}"`);
+            return entry.service;
+        }
+        if (this.flows.size === 0) {
+            throw new FlowNotFoundError('No flows are registered with the agent bridge.');
+        }
+        if (this.flows.size > 1) {
+            throw new InvalidParamsError(`Multiple flows registered (${Array.from(this.flows.keys()).join(', ')}); pass flowId to disambiguate.`);
+        }
+        return this.flows.values().next().value.service;
+    }
+    watchFlow(id, flow) {
+        let pending = false;
+        let destroyed = false;
+        let lastSignature = '';
+        const ref = runInInjectionContext(this.injector, () => effect(() => {
+            // Touch every signal we want to broadcast so the effect re-runs on change.
+            flow.nodes();
+            flow.edges();
+            flow.viewport();
+            flow.selectedNodes();
+            flow.selectedEdges();
+            if (pending)
+                return;
+            pending = true;
+            queueMicrotask(() => {
+                pending = false;
+                // A queued microtask may outlive the effect (unregister between
+                // effect run and microtask drain). Drop late emissions so we never
+                // push state for a flowId that's no longer registered.
+                if (destroyed)
+                    return;
+                // Re-read on flush so coalesced bursts see the latest state.
+                const params = {
+                    flowId: id,
+                    nodes: flow.getNodes(),
+                    edges: flow.getEdges(),
+                    viewport: flow.getViewport(),
+                    selection: {
+                        nodeIds: flow.selectedNodes().map((n) => n.id),
+                        edgeIds: flow.selectedEdges().map((e) => e.id),
+                    },
+                };
+                // Suppress duplicate emissions when controlled-mode round-trips bounce
+                // identical state through the store twice. See signatureOf for the
+                // field set; it must cover anything a mutating tool can change.
+                const sig = signatureOf(params);
+                if (sig === lastSignature)
+                    return;
+                lastSignature = sig;
+                this.emit({ event: 'flow.state', params });
+            });
+        }));
+        return () => {
+            destroyed = true;
+            ref.destroy();
+        };
+    }
+    installHandlers() {
+        this.handlers.set('list_flows', () => Array.from(this.flows.keys()));
+        this.handlers.set('get_state', (flow) => ({
+            nodes: flow.getNodes(),
+            edges: flow.getEdges(),
+            viewport: flow.getViewport(),
+        }));
+        this.handlers.set('get_nodes', (flow) => flow.getNodes());
+        this.handlers.set('get_edges', (flow) => flow.getEdges());
+        this.handlers.set('get_node', (flow, params) => {
+            const id = requireString(params, 'id');
+            return flow.getNode(id) ?? null;
+        });
+        this.handlers.set('get_edge', (flow, params) => {
+            const id = requireString(params, 'id');
+            return flow.getEdge(id) ?? null;
+        });
+        this.handlers.set('add_node', (flow, params) => {
+            const node = validateNodeShape(requireObject(params, 'node'), 'add_node');
+            flow.addNodes(node);
+            return flow.getNode(node.id) ?? null;
+        });
+        this.handlers.set('add_edge', (flow, params) => {
+            const edge = validateEdgeShape(requireObject(params, 'edge'), 'add_edge');
+            flow.addEdges(edge);
+            return flow.getEdge(edge.id) ?? null;
+        });
+        this.handlers.set('update_node', (flow, params) => {
+            const id = requireString(params, 'id');
+            const patch = requireObject(params, 'patch');
+            flow.updateNode(id, patch);
+            return flow.getNode(id) ?? null;
+        });
+        this.handlers.set('update_edge', (flow, params) => {
+            const id = requireString(params, 'id');
+            const patch = requireObject(params, 'patch');
+            flow.updateEdge(id, patch);
+            return flow.getEdge(id) ?? null;
+        });
+        this.handlers.set('delete_elements', async (flow, params) => {
+            const nodeIds = optionalStringArray(params, 'nodeIds');
+            const edgeIds = optionalStringArray(params, 'edgeIds');
+            const result = await flow.deleteElements({
+                nodes: nodeIds?.map((id) => ({ id })) ?? [],
+                edges: edgeIds?.map((id) => ({ id })) ?? [],
+            });
+            return {
+                deletedNodeIds: result.deletedNodes.map((n) => n.id),
+                deletedEdgeIds: result.deletedEdges.map((e) => e.id),
+            };
+        });
+        this.handlers.set('set_nodes', (flow, params) => {
+            const nodes = requireArray(params, 'nodes').map((n, i) => validateNodeShape(n, `set_nodes[${i}]`));
+            flow.setNodes(nodes);
+        });
+        this.handlers.set('set_edges', (flow, params) => {
+            const edges = requireArray(params, 'edges').map((e, i) => validateEdgeShape(e, `set_edges[${i}]`));
+            flow.setEdges(edges);
+        });
+        this.handlers.set('fit_view', (flow, params) => {
+            const padding = typeof params['padding'] === 'number' ? params['padding'] : undefined;
+            const duration = typeof params['duration'] === 'number' ? params['duration'] : undefined;
+            const nodeIds = optionalStringArray(params, 'nodeIds');
+            const nodes = nodeIds
+                ? nodeIds
+                    .map((id) => flow.getNode(id))
+                    .filter((n) => !!n)
+                    .map((n) => ({ id: n.id }))
+                : undefined;
+            return flow.fitView({ padding, duration, nodes });
+        });
+        this.handlers.set('set_viewport', (flow, params) => {
+            const viewport = requireObject(params, 'viewport');
+            const duration = typeof params['duration'] === 'number' ? params['duration'] : undefined;
+            flow.setViewport(viewport, { duration });
+        });
+        this.handlers.set('get_viewport', (flow) => flow.getViewport());
+        this.handlers.set('get_internal_node', (flow, params) => {
+            const id = requireString(params, 'id');
+            const internal = flow.getInternalNode(id);
+            if (!internal)
+                return null;
+            return {
+                id: internal.id,
+                positionAbsolute: internal.internals?.positionAbsolute ?? internal.position,
+                measured: internal.measured
+                    ? { width: internal.measured.width, height: internal.measured.height }
+                    : null,
+                handleBounds: internal.internals?.handleBounds ?? null,
+            };
+        });
+        this.handlers.set('get_nodes_bounds', (flow, params) => {
+            const nodeIds = optionalStringArray(params, 'nodeIds');
+            const nodes = nodeIds ? flow.getNodes(nodeIds) : flow.getNodes();
+            return flow.getNodesBounds(nodes);
+        });
+        this.handlers.set('get_intersecting_nodes', (flow, params) => {
+            const id = requireString(params, 'id');
+            const partially = typeof params['partially'] === 'boolean' ? params['partially'] : true;
+            const node = flow.getNode(id);
+            if (!node)
+                return [];
+            return flow.getIntersectingNodes(node, partially);
+        });
+        this.handlers.set('is_node_in_area', (flow, params) => {
+            const id = requireString(params, 'id');
+            const area = requireObject(params, 'area');
+            const partially = typeof params['partially'] === 'boolean' ? params['partially'] : true;
+            const node = flow.getNode(id);
+            if (!node)
+                return false;
+            return flow.isNodeIntersecting(node, area, partially);
+        });
+        this.handlers.set('get_outgoers', (flow, params) => {
+            const id = requireString(params, 'id');
+            // Use the signal-based selector then read its current value to stay non-reactive at the JSON boundary.
+            return flow.selectOutgoers(id)();
+        });
+        this.handlers.set('get_incomers', (flow, params) => {
+            const id = requireString(params, 'id');
+            return flow.selectIncomers(id)();
+        });
+        this.handlers.set('get_connected_edges', (flow, params) => {
+            const nodeIds = optionalStringArray(params, 'nodeIds');
+            if (!nodeIds)
+                throw new InvalidParamsError('Param "nodeIds" must be an array of strings.');
+            return flow.getConnectedEdges(nodeIds);
+        });
+        this.handlers.set('get_node_connections', (flow, params) => {
+            const nodeId = requireString(params, 'nodeId');
+            return flow.getNodeConnections(nodeId);
+        });
+        this.handlers.set('get_handle_connections', (flow, params) => {
+            const nodeId = requireString(params, 'nodeId');
+            const type = requireString(params, 'type');
+            if (type !== 'source' && type !== 'target') {
+                throw new InvalidParamsError('Param "type" must be "source" or "target".');
+            }
+            const handleId = typeof params['handleId'] === 'string' ? params['handleId'] : undefined;
+            return flow.getHandleConnections({ nodeId, type, id: handleId });
+        });
+        this.handlers.set('get_handle_data', (flow, params) => {
+            const nodeId = requireString(params, 'nodeId');
+            const type = requireString(params, 'type');
+            if (type !== 'source' && type !== 'target') {
+                throw new InvalidParamsError('Param "type" must be "source" or "target".');
+            }
+            const rawHandleId = params['handleId'];
+            if (rawHandleId !== null && typeof rawHandleId !== 'string') {
+                throw new InvalidParamsError('Param "handleId" must be a string or null.');
+            }
+            return flow.getHandleData(nodeId, rawHandleId, type) ?? null;
+        });
+        this.handlers.set('screen_to_flow_position', (flow, params) => {
+            const position = requireObject(params, 'position');
+            const snapToGrid = typeof params['snapToGrid'] === 'boolean' ? params['snapToGrid'] : undefined;
+            return flow.screenToFlowPosition(position, snapToGrid !== undefined ? { snapToGrid } : undefined);
+        });
+        this.handlers.set('flow_to_screen_position', (flow, params) => {
+            const position = requireObject(params, 'position');
+            return flow.flowToScreenPosition(position);
+        });
+        this.handlers.set('zoom_in', (flow, params) => {
+            const duration = typeof params['duration'] === 'number' ? params['duration'] : undefined;
+            return flow.zoomIn({ duration });
+        });
+        this.handlers.set('zoom_out', (flow, params) => {
+            const duration = typeof params['duration'] === 'number' ? params['duration'] : undefined;
+            return flow.zoomOut({ duration });
+        });
+        this.handlers.set('zoom_to', (flow, params) => {
+            const level = params['level'];
+            if (typeof level !== 'number')
+                throw new InvalidParamsError('Param "level" must be a number.');
+            const duration = typeof params['duration'] === 'number' ? params['duration'] : undefined;
+            return flow.zoomTo(level, { duration });
+        });
+        this.handlers.set('set_center', (flow, params) => {
+            const x = params['x'];
+            const y = params['y'];
+            if (typeof x !== 'number' || typeof y !== 'number') {
+                throw new InvalidParamsError('Params "x" and "y" must be numbers.');
+            }
+            const zoom = typeof params['zoom'] === 'number' ? params['zoom'] : undefined;
+            const duration = typeof params['duration'] === 'number' ? params['duration'] : undefined;
+            return flow.setCenter(x, y, { zoom, duration });
+        });
+        this.handlers.set('fit_bounds', (flow, params) => {
+            const bounds = requireObject(params, 'bounds');
+            const padding = typeof params['padding'] === 'number' ? params['padding'] : undefined;
+            const duration = typeof params['duration'] === 'number' ? params['duration'] : undefined;
+            return flow.fitBounds(bounds, { padding, duration });
+        });
+        this.handlers.set('add_nodes', (flow, params) => {
+            const nodes = requireArray(params, 'nodes').map((n, i) => validateNodeShape(n, `add_nodes[${i}]`));
+            flow.addNodes(nodes);
+            return nodes.map((n) => flow.getNode(n.id)).filter((n) => !!n);
+        });
+        this.handlers.set('add_edges', (flow, params) => {
+            const edges = requireArray(params, 'edges').map((e, i) => validateEdgeShape(e, `add_edges[${i}]`));
+            flow.addEdges(edges);
+            return edges.map((e) => flow.getEdge(e.id)).filter((e) => !!e);
+        });
+        this.handlers.set('update_node_data', (flow, params) => {
+            const id = requireString(params, 'id');
+            const dataPatch = requireObject(params, 'dataPatch');
+            flow.updateNodeData(id, dataPatch);
+            return flow.getNode(id) ?? null;
+        });
+        this.handlers.set('update_edge_data', (flow, params) => {
+            const id = requireString(params, 'id');
+            const dataPatch = requireObject(params, 'dataPatch');
+            flow.updateEdgeData(id, dataPatch);
+            return flow.getEdge(id) ?? null;
+        });
+        this.handlers.set('select_nodes', (flow, params) => {
+            const nodeIds = optionalStringArray(params, 'nodeIds');
+            if (!nodeIds)
+                throw new InvalidParamsError('Param "nodeIds" must be an array of strings.');
+            const additive = typeof params['additive'] === 'boolean' ? params['additive'] : false;
+            flow.setSelection({ nodeIds, additive });
+            return { selectedNodeIds: flow.selectedNodes().map((n) => n.id) };
+        });
+        this.handlers.set('select_edges', (flow, params) => {
+            const edgeIds = optionalStringArray(params, 'edgeIds');
+            if (!edgeIds)
+                throw new InvalidParamsError('Param "edgeIds" must be an array of strings.');
+            const additive = typeof params['additive'] === 'boolean' ? params['additive'] : false;
+            flow.setSelection({ edgeIds, additive });
+            return { selectedEdgeIds: flow.selectedEdges().map((e) => e.id) };
+        });
+        this.handlers.set('deselect_all', (flow) => {
+            flow.setSelection({ nodeIds: [], edgeIds: [], additive: false });
+        });
+        this.handlers.set('apply_changes', (flow, params) => {
+            const ops = requireArray(params, 'ops');
+            // apply_changes' delete_elements op takes the synchronous setNodes/
+            // setEdges path so the whole batch can roll back, which means
+            // onBeforeDelete is bypassed (it can't be awaited inside a rollback-
+            // capable batch). Warn once per bridge lifetime if the host actually
+            // has the veto hook registered — otherwise the silent veto-loss is
+            // very hard to discover.
+            if (!this.warnedOnBeforeDeleteBypass && flow.hasOnBeforeDeleteHook()) {
+                const hasDelete = ops.some((o) => o['op'] === 'delete_elements');
+                if (hasDelete) {
+                    this.warnedOnBeforeDeleteBypass = true;
+                    // eslint-disable-next-line no-console
+                    console.warn('[angflow] apply_changes/delete_elements bypasses onBeforeDelete. ' +
+                        'Call the standalone `delete_elements` tool if you need the veto hook.');
+                }
+            }
+            // Capture snapshot for rollback. Viewport is intentionally excluded.
+            // Shallow-clone each element so in-place field assignments (e.g.
+            // FlowStore's drag fast-path writing `node.position` / `node.dragging`)
+            // cannot corrupt the snapshot mid-batch. We do not deep-clone `data`
+            // because mutating `data` directly violates the documented contract.
+            const snapshot = {
+                nodes: flow.getNodes().map((n) => ({ ...n })),
+                edges: flow.getEdges().map((e) => ({ ...e })),
+            };
+            const results = [];
+            let failure = null;
+            flow.batch(() => {
+                for (let i = 0; i < ops.length; i++) {
+                    try {
+                        results.push({ ok: true, value: executeOp(flow, ops[i]) });
+                    }
+                    catch (err) {
+                        failure = { failedIndex: i, cause: err };
+                        break;
+                    }
+                }
+            });
+            if (failure) {
+                flow.batch(() => {
+                    flow.setNodes(snapshot.nodes);
+                    flow.setEdges(snapshot.edges);
+                });
+                const f = failure;
+                const message = f.cause instanceof Error ? f.cause.message : String(f.cause);
+                throw new ApplyChangesError(f.failedIndex, message);
+            }
+            return { results };
+        });
+        this.handlers.set('undo', (flow, params) => {
+            if (!this.history)
+                return { undone: 0, canUndo: false, canRedo: false };
+            const flowId = this.findFlowId(flow);
+            if (!flowId)
+                return { undone: 0, canUndo: false, canRedo: false };
+            const steps = typeof params['steps'] === 'number' ? params['steps'] : 1;
+            const current = {
+                nodes: flow.getNodes().map((n) => ({ ...n })),
+                edges: flow.getEdges().map((e) => ({ ...e })),
+            };
+            const result = this.history.undo(flowId, steps, current);
+            if (result) {
+                flow.batch(() => {
+                    flow.setNodes(result.snapshot.nodes);
+                    flow.setEdges(result.snapshot.edges);
+                });
+            }
+            this.emitHistory(flowId);
+            const status = this.history.status(flowId);
+            return { undone: result?.consumed ?? 0, canUndo: status.canUndo, canRedo: status.canRedo };
+        });
+        this.handlers.set('redo', (flow, params) => {
+            if (!this.history)
+                return { redone: 0, canUndo: false, canRedo: false };
+            const flowId = this.findFlowId(flow);
+            if (!flowId)
+                return { redone: 0, canUndo: false, canRedo: false };
+            const steps = typeof params['steps'] === 'number' ? params['steps'] : 1;
+            const current = {
+                nodes: flow.getNodes().map((n) => ({ ...n })),
+                edges: flow.getEdges().map((e) => ({ ...e })),
+            };
+            const result = this.history.redo(flowId, steps, current);
+            if (result) {
+                flow.batch(() => {
+                    flow.setNodes(result.snapshot.nodes);
+                    flow.setEdges(result.snapshot.edges);
+                });
+            }
+            this.emitHistory(flowId);
+            const status = this.history.status(flowId);
+            return { redone: result?.consumed ?? 0, canUndo: status.canUndo, canRedo: status.canRedo };
+        });
+        this.handlers.set('history_status', (flow) => {
+            if (!this.history)
+                return { canUndo: false, canRedo: false, pastDepth: 0, futureDepth: 0 };
+            const flowId = this.findFlowId(flow);
+            if (!flowId)
+                return { canUndo: false, canRedo: false, pastDepth: 0, futureDepth: 0 };
+            return this.history.status(flowId);
+        });
+        this.handlers.set('clear_history', (flow) => {
+            if (!this.history)
+                return;
+            const flowId = this.findFlowId(flow);
+            if (!flowId)
+                return;
+            this.history.clear(flowId);
+            this.emitHistory(flowId);
+        });
+    }
+    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' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.6", ngImport: i0, type: AngflowAgentBridge, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [AGENT_TRANSPORTS]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [AGENT_HISTORY_OPTIONS]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [AGENT_ON_ERROR]
+                }] }] });
+class FlowNotFoundError extends Error {
+}
+class InvalidParamsError extends Error {
+}
+class ApplyChangesError extends Error {
+    constructor(failedIndex, message) {
+        super(message);
+        this.failedIndex = failedIndex;
+    }
+}
+/**
+ * Build a stable signature of the emit payload, used to suppress duplicate
+ * emissions when controlled-mode round-trips bounce identical state through
+ * the store twice. Must hash every field that can change via a mutating
+ * tool — including `data`, `style`, `type`, `hidden`, `animated`, `label` —
+ * otherwise `update_node_data` / `update_edge_data` updates would be silently
+ * dropped.
+ */
+function signatureOf(params) {
+    // Curated subset of node/edge fields that surface in `flow.state` consumers
+    // (renderers, history, agents). Order is fixed by the literal so JSON.stringify
+    // produces a deterministic string.
+    const n = params.nodes.map((node) => ({
+        id: node.id,
+        p: [node.position.x, node.position.y],
+        m: node.measured ? [node.measured.width ?? null, node.measured.height ?? null] : null,
+        t: node.type ?? null,
+        h: node.hidden === true,
+        d: node.data ?? null,
+        s: node.style ?? null,
+    }));
+    const e = params.edges.map((edge) => ({
+        id: edge.id,
+        src: edge.source,
+        tgt: edge.target,
+        sh: edge.sourceHandle ?? null,
+        th: edge.targetHandle ?? null,
+        t: edge.type ?? null,
+        h: edge.hidden === true,
+        a: edge.animated === true,
+        l: edge.label ?? null,
+        d: edge.data ?? null,
+        s: edge.style ?? null,
+    }));
+    try {
+        return JSON.stringify({ n, e, v: params.viewport, sel: params.selection });
+    }
+    catch {
+        // Defensive: if any field is non-serializable (e.g. cyclic data), fall back
+        // to a coarser signature so dedup never silently swallows updates.
+        return `__nonserializable__:${Date.now()}:${Math.random()}`;
+    }
+}
+function executeOp(flow, op) {
+    const kind = op['op'];
+    switch (kind) {
+        case 'add_node': {
+            const node = validateNodeShape(op['node'], 'apply_changes/add_node');
+            flow.addNodes(node);
+            return flow.getNode(node.id) ?? null;
+        }
+        case 'add_nodes': {
+            const nodes = op['nodes'];
+            if (!Array.isArray(nodes))
+                throw new InvalidParamsError('add_nodes: "nodes" must be an array.');
+            const validated = nodes.map((n, i) => validateNodeShape(n, `apply_changes/add_nodes[${i}]`));
+            flow.addNodes(validated);
+            return validated.map((n) => flow.getNode(n.id)).filter((n) => !!n);
+        }
+        case 'add_edge': {
+            const edge = validateEdgeShape(op['edge'], 'apply_changes/add_edge');
+            flow.addEdges(edge);
+            return flow.getEdge(edge.id) ?? null;
+        }
+        case 'add_edges': {
+            const edges = op['edges'];
+            if (!Array.isArray(edges))
+                throw new InvalidParamsError('add_edges: "edges" must be an array.');
+            const validated = edges.map((e, i) => validateEdgeShape(e, `apply_changes/add_edges[${i}]`));
+            flow.addEdges(validated);
+            return validated.map((e) => flow.getEdge(e.id)).filter((e) => !!e);
+        }
+        case 'update_node': {
+            const id = op['id'];
+            const patch = op['patch'];
+            if (typeof id !== 'string')
+                throw new InvalidParamsError('update_node: "id" must be a string.');
+            if (!patch || typeof patch !== 'object')
+                throw new InvalidParamsError('update_node: "patch" must be an object.');
+            if (!flow.getNode(id))
+                throw new InvalidParamsError(`update_node: node "${id}" not found.`);
+            flow.updateNode(id, patch);
+            return flow.getNode(id) ?? null;
+        }
+        case 'update_node_data': {
+            const id = op['id'];
+            const dataPatch = op['dataPatch'];
+            if (typeof id !== 'string')
+                throw new InvalidParamsError('update_node_data: "id" must be a string.');
+            if (!dataPatch || typeof dataPatch !== 'object')
+                throw new InvalidParamsError('update_node_data: "dataPatch" must be an object.');
+            if (!flow.getNode(id))
+                throw new InvalidParamsError(`update_node_data: node "${id}" not found.`);
+            flow.updateNodeData(id, dataPatch);
+            return flow.getNode(id) ?? null;
+        }
+        case 'update_edge': {
+            const id = op['id'];
+            const patch = op['patch'];
+            if (typeof id !== 'string')
+                throw new InvalidParamsError('update_edge: "id" must be a string.');
+            if (!patch || typeof patch !== 'object')
+                throw new InvalidParamsError('update_edge: "patch" must be an object.');
+            if (!flow.getEdge(id))
+                throw new InvalidParamsError(`update_edge: edge "${id}" not found.`);
+            flow.updateEdge(id, patch);
+            return flow.getEdge(id) ?? null;
+        }
+        case 'update_edge_data': {
+            const id = op['id'];
+            const dataPatch = op['dataPatch'];
+            if (typeof id !== 'string')
+                throw new InvalidParamsError('update_edge_data: "id" must be a string.');
+            if (!dataPatch || typeof dataPatch !== 'object')
+                throw new InvalidParamsError('update_edge_data: "dataPatch" must be an object.');
+            if (!flow.getEdge(id))
+                throw new InvalidParamsError(`update_edge_data: edge "${id}" not found.`);
+            flow.updateEdgeData(id, dataPatch);
+            return flow.getEdge(id) ?? null;
+        }
+        case 'delete_elements': {
+            const nodeIds = Array.isArray(op['nodeIds']) ? op['nodeIds'] : [];
+            const edgeIds = Array.isArray(op['edgeIds']) ? op['edgeIds'] : [];
+            // deleteElements is async because of onBeforeDelete; inside apply_changes we
+            // intentionally do not await — the synchronous setNodes/setEdges paths are
+            // what we need for rollback semantics. Skip onBeforeDelete hooks inside batches.
+            const allEdgeIds = new Set(edgeIds);
+            for (const e of flow.getEdges()) {
+                if (nodeIds.includes(e.source) || nodeIds.includes(e.target))
+                    allEdgeIds.add(e.id);
+            }
+            if (nodeIds.length > 0) {
+                flow.setNodes(flow.getNodes().filter((n) => !nodeIds.includes(n.id)));
+            }
+            if (allEdgeIds.size > 0) {
+                flow.setEdges(flow.getEdges().filter((e) => !allEdgeIds.has(e.id)));
+            }
+            return { deletedNodeIds: nodeIds, deletedEdgeIds: Array.from(allEdgeIds) };
+        }
+        case 'select_nodes': {
+            const nodeIds = op['nodeIds'];
+            if (!Array.isArray(nodeIds))
+                throw new InvalidParamsError('select_nodes: "nodeIds" must be an array.');
+            const additive = typeof op['additive'] === 'boolean' ? op['additive'] : false;
+            flow.setSelection({ nodeIds: nodeIds, additive });
+            return null;
+        }
+        case 'select_edges': {
+            const edgeIds = op['edgeIds'];
+            if (!Array.isArray(edgeIds))
+                throw new InvalidParamsError('select_edges: "edgeIds" must be an array.');
+            const additive = typeof op['additive'] === 'boolean' ? op['additive'] : false;
+            flow.setSelection({ edgeIds: edgeIds, additive });
+            return null;
+        }
+        case 'deselect_all': {
+            flow.setSelection({ nodeIds: [], edgeIds: [], additive: false });
+            return null;
+        }
+        default:
+            throw new InvalidParamsError(`Unknown op kind: ${String(kind)}`);
+    }
+}
+function requireString(params, key) {
+    const value = params[key];
+    if (typeof value !== 'string')
+        throw new InvalidParamsError(`Param "${key}" must be a string.`);
+    return value;
+}
+function requireObject(params, key) {
+    const value = params[key];
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new InvalidParamsError(`Param "${key}" must be an object.`);
+    }
+    return value;
+}
+function requireArray(params, key) {
+    const value = params[key];
+    if (!Array.isArray(value))
+        throw new InvalidParamsError(`Param "${key}" must be an array.`);
+    return value;
+}
+function optionalStringArray(params, key) {
+    const value = params[key];
+    if (value == null)
+        return undefined;
+    if (!Array.isArray(value) || value.some((v) => typeof v !== 'string')) {
+        throw new InvalidParamsError(`Param "${key}" must be an array of strings.`);
+    }
+    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)) {
+        throw new InvalidParamsError(`${ctx}: node must be an object.`);
+    }
+    const n = value;
+    if (typeof n['id'] !== 'string' || n['id'].length === 0) {
+        throw new InvalidParamsError(`${ctx}: node.id must be a non-empty string.`);
+    }
+    const pos = n['position'];
+    if (!pos || typeof pos !== 'object' || Array.isArray(pos)) {
+        throw new InvalidParamsError(`${ctx}: node.position must be { x, y }.`);
+    }
+    const p = pos;
+    if (typeof p['x'] !== 'number' || typeof p['y'] !== 'number') {
+        throw new InvalidParamsError(`${ctx}: node.position.{x,y} must be numbers.`);
+    }
+    if (!Number.isFinite(p['x']) || !Number.isFinite(p['y'])) {
+        throw new InvalidParamsError(`${ctx}: node.position.{x,y} must be finite (no NaN/Infinity).`);
+    }
+    return value;
+}
+/** Validate that `value` is a structurally valid Edge payload for add_*. */
+function validateEdgeShape(value, ctx) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new InvalidParamsError(`${ctx}: edge must be an object.`);
+    }
+    const e = value;
+    if (typeof e['id'] !== 'string' || e['id'].length === 0) {
+        throw new InvalidParamsError(`${ctx}: edge.id must be a non-empty string.`);
+    }
+    if (typeof e['source'] !== 'string' || e['source'].length === 0) {
+        throw new InvalidParamsError(`${ctx}: edge.source must be a non-empty string.`);
+    }
+    if (typeof e['target'] !== 'string' || e['target'].length === 0) {
+        throw new InvalidParamsError(`${ctx}: edge.target must be a non-empty string.`);
+    }
+    return value;
+}
+//# sourceMappingURL=agent-bridge.service.js.map