@burdenoff/fluidgrids-fe-sdk 2026.1101.1 → 2026.1101.3

package/dist/{ExecutionDetailPage-4LPCNWM3.js → ExecutionDetailPage-Q77U6YJO.js}

@@ -1,19 +1,22 @@
-export { ExecutionDetailPage } from './chunk-UO5DUKYN.js';
-import './chunk-VJL3DFJT.js';
-import './chunk-JWROEOG5.js';
-import './chunk-ALFMJSD6.js';
-import './chunk-AD7BICOT.js';
+export { ExecutionDetailPage } from './chunk-HKKSXOFO.js';
+import './chunk-OSQ3OCR3.js';
+import './chunk-REO4S5MY.js';
+import './chunk-LYTR6IQO.js';
+import './chunk-H7XPXONT.js';
+import './chunk-JKBCLBHY.js';
 import './chunk-5ERAJC2I.js';
-import './chunk-NMEI7TQW.js';
+import './chunk-F7DD7BOB.js';
+import './chunk-JDLQ6QIB.js';
 import './chunk-PZ45H72P.js';
 import './chunk-Y53CVZVV.js';
 import './chunk-FNZZ5JJL.js';
-import './chunk-SEFOT2LD.js';
+import './chunk-LWLHPVIA.js';
 import './chunk-PJAWNFJV.js';
 import './chunk-7KKYIRLH.js';
-import './chunk-6ILIBJFH.js';
+import './chunk-NZJWKVER.js';
 import './chunk-ZUVFD5KV.js';
 import './chunk-JL7CASN5.js';
+import './chunk-OCJTTHTS.js';
 import './chunk-PXIFUMLA.js';
 import './chunk-6AMNEX2Y.js';
 import './chunk-G77IGC3Y.js';

package/dist/{ExecutionsListPage-HNPUKYD7.js → ExecutionsListPage-X4H4FVLN.js}

@@ -1,16 +1,17 @@
-export { ExecutionsListPage } from './chunk-76UUEMTN.js';
-import './chunk-VJL3DFJT.js';
-import './chunk-JWROEOG5.js';
+export { ExecutionsListPage } from './chunk-37VUN74D.js';
+import './chunk-REO4S5MY.js';
+import './chunk-LYTR6IQO.js';
 import './chunk-5ERAJC2I.js';
 import './chunk-PZ45H72P.js';
 import './chunk-FNZZ5JJL.js';
-import './chunk-SEFOT2LD.js';
+import './chunk-LWLHPVIA.js';
 import './chunk-PJAWNFJV.js';
 import './chunk-7KKYIRLH.js';
 import './chunk-4VJ3MDOV.js';
-import './chunk-6ILIBJFH.js';
+import './chunk-NZJWKVER.js';
 import './chunk-ZUVFD5KV.js';
 import './chunk-JL7CASN5.js';
+import './chunk-OCJTTHTS.js';
 import './chunk-PXIFUMLA.js';
 import './chunk-6AMNEX2Y.js';
 import './chunk-G77IGC3Y.js';

package/dist/{WorkflowBuilder-QFSCYCUC.js → WorkflowBuilder-RJPRUMQR.js}

@@ -1,24 +1,27 @@
-export { WorkflowBuilder } from './chunk-26NENGXA.js';
-import './chunk-77HIU3CX.js';
+export { WorkflowBuilder } from './chunk-YSXNJGCY.js';
+import './chunk-26HGYPBC.js';
 import './chunk-PIKYQE7P.js';
-import './chunk-S7XV65DB.js';
+import './chunk-DQ2ZCXYX.js';
 import './chunk-GEMNVFPK.js';
 import './chunk-B6CCE2RW.js';
 import './chunk-IEVSFCFS.js';
 import './chunk-YXMFRQYV.js';
 import './chunk-BQXVT32O.js';
-import './chunk-A47PSD7A.js';
-import './chunk-NMEI7TQW.js';
+import './chunk-MR2B67NW.js';
+import './chunk-CRDG2SQQ.js';
+import './chunk-WF6GMBR4.js';
+import './chunk-F7DD7BOB.js';
+import './chunk-JDLQ6QIB.js';
 import './chunk-PZ45H72P.js';
 import './chunk-Y53CVZVV.js';
