@burdenoff/fluidgrids-fe-sdk 2026.1028.6 → 2026.1028.8

package/dist/{chunk-XZPXIOGE.js → chunk-GGINSR75.js}

@@ -1,18 +1,23 @@
-import { ActionPoliciesTab } from './chunk-FDEZGRRL.js';
-import { useFluidGridsFlag, FLUIDGRIDS_FLAGS, LogStreamingTab } from './chunk-I2ZNBBRK.js';
+import { ActionPoliciesTab } from './chunk-GQQV2L74.js';
+import { LogStreamingTab } from './chunk-VFPIMW52.js';
+import { AgentsTab } from './chunk-TX6WIT3N.js';
 import { FluidGridsDocsLink } from './chunk-4VJ3MDOV.js';
-import { useFlowStore, useSaveStatusStore, useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS, throwIfResultError } from './chunk-C4AY6JI2.js';
-import { useWorkflowDefinitionQuery, useUpdateWorkflowDefinitionMutation, useWorkflowDefinitionsQuery } from './chunk-6J4RR46J.js';
+import { useFluidGridsFlag, FLUIDGRIDS_FLAGS } from './chunk-77NA7TPJ.js';
+import { useFlowStore, useSaveStatusStore, useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS, throwIfResultError, describeOperationError, useConnections } from './chunk-NVUJFHTQ.js';
+import { getGlobalStoreClient } from './chunk-PXIFUMLA.js';
+import { getFluidGridsConfig } from './chunk-CY6KX4RG.js';
+import { useWorkflowDefinitionQuery, useUpdateWorkflowDefinitionMutation, useWorkflowDefinitionsQuery } from './chunk-7PBOU7JC.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
 import { useState, useMemo, useEffect, useCallback } from 'react';
 import { useNavigate, useParams } from 'react-router';
 import { Icon } from '@iconify/react';
 import { Button } from '@burdenoff/fe-libs/button';
-import { Tabs, TabsList, TabsTrigger, TabsContent, Input, Switch, Select, SelectTrigger, SelectValue, SelectContent, SelectItem, Card, CardHeader, Label, TooltipProvider, Tooltip, TooltipTrigger, TooltipContent } from '@burdenoff/fe-libs/ui';
+import { Tabs, TabsList, TabsTrigger, TabsContent, Input, Switch, Select, SelectTrigger, SelectValue, SelectContent, SelectItem, Label, Card, CardHeader, Badge, Checkbox, TooltipProvider, Tooltip, TooltipTrigger, TooltipContent } from '@burdenoff/fe-libs/ui';
 import { toast } from 'sonner';
 import { jsxs, jsx } from 'react/jsx-runtime';
 import { gql } from '@apollo/client';