-import './chunk-SEFOT2LD.js';
+import './chunk-LWLHPVIA.js';
 import './chunk-GLYINMOR.js';
 import './chunk-7KKYIRLH.js';
-import './chunk-YOLPHVOE.js';
 import './chunk-4VJ3MDOV.js';
-import './chunk-6ILIBJFH.js';
+import './chunk-NZJWKVER.js';
 import './chunk-ZUVFD5KV.js';
 import './chunk-JL7CASN5.js';
+import './chunk-OCJTTHTS.js';
 import './chunk-PXIFUMLA.js';
 import './chunk-6AMNEX2Y.js';
 import './chunk-G77IGC3Y.js';

package/dist/{WorkflowsList-RV4BRJO7.js → WorkflowsList-R2JJK7BL.js}

@@ -1,16 +1,17 @@
-export { WorkflowsList } from './chunk-BXR6BWXM.js';
-import './chunk-77HIU3CX.js';
-import './chunk-JWROEOG5.js';
+export { WorkflowsList } from './chunk-W7MTSATB.js';
+import './chunk-26HGYPBC.js';
+import './chunk-LYTR6IQO.js';
 import './chunk-5ERAJC2I.js';
-import './chunk-A47PSD7A.js';
+import './chunk-WF6GMBR4.js';
 import './chunk-FNZZ5JJL.js';
-import './chunk-SEFOT2LD.js';
+import './chunk-LWLHPVIA.js';
 import './chunk-PJAWNFJV.js';
 import './chunk-7KKYIRLH.js';
 import './chunk-4VJ3MDOV.js';
-import './chunk-6ILIBJFH.js';
+import './chunk-NZJWKVER.js';
 import './chunk-ZUVFD5KV.js';
 import './chunk-JL7CASN5.js';
+import './chunk-OCJTTHTS.js';
 import './chunk-PXIFUMLA.js';
 import './chunk-6AMNEX2Y.js';
 import './chunk-G77IGC3Y.js';

package/dist/agentTools-MISTH7JI.js

@@ -0,0 +1,349 @@
+import { nodeTitle, selectedOperationOf, paramsFromOperation, fixedParameterState } from './chunk-IA2ZCHNQ.js';
+import { external_exports } from './chunk-WYCB6OQL.js';
+import { computeAttachPosition, autosaveAllowedFor, isFlowComplete } from './chunk-CRDG2SQQ.js';
+import { NODE_CONFIGS, createConfiguredNode, resolveOutputHandles, resolveInputHandles, isNodeConfigsInitialized, useFlowStore, useSaveStatusStore, isNodeTypeHiddenFromPalette } from './chunk-NZJWKVER.js';
+import './chunk-ZUVFD5KV.js';
+import './chunk-JL7CASN5.js';
+import './chunk-OCJTTHTS.js';
+import './chunk-PXIFUMLA.js';
+import './chunk-6AMNEX2Y.js';
+import './chunk-G77IGC3Y.js';
+import './chunk-IHEV5HTD.js';
+import './chunk-UULVIT25.js';
+import './chunk-NTWG3CJX.js';
+import './chunk-62GWEYJ5.js';
+import { defineAgentTool, AgentToolError } from '@burdenoff/fe-libs/shared/agent-tools';
+
+var MAX_NODES_LISTED = 40;
+var MAX_EDGES_LISTED = 60;
+var MAX_TYPES_LISTED = 15;
+var POSITION_GAP_X = 400;
+var nodeId = external_exports.string().trim().min(1).max(100).describe("A node id from fg_canvas_read.");
+var SENSITIVE_PARAM = /pass(word)?|secret|token|api[-_]?key|private[-_]?key|credential|connection/i;
+function store() {
+  return useFlowStore.getState();
+}
+function findNode(id) {
+  const node = store().workflow.nodes.find((candidate) => candidate.id === id);
+  if (!node)
+    throw new AgentToolError(
+      "NOT_FOUND",
+      `No node "${id.slice(0, 40)}" on the canvas. Use fg_canvas_read.`,
+      { retryable: true }
+    );
+  return node;
+}
+var defaultCatalogueReady = () => isNodeConfigsInitialized() && NODE_CONFIGS.length > 0;
+function requireCatalogue(ready) {
+  if (!ready())
+    throw new AgentToolError(
+      "CONFLICT",
+      "The node catalogue is still loading. Try again in a few seconds.",
+      { retryable: true }
+    );
+}
+function autosaves() {
+  try {
+    const { workflow } = store();
+    return !useSaveStatusStore.getState().autosavePaused && autosaveAllowedFor(workflow) && isFlowComplete(workflow.nodes, workflow.edges);
+  } catch {
+    return false;
+  }
+}
+var SAVE_RULE = "When autosaves is true the change is saved shortly after, like the person's own edits; otherwise (a new workflow, an active version, an incomplete flow, autosave off or paused) it is kept only when the person saves.";
+function dataOf(node) {
+  return node.data && typeof node.data === "object" ? node.data : {};
+}
+function operationNames(type) {
+  const config = NODE_CONFIGS.find((candidate) => candidate.type === type);
+  return (config?.operations ?? []).filter((op) => op.name && !op.isAdapterOperation && !op.internal).map((op) => op.name);
+}
+function freePosition(nodes) {
+  if (nodes.length === 0) return { x: 0, y: 0 };
+  const rightMost = nodes.reduce(
+    (best, node) => node.position.x > best.position.x ? node : best
+  );
+  return { x: rightMost.position.x + POSITION_GAP_X, y: rightMost.position.y };
+}
+function createBuilderAgentTools(options = {}) {
+  const catalogueReady = options.catalogueReady ?? defaultCatalogueReady;
+  const durableFunctionsEnabled = options.durableFunctionsEnabled ?? (() => false);
+  const isHidden = (type) => isNodeTypeHiddenFromPalette(type, durableFunctionsEnabled());
+  const read = defineAgentTool({
+    name: "fg_canvas_read",
+    title: "Read the canvas",
+    description: "Reads the workflow open in the builder: its name, version and status, every node (id, label, type, operation, disabled) and every connection. Says whether edits autosave (drafts) or wait for the person to save.",
+    input: external_exports.strictObject({
+      offset: external_exports.number().int().min(0).max(1e4).default(0).describe("Index of the first node to list, for large workflows.")
+    }),
+    annotations: { readOnly: true, untrustedContent: true },
+    execute: ({ offset }) => {
+      const { workflow } = store();
+      const nodes = workflow.nodes;
+      const page = nodes.slice(offset, offset + MAX_NODES_LISTED);
+      return {
+        workflow: {
+          workflowKey: workflow.workflowKey,
+          name: workflow.name,
+          version: workflow.version,
+          status: workflow.status,
+          autosaves: autosaves()
+        },
+        nodeCount: nodes.length,
+        nodes: page.map((node) => {
+          const data = dataOf(node);
+          return {
+            id: node.id,
+            label: nodeTitle(node),
+            type: node.type,
+            ...typeof data.operation_name === "string" ? { operation: data.operation_name } : {},
+            ...data.disabled === true ? { disabled: true } : {}
+          };
+        }),
+        ...offset + page.length < nodes.length ? { nextOffset: offset + page.length } : {},
+        edges: workflow.edges.slice(0, MAX_EDGES_LISTED).map((edge) => ({
+          from: edge.source,
+          to: edge.target,
+          ...edge.sourceHandle && edge.sourceHandle !== "source" ? { fromHandle: edge.sourceHandle } : {},
+          ...edge.targetHandle && edge.targetHandle !== "target" ? { toHandle: edge.targetHandle } : {}
+        }))
+      };
+    }
+  });
+  const nodeTypes = defineAgentTool({
+    name: "fg_canvas_node_types",
+    title: "Find node types",
+    description: "Finds node types that can be added to the canvas (installed and built-in), by words in their name or description. Returns the type id and its operations, for fg_canvas_add_node.",
+    input: external_exports.strictObject({
+      query: external_exports.string().trim().min(1).max(80).describe('Words to look for, e.g. "gmail", "http request", "if".')
+    }),
+    annotations: { readOnly: true },
+    execute: ({ query }) => {
+      requireCatalogue(catalogueReady);
+      const words = query.toLowerCase().split(/\s+/);
+      const matches = NODE_CONFIGS.filter((config) => {
+        if (isHidden(config.type)) return false;
+        const text = `${config.type} ${config.detail.title} ${config.detail.description ?? ""}`.toLowerCase();
+        return words.every((word) => text.includes(word));
+      });
+      return {
+        total: matches.length,
+        types: matches.slice(0, MAX_TYPES_LISTED).map((config) => ({
+          nodeType: config.type,
+          title: config.detail.title,
+          operations: operationNames(config.type).slice(0, 12)
+        }))
+      };
+    }
+  });
+  const addNode = defineAgentTool({
+    name: "fg_canvas_add_node",
+    title: "Add a node",
+    description: "Adds a node to the canvas, pinned to an operation, optionally right after an existing node and connected to it. Find nodeType with fg_canvas_node_types. " + SAVE_RULE,
+    input: external_exports.strictObject({
+      nodeType: external_exports.string().trim().min(1).max(120).describe("A nodeType from fg_canvas_node_types."),
+      operation: external_exports.string().trim().min(1).max(120).optional().describe("The operation to pin. Omit for a single-operation node."),
+      afterNodeId: nodeId.optional().describe("Place the new node after this node and connect it.")
+    }),
+    execute: ({ nodeType, operation, afterNodeId }) => {
+      requireCatalogue(catalogueReady);
+      if (isHidden(nodeType) || !NODE_CONFIGS.some((config) => config.type === nodeType))
+        throw new AgentToolError(
+          "NOT_FOUND",
+          `No node type "${nodeType.slice(0, 60)}". Use fg_canvas_node_types.`,
+          { retryable: true }
+        );
+      const operations = operationNames(nodeType);
+      if (operation && !operations.includes(operation))
+        throw new AgentToolError(
+          "INVALID_INPUT",
+          `No operation "${operation.slice(0, 60)}" on ${nodeType}. Operations: ${operations.slice(0, 12).join(", ")}.`
+        );
+      if (!operation && operations.length > 1)
+        throw new AgentToolError(
+          "INVALID_INPUT",
+          `Choose an operation for ${nodeType}: ${operations.slice(0, 12).join(", ")}.`
+        );
+      const anchor = afterNodeId ? findNode(afterNodeId) : void 0;
+      const current = store().workflow.nodes;
+      const position = computeAttachPosition(anchor) ?? freePosition(current);
+      const created = createConfiguredNode(
+        nodeType,
+        position,
+        operation
+      );
+      store().actions.nodes.setNodes([
+        ...current.map(
+          (node) => node.selected ? { ...node, selected: false } : node
+        ),
+        created
+      ]);
+      if (anchor) {
+        const sourceHandle = resolveOutputHandles(dataOf(anchor), anchor.type)[0]?.id ?? "source";
+        const targetHandle = resolveInputHandles(dataOf(created))[0]?.id ?? "target";
+        store().actions.edges.onConnect({
+          source: anchor.id,
+          sourceHandle,
+          target: created.id,
+          targetHandle
+        });
+      }
+      return {
+        nodeId: created.id,
+        label: nodeTitle(created),
+        ...typeof dataOf(created).operation_name === "string" ? { operation: dataOf(created).operation_name } : {},
+        connectedFrom: anchor?.id,
+        autosaves: autosaves()
+      };
+    }
+  });
+  const connect = defineAgentTool({
+    name: "fg_canvas_connect",
+    title: "Connect two nodes",
+    description: "Connects one node's output to another node's input. For nodes with several outputs (IF, Switch) or inputs (Merge) pass the handle ids. " + SAVE_RULE,
+    input: external_exports.strictObject({
+      fromNodeId: nodeId.describe("The node the data comes from."),
+      toNodeId: nodeId.describe("The node the data goes to."),
+      fromHandle: external_exports.string().trim().min(1).max(60).optional().describe('Output handle id, e.g. "true" or "false" on an IF node.'),
+      toHandle: external_exports.string().trim().min(1).max(60).optional().describe('Input handle id, e.g. "input-2" on a Merge node.')
+    }),
+    execute: ({ fromNodeId, toNodeId, fromHandle, toHandle }) => {
+      if (fromNodeId === toNodeId)
+        throw new AgentToolError(
+          "INVALID_INPUT",
+          "A node cannot connect to itself."
+        );
+      const from = findNode(fromNodeId);
+      const to = findNode(toNodeId);
+      const outputs = resolveOutputHandles(dataOf(from), from.type).map(
+        (handle) => handle.id
+      );
+      const inputs = resolveInputHandles(dataOf(to)).map((handle) => handle.id);
+      const sourceHandle = fromHandle ?? outputs[0] ?? "source";
+      const targetHandle = toHandle ?? inputs[0] ?? "target";
+      if (outputs.length > 0 && !outputs.includes(sourceHandle))
+        throw new AgentToolError(
+          "INVALID_INPUT",
+          `No output "${sourceHandle}". Outputs: ${outputs.join(", ")}.`
+        );
+      if (inputs.length > 0 && !inputs.includes(targetHandle))
+        throw new AgentToolError(
+          "INVALID_INPUT",
+          `No input "${targetHandle}". Inputs: ${inputs.join(", ")}.`
+        );
+      const exists = store().workflow.edges.some(
+        (edge) => edge.source === from.id && edge.target === to.id && (edge.sourceHandle ?? "source") === sourceHandle && (edge.targetHandle ?? "target") === targetHandle
+      );
+      if (!exists)
+        store().actions.edges.onConnect({
+          source: from.id,
+          sourceHandle,
+          target: to.id,
+          targetHandle
+        });
+      return {
+        from: from.id,
+        to: to.id,
+        fromHandle: sourceHandle,
+        toHandle: targetHandle,
+        alreadyConnected: exists,
+        autosaves: autosaves()
+      };
+    }
+  });
+  const rename = defineAgentTool({
+    name: "fg_canvas_rename_node",
+    title: "Rename a node",
+    description: "Renames a node on the canvas. " + SAVE_RULE,
+    input: external_exports.strictObject({
+      nodeId,
+      label: external_exports.string().trim().min(1).max(80).describe("The new node name.")
+    }),
+    execute: ({ nodeId: id, label }) => {
+      findNode(id);
+      store().actions.nodes.renameNode(id, label);
+      return {
+        nodeId: id,
+        label: nodeTitle(findNode(id)),
+        autosaves: autosaves()
+      };
+    }
+  });
+  const toggle = defineAgentTool({
+    name: "fg_canvas_toggle_node",
+    title: "Enable or disable a node",
+    description: "Disables a node (runs skip it) or enables it again. " + SAVE_RULE,
+    input: external_exports.strictObject({
+      nodeId,
+      disabled: external_exports.boolean().describe("true to disable the node, false to enable it.")
+    }),
+    execute: ({ nodeId: id, disabled }) => {
+      const node = findNode(id);
+      const current = dataOf(node).disabled === true;
+      const now = current === disabled ? current : store().actions.nodes.toggleDisabled(id);
+      return { nodeId: id, disabled: now, autosaves: autosaves() };
+    }
+  });
+  const setParam = defineAgentTool({
+    name: "fg_canvas_set_param",
+    title: "Set a node parameter",
+    description: "Sets one parameter of a node's operation to a fixed value, as the node panel does. Connections and secrets are not set here; the person picks those. " + SAVE_RULE,
+    input: external_exports.strictObject({
+      nodeId,
+      field: external_exports.string().trim().min(1).max(80).describe("The parameter name; an unknown one lists the valid names."),
+      value: external_exports.string().max(4e3).describe(
+        "The value as text: numbers, true/false and JSON are converted to the parameter's type. Empty clears it."
+      )
+    }),
+    execute: ({ nodeId: id, field, value }) => {
+      const node = findNode(id);
+      const operation = selectedOperationOf(dataOf(node), node.type);
+      const params = paramsFromOperation(operation);
+      const parameter = params.find((candidate) => candidate.name === field);
+      if (!parameter)
+        throw new AgentToolError(
+          "INVALID_INPUT",
+          params.length > 0 ? `No parameter "${field.slice(0, 40)}". Parameters: ${params.slice(0, 20).map((candidate) => candidate.name).join(", ")}.` : "This node has no parameters to set (pin an operation first)."
+        );
+      const typeText = `${parameter.type} ${parameter.name}`;
+      if (SENSITIVE_PARAM.test(typeText))
+        throw new AgentToolError(
+          "NEEDS_USER",
+          "That is a credential or secret: ask the person to set it in the node panel."
+        );
+      if (parameter.options && value && !parameter.options.includes(value))
+        throw new AgentToolError(
+          "INVALID_INPUT",
+          `"${field}" must be one of: ${parameter.options.slice(0, 20).join(", ")}.`
+        );
+      const { workflow, actions } = store();
+      actions.nodes.setNodes(
+        workflow.nodes.map((candidate) => {
+          if (candidate.id !== id) return candidate;
+          const data = { ...dataOf(candidate) };
+          const args = {
+            ...data.args ?? {}
+          };
+          args.state = fixedParameterState(
+            args.state ?? {},
+            params,
+            field,
+            value
+          );
+          data.args = args;
+          return { ...candidate, data };
+        })
+      );
+      return {
+        nodeId: id,
+        field,
+        cleared: value === "",
+        autosaves: autosaves()
+      };
+    }
+  });
+  return [read, nodeTypes, addNode, connect, rename, toggle, setParam];
+}
+var BUILDER_AGENT_TOOLS = createBuilderAgentTools();
+
+export { BUILDER_AGENT_TOOLS, createBuilderAgentTools };