+import { cn } from '@burdenoff/fe-libs/utils';
 
 function SettingRow({
   label,
@@ -94,6 +99,29 @@ function fromSavingChoice(choice) {
   if (choice === "skip") return false;
   return void 0;
 }
+var MAX_REDACT_FIELDS = 50;
+var MAX_REDACT_FIELD_LENGTH = 200;
+var MAX_REDACT_PATH_SEGMENTS = 16;
+function parseRedactFields(text) {
+  const seen = /* @__PURE__ */ new Set();
+  const fields = [];
+  for (const raw of text.split(/[,\n]/)) {
+    const segments = raw.trim().split(".").map((segment) => segment.trim());
+    const field = segments.join(".");
+    if (field.length === 0 || field.length > MAX_REDACT_FIELD_LENGTH || segments.length > MAX_REDACT_PATH_SEGMENTS || segments.some((segment) => segment.length === 0)) {
+      continue;
+    }
+    const key = field.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    fields.push(field);
+    if (fields.length >= MAX_REDACT_FIELDS) break;
+  }
+  return fields.length > 0 ? fields : void 0;
+}
+function formatRedactFields(fields) {
+  return (fields ?? []).join(", ");
+}
 function compactOverrides(value) {
   if (!value) return void 0;
   const entries = Object.entries(value).filter(([, v]) => v !== void 0);
@@ -370,6 +398,1261 @@ function parseOptionalPositiveInt(value) {
   return Number.isFinite(parsed) ? Math.max(1, Math.trunc(parsed)) : void 0;
 }
 
+// src/modules/mcp-gateway/utils/mcp-form.ts
+var MCP_TOOL_NAME = /^[a-z][a-z0-9_-]{0,63}$/;
+var MCP_TOKEN_DEFAULT_DAYS = 90;
+var MCP_TOKEN_MAX_DAYS = 365;
+var McpFormError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "McpFormError";
+  }
+};
+function assertToolName(raw) {
+  const name = raw.trim();
+  if (!MCP_TOOL_NAME.test(name)) {
+    throw new McpFormError(
+      "Use lowercase letters, digits, _ and - (starting with a letter, 64 characters at most)."
+    );
+  }
+  return name;
+}
+function emptyTokenForm() {
+  return {
+    name: "",
+    allTools: false,
+    tools: [],
+    pinVersion: null,
+    expiresInDays: MCP_TOKEN_DEFAULT_DAYS
+  };
+}
+function tokenScopes(form) {
+  const scopes = form.allTools ? ["mcp:*"] : [...new Set(form.tools)].map((tool) => `mcp:tool:${tool}`);
+  if (form.pinVersion !== null) scopes.push(`mcp:toolset:${form.pinVersion}`);
+  return scopes;
+}
+function validateTokenForm(form, now = /* @__PURE__ */ new Date()) {
+  const name = form.name.trim();
+  if (!name) throw new McpFormError("Give the token a name.");
+  if (!form.allTools && form.tools.length === 0) {
+    throw new McpFormError("Choose the tools the token may call.");
+  }
+  const days = Math.trunc(form.expiresInDays);
+  if (!Number.isFinite(days) || days < 1 || days > MCP_TOKEN_MAX_DAYS) {
+    throw new McpFormError(
+      `A token lasts between 1 and ${MCP_TOKEN_MAX_DAYS} days.`
+    );
+  }
+  for (const tool of form.tools) assertToolName(tool);
+  return {
+    name,
+    scopes: tokenScopes(form),
+    expiresAt: new Date(now.getTime() + days * 864e5).toISOString()
+  };
+}
+function isMcpKey(key) {
+  return key.scopes.some((scope) => scope.startsWith("mcp:"));
+}
+function describeScopes(scopes) {
+  const mcp = scopes.filter((scope) => scope.startsWith("mcp:"));
+  if (mcp.length === 0) return "No MCP access";
+  const parts = [];
+  if (mcp.includes("mcp:*")) parts.push("All tools");
+  const tools = mcp.filter((scope) => scope.startsWith("mcp:tool:")).map((scope) => scope.slice("mcp:tool:".length));
+  if (tools.length > 0) parts.push(tools.join(", "));
+  const versions = mcp.filter((scope) => scope.startsWith("mcp:toolset:")).map((scope) => `v${scope.slice("mcp:toolset:".length)}`);
+  if (versions.length > 0) parts.push(`pinned to ${versions.join(", ")}`);
+  return parts.join(" \xB7 ");
+}
+function endpointUrl(gatewayUrl, path) {
+  const base = gatewayUrl.replace(/\/workspaces\/graphql\/?$/, "");
+  return `${base.replace(/\/+$/, "")}${path}`;
+}
+function callTone(status) {
+  switch (status) {
+    case "SUCCEEDED":
+      return "success";
+    case "RUNNING":
+    case "PENDING_APPROVAL":
+      return "warning";
+    case "FAILED":
+    case "DENIED":
+      return "danger";
+    default:
+      return "neutral";
+  }
+}
+function canDecide(call, now = /* @__PURE__ */ new Date()) {
+  if (call.approvalStatus !== "PENDING") return false;
+  return !call.approvalExpiresAt || new Date(call.approvalExpiresAt).getTime() > now.getTime();
+}
+
+// src/modules/mcp-gateway/hooks/useMcpGateway.ts
+var TOOL_FIELDS = `
+  id
+  toolName
+  kind
+  description
+  workflowKey
+  nodeType
+  nodeVersion
+  operation
+  connectionId
+  adapter
+  readOnly
+  allowWrite
+  enabled
+  updatedAt
+`;
+var TOOL_SET_FIELDS = `
+  id
+  version
+  status
+  note
+  publishedAt
+  tools { name kind description readOnly workflowKey nodeType operation }
+`;
+var CALL_FIELDS = `
+  id
+  toolSetVersion
+  toolName
+  toolKind
+  actorId
+  decision
+  decisionReason
+  policyName
+  status
+  runId
+  latencyMs
+  errorCode
+  errorMessage
+  approvalStatus
+  approvalExpiresAt
+  argsSha256
+  createdAt
+`;
+var OVERVIEW = gql`
+  query McpGatewayOverview {
+    mcpEndpoint { path productKey workspaceId latestVersion }
+    mcpExposedTools { ${TOOL_FIELDS} }
+    mcpToolSets { ${TOOL_SET_FIELDS} }
+  }
+`;
+var CALLS = gql`
+  query McpToolCalls($first: Int, $after: String, $filter: McpToolCallFilter) {
+    mcpToolCalls(first: $first, after: $after, filter: $filter) {
+      items { ${CALL_FIELDS} }
+      nextCursor
+      hasMore
+    }
+  }
+`;
+var EXPOSE_WORKFLOW = gql`
+  mutation ExposeWorkflowAsMcpTool($input: ExposeWorkflowAsMcpToolInput!) {
+    exposeWorkflowAsMcpTool(input: $input) { ${TOOL_FIELDS} }
+  }
+`;
+var EXPOSE_CONNECTOR = gql`
+  mutation ExposeConnectorOperationAsMcpTool($input: ExposeConnectorOperationAsMcpToolInput!) {
+    exposeConnectorOperationAsMcpTool(input: $input) { ${TOOL_FIELDS} }
+  }
+`;
+var SET_ENABLED = gql`
+  mutation SetMcpToolEnabled($id: ID!, $enabled: Boolean!) {
+    setMcpToolEnabled(id: $id, enabled: $enabled) {
+      id
+      enabled
+    }
+  }
+`;
+var REMOVE_TOOL = gql`
+  mutation RemoveMcpTool($id: ID!) {
+    removeMcpTool(id: $id)
+  }
+`;
+var PUBLISH = gql`
+  mutation PublishMcpToolSet($note: String) {
+    publishMcpToolSet(note: $note) {
+      created
+      toolSet { ${TOOL_SET_FIELDS} }
+      skipped { toolName reason }
+    }
+  }
+`;
+var DEPRECATE = gql`
+  mutation DeprecateMcpToolSet($version: Int!) {
+    deprecateMcpToolSet(version: $version) {
+      id
+      status
+    }
+  }
+`;
+var DECIDE = gql`
+  mutation DecideMcpToolCallApproval($id: ID!, $approve: Boolean!) {
+    decideMcpToolCallApproval(id: $id, approve: $approve) {
+      id
+      approvalStatus
+    }
+  }
+`;
+var MY_API_KEYS = gql`
+  query McpApiKeys($pagination: PaginationInput) {
+    myApiKeys(pagination: $pagination) {
+      apiKeys {
+        id
+        name
+        prefix
+        appId
+        appName
+        scopes
+        expiresAt
+        lastUsedAt
+        createdAt
+      }
+    }
+  }
+`;
+var CREATE_APP = gql`
+  mutation CreateMcpClientApp($input: CreateAppInput!) {
+    createApp(input: $input) {
+      app {
+        id
+      }
+    }
+  }
+`;
+var GRANT_WORKSPACE = gql`
+  mutation GrantMcpClientWorkspace($input: GrantAppWorkspaceAccessInput!) {
+    grantAppWorkspaceAccess(input: $input) {
+      id
+      status
+    }
+  }
+`;
+var GENERATE_KEY = gql`
+  mutation GenerateMcpApiKey($input: GenerateAPIKeyInput!) {
+    generateAPIKey(input: $input) {
+      apiKey
+      apiSecret
+      keyId
+    }
+  }
+`;
+var REVOKE_KEY = gql`
+  mutation RevokeMcpApiKey($keyId: String!) {
+    revokeAPIKey(keyId: $keyId)
+  }
+`;
+function globalClient() {
+  const client = getGlobalStoreClient();
+  if (!client) {
+    throw new McpFormError("Token management is not available in this app.");
+  }
+  return client;
+}
+function useMcpGateway() {
+  const [endpoint, setEndpoint] = useState(null);
+  const [tools, setTools] = useState([]);
+  const [toolSets, setToolSets] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const reload = useCallback(async () => {
+    setLoading(true);
+    try {
+      const result = await getFluidGridsClient().query({ query: OVERVIEW, fetchPolicy: "network-only" });
+      throwIfResultError(result);
+      setEndpoint(result.data?.mcpEndpoint ?? null);
+      setTools(result.data?.mcpExposedTools ?? []);
+      setToolSets(result.data?.mcpToolSets ?? []);
+      setError(null);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  useEffect(() => {
+    void reload();
+  }, [reload]);
+  const mutateAndReload = useCallback(
+    async (mutation, variables) => {
+      const result = await getFluidGridsClient().mutate({
+        mutation,
+        variables
+      });
+      throwIfResultError(result);
+      await reload();
+      return result.data;
+    },
+    [reload]
+  );
+  const exposeWorkflow = useCallback(
+    (input) => mutateAndReload(EXPOSE_WORKFLOW, { input }),
+    [mutateAndReload]
+  );
+  const exposeConnector = useCallback(
+    (input) => mutateAndReload(EXPOSE_CONNECTOR, { input }),
+    [mutateAndReload]
+  );
+  const setEnabled = useCallback(
+    (id, enabled) => mutateAndReload(SET_ENABLED, { id, enabled }),
+    [mutateAndReload]
+  );
+  const removeTool = useCallback(
+    (id) => mutateAndReload(REMOVE_TOOL, { id }),
+    [mutateAndReload]
+  );
+  const publish = useCallback(
+    async (note) => {
+      const data = await mutateAndReload(PUBLISH, { note: note || null });
+      if (!data?.publishMcpToolSet)
+        throw new McpFormError("Publishing returned nothing.");
+      return data.publishMcpToolSet;
+    },
+    [mutateAndReload]
+  );
+  const deprecate = useCallback(
+    (version) => mutateAndReload(DEPRECATE, { version }),
+    [mutateAndReload]
+  );
+  return {
+    endpoint,
+    tools,
+    toolSets,
+    loading,
+    error,
+    reload,
+    exposeWorkflow,
+    exposeConnector,
+    setEnabled,
+    removeTool,
+    publish,
+    deprecate
+  };
+}
+function useMcpToolCalls(pageSize = 25) {
+  const [calls, setCalls] = useState([]);
+  const [cursor, setCursor] = useState(null);
+  const [hasMore, setHasMore] = useState(false);
+  const [loading, setLoading] = useState(true);
+  const [statusFilter, setStatusFilter] = useState(null);
+  const fetchPage = useCallback(
+    async (after) => {
+      const result = await getFluidGridsClient().query({
+        query: CALLS,
+        variables: {
+          first: pageSize,
+          after,
+          filter: statusFilter ? { status: statusFilter } : null
+        },
+        fetchPolicy: "network-only"
+      });
+      throwIfResultError(result);
+      return result.data?.mcpToolCalls ?? {
+        items: [],
+        nextCursor: null,
+        hasMore: false
+      };
+    },
+    [pageSize, statusFilter]
+  );
+  const reload = useCallback(async () => {
+    setLoading(true);
+    try {
+      const page = await fetchPage(null);
+      setCalls(page.items);
+      setCursor(page.nextCursor);
+      setHasMore(page.hasMore);
+    } finally {
+      setLoading(false);
+    }
+  }, [fetchPage]);
+  const loadMore = useCallback(async () => {
+    if (!cursor) return;
+    const page = await fetchPage(cursor);
+    setCalls((current) => [...current, ...page.items]);
+    setCursor(page.nextCursor);
+    setHasMore(page.hasMore);
+  }, [cursor, fetchPage]);
+  useEffect(() => {
+    void reload().catch(() => void 0);
+  }, [reload]);
+  const decide = useCallback(
+    async (id, approve) => {
+      const result = await getFluidGridsClient().mutate({
+        mutation: DECIDE,
+        variables: { id, approve }
+      });
+      throwIfResultError(result);
+      await reload();
+    },
+    [reload]
+  );
+  return {
+    calls,
+    hasMore,
+    loading,
+    statusFilter,
+    setStatusFilter,
+    reload,
+    loadMore,
+    decide
+  };
+}
+function useMcpTokens() {
+  const [keys, setKeys] = useState([]);
+  const [available, setAvailable] = useState(true);
+  const [loading, setLoading] = useState(true);
+  const reload = useCallback(async () => {
+    const client = getGlobalStoreClient();
+    if (!client) {
+      setAvailable(false);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    try {
+      const result = await client.query({
+        query: MY_API_KEYS,
+        variables: { pagination: { limit: 100, offset: 0 } },
+        fetchPolicy: "network-only"
+      });
+      throwIfResultError(result);
+      setKeys((result.data?.myApiKeys.apiKeys ?? []).filter(isMcpKey));
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  useEffect(() => {
+    void reload().catch(() => void 0);
+  }, [reload]);
+  const create = useCallback(
+    async (input) => {
+      const client = globalClient();
+      const { workspaceId, tenantId } = getFluidGridsConfig();
+      if (!workspaceId || !tenantId) {
+        throw new McpFormError(
+          "The workspace context is not ready yet. Try again shortly."
+        );
+      }
+      const app = await client.mutate({
+        mutation: CREATE_APP,
+        variables: {
+          input: {
+            name: `MCP: ${input.name}`.slice(0, 120),
+            description: "MCP client created in FluidGrids Settings \u2192 MCP",
+            type: "API_INTEGRATION",
+            scopes: input.scopes
+          }
+        }
+      });
+      throwIfResultError(app);
+      const appId = app.data?.createApp.app.id;
+      if (!appId)
+        throw new McpFormError("The MCP client could not be created.");
+      throwIfResultError(
+        await client.mutate({
+          mutation: GRANT_WORKSPACE,
+          variables: { input: { appId, workspaceId, tenantId } }
+        })
+      );
+      const key = await client.mutate({
+        mutation: GENERATE_KEY,
+        variables: {
+          input: {
+            appId,
+            name: input.name,
+            scope: input.scopes,
+            expiresAt: input.expiresAt
+          }
+        }
+      });
+      throwIfResultError(key);
+      if (!key.data?.generateAPIKey)
+        throw new McpFormError("The API key could not be created.");
+      await reload();
+      return key.data.generateAPIKey;
+    },
+    [reload]
+  );
+  const revoke = useCallback(
+    async (keyId) => {
+      throwIfResultError(
+        await globalClient().mutate({
+          mutation: REVOKE_KEY,
+          variables: { keyId }
+        })
+      );
+      await reload();
+    },
+    [reload]
+  );
+  return { keys, available, loading, reload, create, revoke };
+}
+var FIELD = "rounded-md border border-border-secondary bg-background-secondary px-2 py-1.5 text-sm text-text-primary";
+var CARD = "rounded-lg border border-border-secondary bg-background-primary p-4 space-y-3";
+var TONE_CLASSES = {
+  success: "bg-status-success-bg-subtle text-status-success-text border-status-success-border",
+  warning: "bg-status-warning-bg-subtle text-status-warning-text border-status-warning-border",
+  danger: "bg-status-error-bg-subtle text-status-error-text border-status-error-border",
+  neutral: "bg-background-secondary text-text-secondary border-border-secondary"
+};
+function errorMessage(err) {
+  return err instanceof McpFormError ? err.message : describeOperationError(err);
+}
+function ToneBadge({
+  tone,
+  children
+}) {
+  return /* @__PURE__ */ jsx(Badge, { variant: "outline", className: cn("text-xs", TONE_CLASSES[tone]), children });
+}
+async function copy(value, done, failed = "Copy failed") {
+  try {
+    await navigator.clipboard.writeText(value);
+    toast.success(done);
+  } catch {
+    toast.error(failed);
+  }
+}
+async function attempt(action, success) {
+  try {
+    await action();
+    if (success) toast.success(success);
+    return true;
+  } catch (err) {
+    toast.error(errorMessage(err));
+    return false;
+  }
+}
+function ConnectorToolForm({
+  onSave
+}) {
+  const tr = useTr();
+  const { connections } = useConnections();
+  const [toolName, setToolName] = useState("");
+  const [nodeType, setNodeType] = useState("");
+  const [operation, setOperation] = useState("");
+  const [connectionId, setConnectionId] = useState("");
+  const [description, setDescription] = useState("");
+  const [allowWrite, setAllowWrite] = useState(false);
+  const [busy, setBusy] = useState(false);
+  const connection = connections.find((entry) => entry.id === connectionId);
+  const submit = async () => {
+    setBusy(true);
+    try {
+      const saved = await onSave({
+        toolName: assertToolName(toolName),
+        nodeType: nodeType.trim(),
+        operation: operation.trim(),
+        connectionId,
+        adapter: connection?.provider.key ?? connection?.providerId ?? "",
+        description: description.trim() || void 0,
+        allowWrite
+      });
+      if (saved) {
+        setToolName("");
+        setOperation("");
+        setDescription("");
+        setAllowWrite(false);
+      }
+    } catch (err) {
+      toast.error(errorMessage(err));
+    } finally {
+      setBusy(false);
+    }
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "space-y-2 border-t border-border-secondary pt-3",
+      "data-testid": "mcp-connector-form",
+      children: [
+        /* @__PURE__ */ jsx("p", { className: "text-sm font-medium text-text-primary", children: tr("fluidgrids.mcp.connector.title", "Expose a connector operation") }),
+        /* @__PURE__ */ jsx("p", { className: "text-xs text-text-secondary", children: tr(
+          "fluidgrids.mcp.connector.help",
+          "Read operations (get, list, search, ...) can be exposed as they are. An operation that changes data is exposed only when you allow writes for this tool, and every call still passes your action policies."
+        ) }),
+        /* @__PURE__ */ jsxs("div", { className: "grid gap-2 sm:grid-cols-2", children: [
+          /* @__PURE__ */ jsx(
+            Input,
+            {
+              "aria-label": tr("fluidgrids.mcp.connector.toolName", "Tool name"),
+              placeholder: "list_customers",
+              value: toolName,
+              onChange: (e) => setToolName(e.target.value)
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Input,
+            {
+              "aria-label": tr("fluidgrids.mcp.connector.nodeType", "Node type"),
+              placeholder: "store/stripe",
+              value: nodeType,
+              onChange: (e) => setNodeType(e.target.value)
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Input,
+            {
+              "aria-label": tr("fluidgrids.mcp.connector.operation", "Operation"),
+              placeholder: "listCustomers",
+              value: operation,
+              onChange: (e) => setOperation(e.target.value)
+            }
+          ),
+          /* @__PURE__ */ jsxs(
+            "select",
+            {
+              "aria-label": tr("fluidgrids.mcp.connector.connection", "Connection"),
+              className: FIELD,
+              value: connectionId,
+              onChange: (e) => setConnectionId(e.target.value),
+              children: [
+                /* @__PURE__ */ jsx("option", { value: "", children: tr(
+                  "fluidgrids.mcp.connector.pickConnection",
+                  "Choose a connection"
+                ) }),
+                connections.map((entry) => /* @__PURE__ */ jsxs("option", { value: entry.id, children: [
+                  entry.name,
+                  " (",
+                  entry.provider.name,
+                  ")"
+                ] }, entry.id))
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Input,
+            {
+              className: "sm:col-span-2",
+              "aria-label": tr("fluidgrids.mcp.connector.description", "Description"),
+              placeholder: tr(
+                "fluidgrids.mcp.connector.descriptionPlaceholder",
+                "What the tool does (optional)"
+              ),
+              value: description,
+              onChange: (e) => setDescription(e.target.value)
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center justify-between gap-2", children: [
+          /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+            /* @__PURE__ */ jsx(
+              Checkbox,
+              {
+                id: "mcp-allow-write",
+                checked: allowWrite,
+                onCheckedChange: (on) => setAllowWrite(on === true)
+              }
+            ),
+            /* @__PURE__ */ jsx(Label, { htmlFor: "mcp-allow-write", className: "text-sm", children: tr(
+              "fluidgrids.mcp.connector.allowWrite",
+              "Allow this tool to change data"
+            ) })
+          ] }),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              size: "sm",
+              onClick: () => void submit(),
+              disabled: busy || !connectionId,
+              children: tr("fluidgrids.mcp.connector.add", "Add tool")
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}
+function TokenSection({
+  toolNames,
+  versions
+}) {
+  const tr = useTr();
+  const tokens = useMcpTokens();
+  const [form, setForm] = useState(emptyTokenForm);
+  const [created, setCreated] = useState(null);
+  const [busy, setBusy] = useState(false);
+  if (!tokens.available) {
+    return /* @__PURE__ */ jsx("p", { className: "text-sm text-text-secondary", children: tr(
+      "fluidgrids.mcp.tokens.unavailable",
+      "MCP tokens are managed from the developer portal in this app."
+    ) });
+  }
+  const submit = async () => {
+    setBusy(true);
+    try {
+      const valid = validateTokenForm(form);
+      setCreated(await tokens.create(valid));
+      setForm(emptyTokenForm());
+    } catch (err) {
+      toast.error(errorMessage(err));
+    } finally {
+      setBusy(false);
+    }
+  };
+  const toggleTool = (name, on) => setForm((current) => ({
+    ...current,
+    tools: on ? [.../* @__PURE__ */ new Set([...current.tools, name])] : current.tools.filter((tool) => tool !== name)
+  }));
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-3", "data-testid": "mcp-tokens", children: [
+    created && /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: "rounded-md border border-status-warning-border bg-status-warning-bg-subtle p-3 space-y-2",
+        "data-testid": "mcp-token-created",
+        children: [
+          /* @__PURE__ */ jsx("p", { className: "text-sm text-status-warning-text", children: tr(
+            "fluidgrids.mcp.tokens.once",
+            "Copy the key and secret now: the secret is not shown again. A client exchanges them for an app token (authenticateAPIKey) and a workspace token (issueWorkspaceToken)."
+          ) }),
+          /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap gap-2", children: [
+            /* @__PURE__ */ jsxs(
+              Button,
+              {
+                size: "sm",
+                variant: "outline",
+                onClick: () => void copy(
+                  created.apiKey,
+                  tr("fluidgrids.mcp.tokens.keyCopied", "Key copied")
+                ),
+                children: [
+                  /* @__PURE__ */ jsx(Icon, { icon: "mdi:content-copy", width: 14 }),
+                  " ",
+                  tr("fluidgrids.mcp.tokens.copyKey", "Copy key")
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsxs(
+              Button,
+              {
+                size: "sm",
+                variant: "outline",
+                onClick: () => void copy(
+                  created.apiSecret,
+                  tr("fluidgrids.mcp.tokens.secretCopied", "Secret copied")
+                ),
+                children: [
+                  /* @__PURE__ */ jsx(Icon, { icon: "mdi:content-copy", width: 14 }),
+                  " ",
+                  tr("fluidgrids.mcp.tokens.copySecret", "Copy secret")
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsx(Button, { size: "sm", variant: "ghost", onClick: () => setCreated(null), children: tr("fluidgrids.mcp.tokens.done", "Done") })
+          ] })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs("div", { className: "grid gap-2 sm:grid-cols-3", children: [
+      /* @__PURE__ */ jsx(
+        Input,
+        {
+          "aria-label": tr("fluidgrids.mcp.tokens.name", "Token name"),
+          placeholder: tr(
+            "fluidgrids.mcp.tokens.namePlaceholder",
+            "e.g. Claude Desktop"
+          ),
+          value: form.name,
+          onChange: (e) => setForm({ ...form, name: e.target.value }),
+          "data-testid": "mcp-token-name"
+        }
+      ),
+      /* @__PURE__ */ jsxs(
+        "select",
+        {
+          "aria-label": tr("fluidgrids.mcp.tokens.version", "Tool set version"),
+          className: FIELD,
+          value: form.pinVersion ?? "",
+          onChange: (e) => setForm({
+            ...form,
+            pinVersion: e.target.value ? Number(e.target.value) : null
+          }),
+          children: [
+            /* @__PURE__ */ jsx("option", { value: "", children: tr("fluidgrids.mcp.tokens.latest", "Newest version") }),
+            versions.map((version) => /* @__PURE__ */ jsx("option", { value: version, children: tr("fluidgrids.mcp.tokens.pinned", "Pinned to v{{version}}", {
+              version
+            }) }, version))
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        Input,
+        {
+          type: "number",
+          min: 1,
+          max: MCP_TOKEN_MAX_DAYS,
+          "aria-label": tr("fluidgrids.mcp.tokens.days", "Expires after (days)"),
+          value: form.expiresInDays,
+          onChange: (e) => setForm({ ...form, expiresInDays: Number(e.target.value) })
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap gap-3", children: [
+      /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+        /* @__PURE__ */ jsx(
+          Checkbox,
+          {
+            id: "mcp-token-all",
+            checked: form.allTools,
+            onCheckedChange: (on) => setForm({ ...form, allTools: on === true })
+          }
+        ),
+        /* @__PURE__ */ jsx(Label, { htmlFor: "mcp-token-all", className: "text-sm", children: tr("fluidgrids.mcp.tokens.allTools", "All tools") })
+      ] }),
+      !form.allTools && toolNames.map((name) => /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+        /* @__PURE__ */ jsx(
+          Checkbox,
+          {
+            id: `mcp-token-tool-${name}`,
+            checked: form.tools.includes(name),
+            onCheckedChange: (on) => toggleTool(name, on === true)
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Label,
+          {
+            htmlFor: `mcp-token-tool-${name}`,
+            className: "text-sm font-mono",
+            children: name
+          }
+        )
+      ] }, name))
+    ] }),
+    /* @__PURE__ */ jsx(
+      Button,
+      {
+        size: "sm",
+        onClick: () => void submit(),
+        disabled: busy,
+        "data-testid": "mcp-token-create",
+        children: tr("fluidgrids.mcp.tokens.create", "Create token")
+      }
+    ),
+    /* @__PURE__ */ jsxs("ul", { className: "divide-y divide-border-secondary", children: [
+      tokens.keys.map((key) => /* @__PURE__ */ jsxs(
+        "li",
+        {
+          className: "flex flex-wrap items-center justify-between gap-2 py-2",
+          children: [
+            /* @__PURE__ */ jsxs("div", { children: [
+              /* @__PURE__ */ jsxs("p", { className: "text-sm text-text-primary", children: [
+                key.name,
+                " ",
+                /* @__PURE__ */ jsxs("span", { className: "font-mono text-xs text-text-secondary", children: [
+                  key.prefix,
+                  "\u2026"
+                ] })
+              ] }),
+              /* @__PURE__ */ jsxs("p", { className: "text-xs text-text-secondary", children: [
+                describeScopes(key.scopes),
+                key.expiresAt ? ` \xB7 expires ${new Date(key.expiresAt).toLocaleDateString()}` : "",
+                key.lastUsedAt ? ` \xB7 last used ${new Date(key.lastUsedAt).toLocaleString()}` : ""
+              ] })
+            ] }),
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                size: "sm",
+                variant: "outline",
+                onClick: () => void attempt(
+                  () => tokens.revoke(key.id),
+                  tr("fluidgrids.mcp.tokens.revoked", "Token revoked")
+                ),
+                children: tr("fluidgrids.mcp.tokens.revoke", "Revoke")
+              }
+            )
+          ]
+        },
+        key.id
+      )),
+      !tokens.loading && tokens.keys.length === 0 && /* @__PURE__ */ jsx("li", { className: "py-2 text-sm text-text-secondary", children: tr("fluidgrids.mcp.tokens.empty", "No MCP tokens yet.") })
+    ] })
+  ] });
+}
+function CallRow({
+  call,
+  onDecide
+}) {
+  const tr = useTr();
+  return /* @__PURE__ */ jsxs(
+    "tr",
+    {
+      className: "border-t border-border-secondary align-top",
+      "data-testid": "mcp-call-row",
+      children: [
+        /* @__PURE__ */ jsx("td", { className: "py-2 pr-3 text-xs text-text-secondary whitespace-nowrap", children: new Date(call.createdAt).toLocaleString() }),
+        /* @__PURE__ */ jsxs("td", { className: "py-2 pr-3 font-mono text-xs text-text-primary", children: [
+          call.toolName,
+          " ",
+          /* @__PURE__ */ jsxs("span", { className: "text-text-secondary", children: [
+            "v",
+            call.toolSetVersion
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx("td", { className: "py-2 pr-3", children: /* @__PURE__ */ jsx(ToneBadge, { tone: callTone(call.status), children: call.status }) }),
+        /* @__PURE__ */ jsxs("td", { className: "py-2 pr-3 text-xs text-text-secondary", children: [
+          call.decision,
+          call.policyName ? ` \xB7 ${call.policyName}` : "",
+          call.errorMessage ? /* @__PURE__ */ jsx("div", { className: "text-status-error-text", children: call.errorMessage }) : null
+        ] }),
+        /* @__PURE__ */ jsxs("td", { className: "py-2 pr-3 text-xs text-text-secondary", children: [
+          call.runId ? /* @__PURE__ */ jsx("span", { className: "font-mono", children: call.runId.slice(0, 8) }) : "\u2014",
+          typeof call.latencyMs === "number" ? ` \xB7 ${call.latencyMs} ms` : ""
+        ] }),
+        /* @__PURE__ */ jsx("td", { className: "py-2 text-xs", children: canDecide(call) ? /* @__PURE__ */ jsxs("div", { className: "flex gap-1", children: [
+          /* @__PURE__ */ jsx(Button, { size: "sm", onClick: () => onDecide(call.id, true), children: tr("fluidgrids.mcp.calls.approve", "Approve") }),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              size: "sm",
+              variant: "outline",
+              onClick: () => onDecide(call.id, false),
+              children: tr("fluidgrids.mcp.calls.decline", "Decline")
+            }
+          )
+        ] }) : /* @__PURE__ */ jsx(
+          "span",
+          {
+            className: "font-mono text-text-secondary",
+            title: call.argsSha256,
+            children: call.argsSha256.slice(0, 10)
+          }
+        ) })
+      ]
+    }
+  );
+}
+function CallLog() {
+  const tr = useTr();
+  const log = useMcpToolCalls();
+  const decide = (id, approve) => void attempt(
+    () => log.decide(id, approve),
+    approve ? tr("fluidgrids.mcp.calls.approved", "Call approved") : tr("fluidgrids.mcp.calls.declined", "Call declined")
+  );
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-2", "data-testid": "mcp-call-log", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+      /* @__PURE__ */ jsxs(
+        "select",
+        {
+          "aria-label": tr("fluidgrids.mcp.calls.filter", "Status"),
+          className: FIELD,
+          value: log.statusFilter ?? "",
+          onChange: (e) => log.setStatusFilter(e.target.value || null),
+          children: [
+            /* @__PURE__ */ jsx("option", { value: "", children: tr("fluidgrids.mcp.calls.all", "All calls") }),
+            ["PENDING_APPROVAL", "SUCCEEDED", "RUNNING", "FAILED", "DENIED"].map(
+              (status) => /* @__PURE__ */ jsx("option", { value: status, children: status }, status)
+            )
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          size: "sm",
+          variant: "ghost",
+          onClick: () => void attempt(() => log.reload()),
+          children: /* @__PURE__ */ jsx(Icon, { icon: "mdi:refresh", width: 16 })
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "overflow-x-auto", children: /* @__PURE__ */ jsxs("table", { className: "w-full text-left text-sm", children: [
+      /* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsxs("tr", { className: "text-xs text-text-secondary", children: [
+        /* @__PURE__ */ jsx("th", { className: "pb-1 pr-3 font-medium", children: tr("fluidgrids.mcp.calls.when", "When") }),
+        /* @__PURE__ */ jsx("th", { className: "pb-1 pr-3 font-medium", children: tr("fluidgrids.mcp.calls.tool", "Tool") }),
+        /* @__PURE__ */ jsx("th", { className: "pb-1 pr-3 font-medium", children: tr("fluidgrids.mcp.calls.status", "Status") }),
+        /* @__PURE__ */ jsx("th", { className: "pb-1 pr-3 font-medium", children: tr("fluidgrids.mcp.calls.decision", "Decision") }),
+        /* @__PURE__ */ jsx("th", { className: "pb-1 pr-3 font-medium", children: tr("fluidgrids.mcp.calls.run", "Run") }),
+        /* @__PURE__ */ jsx("th", { className: "pb-1 font-medium", children: tr("fluidgrids.mcp.calls.args", "Arguments") })
+      ] }) }),
+      /* @__PURE__ */ jsx("tbody", { children: log.calls.map((call) => /* @__PURE__ */ jsx(CallRow, { call, onDecide: decide }, call.id)) })
+    ] }) }),
+    !log.loading && log.calls.length === 0 && /* @__PURE__ */ jsx("p", { className: "text-sm text-text-secondary", children: tr("fluidgrids.mcp.calls.empty", "No calls yet.") }),
+    log.hasMore && /* @__PURE__ */ jsx(
+      Button,
+      {
+        size: "sm",
+        variant: "outline",
+        onClick: () => void attempt(() => log.loadMore()),
+        children: tr("fluidgrids.mcp.calls.more", "Load more")
+      }
+    )
+  ] });
+}
+function McpGatewayTab({
+  workflowKey
+}) {
+  const tr = useTr();
+  const mcp = useMcpGateway();
+  const [note, setNote] = useState("");
+  const [busy, setBusy] = useState(false);
+  const thisWorkflowTool = workflowKey ? mcp.tools.find(
+    (tool) => tool.kind === "WORKFLOW" && tool.workflowKey === workflowKey
+  ) : void 0;
+  const latest = mcp.toolSets.find((set) => set.status === "PUBLISHED");
+  const servedVersions = useMemo(
+    () => mcp.toolSets.filter((set) => set.status === "PUBLISHED").map((set) => set.version),
+    [mcp.toolSets]
+  );
+  const url = mcp.endpoint ? endpointUrl(getFluidGridsConfig().apiGatewayUrl, mcp.endpoint.path) : "";
+  const toggleThisWorkflow = (on) => {
+    if (!workflowKey) return;
+    void attempt(
+      () => thisWorkflowTool ? mcp.setEnabled(thisWorkflowTool.id, on) : mcp.exposeWorkflow({ workflowKey })
+    );
+  };
+  const publish = async () => {
+    setBusy(true);
+    try {
+      const outcome = await mcp.publish(note.trim());
+      setNote("");
+      toast.success(
+        outcome.created ? tr(
+          "fluidgrids.mcp.publish.created",
+          "Published version {{version}}",
+          { version: outcome.toolSet.version }
+        ) : tr(
+          "fluidgrids.mcp.publish.unchanged",
+          "Nothing changed since version {{version}}",
+          {
+            version: outcome.toolSet.version
+          }
+        )
+      );
+      for (const skip of outcome.skipped)
+        toast.warning(`${skip.toolName}: ${skip.reason}`);
+    } catch (err) {
+      toast.error(errorMessage(err));
+    } finally {
+      setBusy(false);
+    }
+  };
+  if (mcp.error && !mcp.loading && mcp.tools.length === 0) {
+    return /* @__PURE__ */ jsxs("div", { className: CARD, children: [
+      /* @__PURE__ */ jsx("p", { className: "text-sm text-status-error-text", children: errorMessage(mcp.error) }),
+      /* @__PURE__ */ jsx(Button, { size: "sm", variant: "outline", onClick: () => void mcp.reload(), children: tr("fluidgrids.mcp.retry", "Try again") })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-4", "data-testid": "mcp-gateway-tab", children: [
+    /* @__PURE__ */ jsxs("section", { className: CARD, children: [
+      /* @__PURE__ */ jsx("h3", { className: "text-base font-semibold text-text-primary", children: tr("fluidgrids.mcp.endpoint.title", "MCP endpoint") }),
+      /* @__PURE__ */ jsx("p", { className: "text-sm text-text-secondary", children: tr(
+        "fluidgrids.mcp.endpoint.help",
+        "External agents call the published tools here over Streamable HTTP with an MCP token. Every call passes your action policies and is recorded below."
+      ) }),
+      url && /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center gap-2", children: [
+        /* @__PURE__ */ jsxs(
+          "code",
+          {
+            className: "rounded bg-background-secondary px-2 py-1 text-xs text-text-primary break-all",
+            "data-testid": "mcp-endpoint-url",
+            children: [
+              "POST ",
+              url
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            size: "sm",
+            variant: "outline",
+            onClick: () => void copy(
+              url,
+              tr("fluidgrids.mcp.endpoint.copied", "Endpoint copied")
+            ),
+            children: /* @__PURE__ */ jsx(Icon, { icon: "mdi:content-copy", width: 14 })
+          }
+        ),
+        /* @__PURE__ */ jsx("span", { className: "text-xs text-text-secondary", children: latest ? tr(
+          "fluidgrids.mcp.endpoint.version",
+          "Serving version {{version}}",
+          { version: latest.version }
+        ) : tr("fluidgrids.mcp.endpoint.none", "Nothing published yet") })
+      ] }),
+      workflowKey && /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 border-t border-border-secondary pt-3", children: [
+        /* @__PURE__ */ jsx(
+          Switch,
+          {
+            id: "mcp-this-workflow",
+            checked: thisWorkflowTool?.enabled ?? false,
+            onCheckedChange: toggleThisWorkflow,
+            "data-testid": "mcp-expose-this-workflow"
+          }
+        ),
+        /* @__PURE__ */ jsxs(Label, { htmlFor: "mcp-this-workflow", className: "text-sm", children: [
+          tr(
+            "fluidgrids.mcp.thisWorkflow",
+            "Expose this workflow as an MCP tool"
+          ),
+          thisWorkflowTool ? /* @__PURE__ */ jsx("span", { className: "ml-1 font-mono text-text-secondary", children: thisWorkflowTool.toolName }) : null
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs("section", { className: CARD, children: [
+      /* @__PURE__ */ jsx("h3", { className: "text-base font-semibold text-text-primary", children: tr("fluidgrids.mcp.tools.title", "Tools") }),
+      /* @__PURE__ */ jsx("p", { className: "text-xs text-text-secondary", children: tr(
+        "fluidgrids.mcp.tools.help",
+        `A workflow tool runs the workflow's active version; its arguments are the fields its "When Executed by Another Workflow" trigger declares. Changes reach clients when you publish.`
+      ) }),
+      /* @__PURE__ */ jsxs(
+        "ul",
+        {
+          className: "divide-y divide-border-secondary",
+          "data-testid": "mcp-tools",
+          children: [
+            mcp.tools.map((tool) => /* @__PURE__ */ jsxs(
+              "li",
+              {
+                className: "flex flex-wrap items-center justify-between gap-2 py-2",
+                children: [
+                  /* @__PURE__ */ jsxs("div", { className: "space-y-0.5", children: [
+                    /* @__PURE__ */ jsx("p", { className: "font-mono text-sm text-text-primary", children: tool.toolName }),
+                    /* @__PURE__ */ jsx("p", { className: "text-xs text-text-secondary", children: tool.kind === "WORKFLOW" ? tr("fluidgrids.mcp.tools.workflow", "Workflow {{key}}", {
+                      key: tool.workflowKey ?? ""
+                    }) : `${tool.nodeType ?? ""} \xB7 ${tool.operation ?? ""}` })
+                  ] }),
+                  /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+                    /* @__PURE__ */ jsx(ToneBadge, { tone: tool.readOnly ? "success" : "warning", children: tool.readOnly ? tr("fluidgrids.mcp.tools.readOnly", "Read only") : tr("fluidgrids.mcp.tools.write", "Changes data") }),
+                    /* @__PURE__ */ jsx(
+                      Switch,
+                      {
+                        checked: tool.enabled,
+                        "aria-label": tr("fluidgrids.mcp.tools.enabled", "Enabled"),
+                        onCheckedChange: (on) => void attempt(() => mcp.setEnabled(tool.id, on))
+                      }
+                    ),
+                    /* @__PURE__ */ jsx(
+                      Button,
+                      {
+                        size: "sm",
+                        variant: "ghost",
+                        "aria-label": tr("fluidgrids.mcp.tools.remove", "Remove"),
+                        onClick: () => void attempt(
+                          () => mcp.removeTool(tool.id),
+                          tr("fluidgrids.mcp.tools.removed", "Tool removed")
+                        ),
+                        children: /* @__PURE__ */ jsx(Icon, { icon: "mdi:delete-outline", width: 16 })
+                      }
+                    )
+                  ] })
+                ]
+              },
+              tool.id
+            )),
+            !mcp.loading && mcp.tools.length === 0 && /* @__PURE__ */ jsx("li", { className: "py-2 text-sm text-text-secondary", children: tr("fluidgrids.mcp.tools.empty", "No tools exposed yet.") })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        ConnectorToolForm,
+        {
+          onSave: (input) => attempt(
+            () => mcp.exposeConnector(input),
+            tr("fluidgrids.mcp.connector.added", "Tool added")
+          )
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs("section", { className: CARD, children: [
+      /* @__PURE__ */ jsx("h3", { className: "text-base font-semibold text-text-primary", children: tr("fluidgrids.mcp.versions.title", "Published versions") }),
+      /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap gap-2", children: [
+        /* @__PURE__ */ jsx(
+          Input,
+          {
+            className: "max-w-sm",
+            "aria-label": tr("fluidgrids.mcp.versions.note", "Release note"),
+            placeholder: tr(
+              "fluidgrids.mcp.versions.notePlaceholder",
+              "What changed (optional)"
+            ),
+            value: note,
+            onChange: (e) => setNote(e.target.value)
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            size: "sm",
+            onClick: () => void publish(),
+            disabled: busy,
+            "data-testid": "mcp-publish",
+            children: tr("fluidgrids.mcp.versions.publish", "Publish tool set")
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx(
+        "ul",
+        {
+          className: "divide-y divide-border-secondary",
+          "data-testid": "mcp-versions",
+          children: mcp.toolSets.map((set) => /* @__PURE__ */ jsxs(
+            "li",
+            {
+              className: "flex flex-wrap items-center justify-between gap-2 py-2",
+              children: [
+                /* @__PURE__ */ jsxs("div", { children: [
+                  /* @__PURE__ */ jsxs("p", { className: "text-sm text-text-primary", children: [
+                    "v",
+                    set.version,
+                    " \xB7",
+                    " ",
+                    set.tools.map((tool) => tool.name).join(", ")
+                  ] }),
+                  /* @__PURE__ */ jsxs("p", { className: "text-xs text-text-secondary", children: [
+                    new Date(set.publishedAt).toLocaleString(),
+                    set.note ? ` \xB7 ${set.note}` : ""
+                  ] })
+                ] }),
+                /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+                  /* @__PURE__ */ jsx(
+                    ToneBadge,
+                    {
+                      tone: set.status === "PUBLISHED" ? "success" : "neutral",
+                      children: set.status
+                    }
+                  ),
+                  set.status === "PUBLISHED" && /* @__PURE__ */ jsx(
+                    Button,
+                    {
+                      size: "sm",
+                      variant: "outline",
+                      onClick: () => void attempt(
+                        () => mcp.deprecate(set.version),
+                        tr(
+                          "fluidgrids.mcp.versions.deprecated",
+                          "Version deprecated"
+                        )
+                      ),
+                      children: tr("fluidgrids.mcp.versions.deprecate", "Deprecate")
+                    }
+                  )
+                ] })
+              ]
+            },
+            set.id
+          ))
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs("section", { className: CARD, children: [
+      /* @__PURE__ */ jsx("h3", { className: "text-base font-semibold text-text-primary", children: tr("fluidgrids.mcp.tokens.title", "MCP tokens") }),
+      /* @__PURE__ */ jsx(
+        TokenSection,
+        {
+          toolNames: latest?.tools.map((tool) => tool.name) ?? [],
+          versions: servedVersions
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs("section", { className: CARD, children: [
+      /* @__PURE__ */ jsx("h3", { className: "text-base font-semibold text-text-primary", children: tr("fluidgrids.mcp.calls.title", "Call log") }),
+      /* @__PURE__ */ jsx(CallLog, {})
+    ] })
+  ] });
+}
+
 // src/modules/settings/utils/workflow-settings-persistence.ts
 var DATA_SAVING_KEYS = [
   "saveSuccessExecutions",
@@ -380,11 +1663,16 @@ var RETENTION_KEYS = [
   "maxAgeDays",
   "maxRuns"
 ];
+var DATA_PRIVACY_KEYS = [
+  "doNotStoreRunData",
+  "redactFields"
+];
 function mergeWorkflowExecutionSettings(existing, next) {
   const merged = { ...existing, ...next };
   for (const [key, editable] of [
     ["dataSaving", DATA_SAVING_KEYS],
-    ["retention", RETENTION_KEYS]
+    ["retention", RETENTION_KEYS],
+    ["dataPrivacy", DATA_PRIVACY_KEYS]
   ]) {
     const nested = mergeNested(existing[key], next[key], editable);
     if (nested) merged[key] = nested;
@@ -583,7 +1871,15 @@ function ExecutionTab({ workflowKey }) {
     return config ?? {};
   }, [workflow?.definitionJson]);
   const [form, setForm] = useState(persistedConfig);
-  useEffect(() => setForm(persistedConfig), [persistedConfig]);
+  const [redactFieldsText, setRedactFieldsText] = useState(
+    () => formatRedactFields(persistedConfig.dataPrivacy?.redactFields)
+  );
+  useEffect(() => {
+    setForm(persistedConfig);
+    setRedactFieldsText(
+      formatRedactFields(persistedConfig.dataPrivacy?.redactFields)
+    );
+  }, [persistedConfig]);
   const runData = useRunDataSettings();
   const selectedErrorWorkflowKey = form.errorWorkflowKey;
   const { data: errorWorkflowData } = useWorkflowDefinitionQuery({
@@ -970,6 +2266,79 @@ function ExecutionTab({ workflowKey }) {
             }
           )
         }
+      ),
+      /* @__PURE__ */ jsx(
+        SettingRow,
+        {
+          label: tr(
+            "fluidgrids.settings.execution.doNotStoreRunDataLabel",
+            "Do not store run data"
+          ),
+          description: tr(
+            "fluidgrids.settings.execution.doNotStoreRunDataDescription",
+            "Keep only each run's status, timings, node statuses and errors. Trigger data and node inputs and outputs are deleted when the run finishes, and log lines keep their message only. Finished runs cannot be retried, replayed or reused."
+          ),
+          children: /* @__PURE__ */ jsx(
+            Switch,
+            {
+              "data-testid": "fluidgrids-do-not-store-run-data",
+              "aria-label": tr(
+                "fluidgrids.settings.execution.doNotStoreRunDataLabel",
+                "Do not store run data"
+              ),
+              checked: form.dataPrivacy?.doNotStoreRunData === true,
+              onCheckedChange: (checked) => setForm((f) => ({
+                ...f,
+                dataPrivacy: compactOverrides({
+                  ...f.dataPrivacy,
+                  doNotStoreRunData: checked ? true : void 0
+                })
+              })),
+              disabled: locked
+            }
+          )
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        SettingRow,
+        {
+          label: tr(
+            "fluidgrids.settings.execution.redactFieldsLabel",
+            "Redacted fields"
+          ),
+          description: tr(
+            "fluidgrids.settings.execution.redactFieldsDescription",
+            "Comma-separated. A name (ssn) is hidden wherever it appears; a dotted path (customer.email) from the top of the data. Replaced with [REDACTED] in run logs and in stored run data, together with secret-looking keys such as tokens and passwords."
+          ),
+          children: /* @__PURE__ */ jsx(
+            Input,
+            {
+              "data-testid": "fluidgrids-redact-fields",
+              "aria-label": tr(
+                "fluidgrids.settings.execution.redactFieldsLabel",
+                "Redacted fields"
+              ),
+              value: redactFieldsText,
+              placeholder: tr(
+                "fluidgrids.settings.execution.redactFieldsPlaceholder",
+                "ssn, customer.email"
+              ),
+              onChange: (e) => {
+                const text = e.target.value;
+                setRedactFieldsText(text);
+                setForm((f) => ({
+                  ...f,
+                  dataPrivacy: compactOverrides({
+                    ...f.dataPrivacy,
+                    redactFields: parseRedactFields(text)
+                  })
+                }));
+              },
+              disabled: locked,
+              className: "w-[260px]"
+            }
+          )
+        }
       )
     ] }),
     !canEdit && /* @__PURE__ */ jsx("p", { className: "mt-4 text-xs text-text-secondary", role: "note", children: tr(
@@ -1253,6 +2622,30 @@ function SettingsPage({
                 ]
               }
             ),
+            /* @__PURE__ */ jsxs(
+              TabsTrigger,
+              {
+                value: "agents",
+                className: "gap-1.5",
+                "data-tour": "fluidgrids-settings-agents-tab",
+                children: [
+                  /* @__PURE__ */ jsx(Icon, { icon: "mdi:robot-outline", width: 16 }),
+                  tr("fluidgrids.settings.page.agentsTab", "Agents")
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsxs(
+              TabsTrigger,
+              {
+                value: "mcp",
+                className: "gap-1.5",
+                "data-tour": "fluidgrids-settings-mcp-tab",
+                children: [
+                  /* @__PURE__ */ jsx(Icon, { icon: "mdi:connection", width: 16 }),
+                  tr("fluidgrids.settings.page.mcpTab", "MCP")
+                ]
+              }
+            ),
             /* @__PURE__ */ jsxs(TabsTrigger, { value: "notifications", className: "gap-1.5", children: [
               /* @__PURE__ */ jsx(Icon, { icon: "mdi:bell-outline", width: 16 }),
               tr("fluidgrids.settings.page.notificationsTab", "Notifications")
@@ -1280,6 +2673,8 @@ function SettingsPage({
       /* @__PURE__ */ jsx(TabsContent, { value: "execution", children: /* @__PURE__ */ jsx(ExecutionTab, { workflowKey }) }),
       /* @__PURE__ */ jsx(TabsContent, { value: "run-data", children: /* @__PURE__ */ jsx(RunDataTab, {}) }),
       /* @__PURE__ */ jsx(TabsContent, { value: "policies", children: /* @__PURE__ */ jsx(ActionPoliciesTab, {}) }),
+      /* @__PURE__ */ jsx(TabsContent, { value: "agents", children: /* @__PURE__ */ jsx(AgentsTab, {}) }),
+      /* @__PURE__ */ jsx(TabsContent, { value: "mcp", children: /* @__PURE__ */ jsx(McpGatewayTab, { workflowKey }) }),
       /* @__PURE__ */ jsx(TabsContent, { value: "notifications", children: /* @__PURE__ */ jsx(NotificationsTab, {}) }),
       logStreamsEnabled ? /* @__PURE__ */ jsx(TabsContent, { value: "log-streaming", children: /* @__PURE__ */ jsx(LogStreamingTab, {}) }) : null,
       /* @__PURE__ */ jsx(TabsContent, { value: "api", children: /* @__PURE__ */ jsx(ApiTab, {}) })