package/dist/{chunk-77HIU3CX.js → chunk-26HGYPBC.js}

@@ -1,4 +1,4 @@
-import { QuotaExhaustedDialog } from './chunk-A47PSD7A.js';
+import { QuotaExhaustedDialog } from './chunk-WF6GMBR4.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { jsx } from 'react/jsx-runtime';
 

package/dist/{chunk-76UUEMTN.js → chunk-37VUN74D.js}

@@ -1,8 +1,8 @@
-import { useRunStatusCounts, ExecutionStats, ExecutionFilters, ExecutionTable, ExecutionCards, ExecutionTimeline, Pagination, runStatusLabels } from './chunk-VJL3DFJT.js';
-import { useExecutionsWithStore, useExecutionStats, useExecutionActions, useAutoRefresh, WORKFLOW_ID_MAX_LENGTH } from './chunk-JWROEOG5.js';
-import { useWorkflowDefinitions } from './chunk-SEFOT2LD.js';
+import { useRunStatusCounts, ExecutionStats, ExecutionFilters, ExecutionTable, ExecutionCards, ExecutionTimeline, Pagination, runStatusLabels } from './chunk-REO4S5MY.js';
+import { useExecutionsWithStore, useExecutionStats, useExecutionActions, useAutoRefresh, WORKFLOW_ID_MAX_LENGTH } from './chunk-LYTR6IQO.js';
+import { useWorkflowDefinitions } from './chunk-LWLHPVIA.js';
 import { FluidGridsDocsLink } from './chunk-4VJ3MDOV.js';
-import { useDurableParityEnabled } from './chunk-6ILIBJFH.js';
+import { useDurableParityEnabled } from './chunk-NZJWKVER.js';
 import { useExecutionsStore } from './chunk-6AMNEX2Y.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { useRef, useCallback, useMemo, useState, useEffect } from 'react';

package/dist/{chunk-QPZCJKII.js → chunk-3ERT6FQK.js}

@@ -1,8 +1,8 @@
-import { Card, FluidGridsMark } from './chunk-S7XV65DB.js';
+import { Card, FluidGridsMark } from './chunk-DQ2ZCXYX.js';
 import { Input } from './chunk-IEVSFCFS.js';
 import { Button } from './chunk-BQXVT32O.js';
-import { useWorkflowDefinition } from './chunk-SEFOT2LD.js';
-import { FluidGridsProvider, useFlowStore } from './chunk-6ILIBJFH.js';
+import { useWorkflowDefinition } from './chunk-LWLHPVIA.js';
+import { FluidGridsProvider, useFlowStore } from './chunk-NZJWKVER.js';
 import { cn } from './chunk-JL7CASN5.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { useState, useRef, useEffect, useCallback } from 'react';