@burdenoff/fluidgrids-fe-sdk 2026.1028.6 → 2026.1028.7

package/dist/chunk-3ENHRYM5.js

@@ -0,0 +1,749 @@
+import { throwIfResultError, useConnections, describeOperationError } from './chunk-6NUHJPGJ.js';
+import { useTr } from './chunk-UULVIT25.js';
+import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
+import { useState, useCallback, useEffect } from 'react';
+import { Icon } from '@iconify/react';
+import { Button } from '@burdenoff/fe-libs/button';
+import { Badge, Select, SelectTrigger, SelectValue, SelectContent, SelectItem, Label, Input, Switch, Textarea, Checkbox } from '@burdenoff/fe-libs/ui';
+import { toast } from 'sonner';
+import { gql } from '@apollo/client';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+
+var AGENT_FIELDS = `
+  id
+  name
+  description
+  appId
+  toolAllowlist { nodeType operations }
+  connectionScope
+  requireToolApproval
+  ownerUserId
+  status
+  createdAt
+  updatedAt
+`;
+var GRANT_FIELDS = `
+  agentDefinitionId
+  userId
+  grantedBy
+  grantedAt
+  expiresAt
+  status
+  isMine
+`;
+var AGENT_DEFINITIONS = gql`
+  query AgentDefinitions {
+    agentDefinitions {
+      ${AGENT_FIELDS}
+    }
+  }
+`;
+var AGENT_GRANTS = gql`
+  query AgentDefinitionGrants($agentDefinitionId: ID!) {
+    agentDefinitionGrants(agentDefinitionId: $agentDefinitionId) {
+      ${GRANT_FIELDS}
+    }
+  }
+`;
+var CREATE_AGENT = gql`
+  mutation CreateAgentDefinition($input: AgentDefinitionInput!) {
+    createAgentDefinition(input: $input) {
+      ${AGENT_FIELDS}
+    }
+  }
+`;
+var UPDATE_AGENT = gql`
+  mutation UpdateAgentDefinition($id: ID!, $input: AgentDefinitionInput!) {
+    updateAgentDefinition(id: $id, input: $input) {
+      ${AGENT_FIELDS}
+    }
+  }
+`;
+var DELETE_AGENT = gql`
+  mutation DeleteAgentDefinition($id: ID!) {
+    deleteAgentDefinition(id: $id)
+  }
+`;
+var GRANT_AGENT = gql`
+  mutation GrantAgentDefinition($agentDefinitionId: ID!, $expiresInDays: Int) {
+    grantAgentDefinition(agentDefinitionId: $agentDefinitionId, expiresInDays: $expiresInDays) {
+      ${GRANT_FIELDS}
+    }
+  }
+`;
+var REVOKE_MY_GRANT = gql`
+  mutation RevokeMyAgentGrant($agentDefinitionId: ID!) {
+    revokeMyAgentGrant(agentDefinitionId: $agentDefinitionId)
+  }
+`;
+var REVOKE_GRANT = gql`
+  mutation RevokeAgentGrant($agentDefinitionId: ID!, $userId: String!) {
+    revokeAgentGrant(agentDefinitionId: $agentDefinitionId, userId: $userId)
+  }
+`;
+function asError(err) {
+  return err instanceof Error ? err : new Error(String(err));
+}
+function useAgentDefinitionList() {
+  const [agents, setAgents] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const reload = useCallback(async () => {
+    try {
+      const result = await getFluidGridsClient().query({ query: AGENT_DEFINITIONS, fetchPolicy: "network-only" });
+      throwIfResultError(result);
+      setAgents(result.data?.agentDefinitions ?? []);
+      setError(null);
+    } catch (err) {
+      setError(asError(err));
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  useEffect(() => {
+    void reload();
+  }, [reload]);
+  return { agents, loading, error, reload };
+}
+function useAgentDefinitions() {
+  const list = useAgentDefinitionList();
+  const { reload } = list;
+  const save = useCallback(
+    async (id, input) => {
+      const client = getFluidGridsClient();
+      const result = id ? await client.mutate({
+        mutation: UPDATE_AGENT,
+        variables: { id, input }
+      }) : await client.mutate({ mutation: CREATE_AGENT, variables: { input } });
+      throwIfResultError(result);
+      await reload();
+    },
+    [reload]
+  );
+  const remove = useCallback(
+    async (id) => {
+      const result = await getFluidGridsClient().mutate({
+        mutation: DELETE_AGENT,
+        variables: { id }
+      });
+      throwIfResultError(result);
+      await reload();
+    },
+    [reload]
+  );
+  const grants = useCallback(async (agentDefinitionId) => {
+    const result = await getFluidGridsClient().query({
+      query: AGENT_GRANTS,
+      variables: { agentDefinitionId },
+      fetchPolicy: "network-only"
+    });
+    throwIfResultError(result);
+    return result.data?.agentDefinitionGrants ?? [];
+  }, []);
+  const grant = useCallback(
+    async (agentDefinitionId, expiresInDays) => {
+      const result = await getFluidGridsClient().mutate({
+        mutation: GRANT_AGENT,
+        variables: { agentDefinitionId, expiresInDays }
+      });
+      throwIfResultError(result);
+    },
+    []
+  );
+  const revoke = useCallback(
+    async (agentDefinitionId, userId) => {
+      const result = userId ? await getFluidGridsClient().mutate({
+        mutation: REVOKE_GRANT,
+        variables: { agentDefinitionId, userId }
+      }) : await getFluidGridsClient().mutate({
+        mutation: REVOKE_MY_GRANT,
+        variables: { agentDefinitionId }
+      });
+      throwIfResultError(result);
+    },
+    []
+  );
+  return { ...list, save, remove, grants, grant, revoke };
+}
+
+// src/modules/agent-definitions/utils/agent-form.ts
+var DEFAULT_GRANT_DAYS = 30;
+var MAX_GRANT_DAYS = 365;
+var MAX_TOOL_RULES = 100;
+var MAX_CONNECTIONS = 100;
+var AgentFormError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AgentFormError";
+  }
+};
+function emptyAgentForm() {
+  return {
+    name: "",
+    description: "",
+    tools: [{ nodeType: "", operations: "" }],
+    connectionScope: [],
+    requireToolApproval: false,
+    status: "ACTIVE"
+  };
+}
+function agentToForm(agent) {
+  return {
+    name: agent.name,
+    description: agent.description ?? "",
+    tools: agent.toolAllowlist.length > 0 ? agent.toolAllowlist.map((rule) => ({
+      nodeType: rule.nodeType,
+      operations: rule.operations.join(", ")
+    })) : [{ nodeType: "", operations: "" }],
+    connectionScope: [...agent.connectionScope],
+    requireToolApproval: agent.requireToolApproval,
+    status: agent.status
+  };
+}
+function splitOperations(value) {
+  return [
+    ...new Set(
+      value.split(",").map((operation) => operation.trim()).filter(Boolean)
+    )
+  ];
+}
+function formToInput(form) {
+  const name = form.name.trim();
+  if (name.length === 0 || name.length > 200) {
+    throw new AgentFormError("Give the agent a name of 1 to 200 characters.");
+  }
+  const description = form.description.trim();
+  if (description.length > 2e3) {
+    throw new AgentFormError(
+      "The description must be at most 2000 characters."
+    );
+  }
+  const rules = form.tools.map((row) => ({
+    nodeType: row.nodeType.trim(),
+    operations: splitOperations(row.operations)
+  })).filter((rule) => rule.nodeType.length > 0 || rule.operations.length > 0);
+  if (rules.some((rule) => rule.nodeType.length === 0)) {
+    throw new AgentFormError("Every tool rule needs a node type.");
+  }
+  if (rules.length > MAX_TOOL_RULES) {
+    throw new AgentFormError(`At most ${MAX_TOOL_RULES} tool rules.`);
+  }
+  const connectionScope = [...new Set(form.connectionScope.filter(Boolean))];
+  if (connectionScope.length > MAX_CONNECTIONS) {
+    throw new AgentFormError(`At most ${MAX_CONNECTIONS} connections.`);
+  }
+  return {
+    name,
+    description: description || null,
+    toolAllowlist: rules,
+    connectionScope,
+    requireToolApproval: form.requireToolApproval,
+    status: form.status
+  };
+}
+function grantDays(value) {
+  const days = Number(value);
+  if (!Number.isInteger(days) || days < 1 || days > MAX_GRANT_DAYS) {
+    throw new AgentFormError(
+      `A grant lasts between 1 and ${MAX_GRANT_DAYS} days.`
+    );
+  }
+  return days;
+}
+function describeRule(rule) {
+  return rule.operations.length > 0 ? `${rule.nodeType}: ${rule.operations.join(", ")}` : `${rule.nodeType}: any operation`;
+}
+function isAgentNodeType(nodeType) {
+  if (!nodeType) return false;
+  return nodeType === "store/ai-agent" || nodeType.includes("store/ai-agent");
+}
+function errorMessage(err) {
+  if (err instanceof AgentFormError) return err.message;
+  return describeOperationError(err);
+}
+function AgentEditor({
+  initial,
+  onCancel,
+  onSave
+}) {
+  const tr = useTr();
+  const [form, setForm] = useState(initial);
+  const [busy, setBusy] = useState(false);
+  const { connections, loading: connectionsLoading } = useConnections();
+  const setTool = (index, patch) => setForm((current) => ({
+    ...current,
+    tools: current.tools.map(
+      (row, i) => i === index ? { ...row, ...patch } : row
+    )
+  }));
+  const toggleConnection = (id, on) => setForm((current) => ({
+    ...current,
+    connectionScope: on ? [.../* @__PURE__ */ new Set([...current.connectionScope, id])] : current.connectionScope.filter((value) => value !== id)
+  }));
+  const submit = async () => {
+    setBusy(true);
+    try {
+      await onSave(form);
+    } catch (err) {
+      toast.error(errorMessage(err));
+    } finally {
+      setBusy(false);
+    }
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "rounded-lg border border-border-secondary bg-background-primary p-4 space-y-4",
+      "data-testid": "agent-definition-editor",
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "grid gap-3 sm:grid-cols-2", children: [
+          /* @__PURE__ */ jsxs("div", { className: "space-y-1", children: [
+            /* @__PURE__ */ jsx(Label, { htmlFor: "agent-name", children: tr("fluidgrids.agents.name", "Name") }),
+            /* @__PURE__ */ jsx(
+              Input,
+              {
+                id: "agent-name",
+                value: form.name,
+                onChange: (e) => setForm({ ...form, name: e.target.value }),
+                "data-testid": "agent-definition-name"
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs("div", { className: "flex items-end gap-2", children: [
+            /* @__PURE__ */ jsx(
+              Switch,
+              {
+                id: "agent-active",
+                checked: form.status === "ACTIVE",
+                onCheckedChange: (on) => setForm({ ...form, status: on ? "ACTIVE" : "DISABLED" })
+              }
+            ),
+            /* @__PURE__ */ jsx(Label, { htmlFor: "agent-active", children: tr("fluidgrids.agents.active", "Active") })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "space-y-1", children: [
+          /* @__PURE__ */ jsx(Label, { htmlFor: "agent-description", children: tr("fluidgrids.agents.description", "Description") }),
+          /* @__PURE__ */ jsx(
+            Textarea,
+            {
+              id: "agent-description",
+              value: form.description,
+              onChange: (e) => setForm({ ...form, description: e.target.value }),
+              rows: 2
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "space-y-2", children: [
+          /* @__PURE__ */ jsx(Label, { children: tr("fluidgrids.agents.tools", "Tools the agent may call") }),
+          /* @__PURE__ */ jsx("p", { className: "text-xs text-text-secondary", children: tr(
+            "fluidgrids.agents.toolsHelp",
+            "A node type (for example store/slack) and the operations of it the agent may call, separated by commas. Leave the operations empty to allow every operation of that node type. Nothing else can be called."
+          ) }),
+          form.tools.map((row, index) => /* @__PURE__ */ jsxs(
+            "div",
+            {
+              className: "flex flex-wrap items-center gap-2",
+              "data-testid": `agent-definition-tool-${index}`,
+              children: [
+                /* @__PURE__ */ jsx(
+                  Input,
+                  {
+                    className: "w-48",
+                    placeholder: "store/slack",
+                    value: row.nodeType,
+                    onChange: (e) => setTool(index, { nodeType: e.target.value }),
+                    "aria-label": tr("fluidgrids.agents.nodeType", "Node type")
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  Input,
+                  {
+                    className: "min-w-48 flex-1",
+                    placeholder: "postMessage, listChannels",
+                    value: row.operations,
+                    onChange: (e) => setTool(index, { operations: e.target.value }),
+                    "aria-label": tr("fluidgrids.agents.operations", "Operations")
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  Button,
+                  {
+                    variant: "ghost",
+                    size: "sm",
+                    onClick: () => setForm({
+                      ...form,
+                      tools: form.tools.filter((_, i) => i !== index)
+                    }),
+                    "aria-label": tr("fluidgrids.agents.removeTool", "Remove tool"),
+                    children: /* @__PURE__ */ jsx(Icon, { icon: "mdi:close", width: 16 })
+                  }
+                )
+              ]
+            },
+            index
+          )),
+          /* @__PURE__ */ jsxs(
+            Button,
+            {
+              variant: "outline",
+              size: "sm",
+              onClick: () => setForm({
+                ...form,
+                tools: [...form.tools, { nodeType: "", operations: "" }]
+              }),
+              children: [
+                /* @__PURE__ */ jsx(Icon, { icon: "mdi:plus", width: 16 }),
+                tr("fluidgrids.agents.addTool", "Add tool")
+              ]
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "space-y-2", children: [
+          /* @__PURE__ */ jsx(Label, { children: tr(
+            "fluidgrids.agents.connections",
+            "Connections the agent's tools may use"
+          ) }),
+          connectionsLoading ? /* @__PURE__ */ jsx("p", { className: "text-xs text-text-secondary", children: tr("fluidgrids.agents.loadingConnections", "Loading connections\u2026") }) : connections.length === 0 ? /* @__PURE__ */ jsx("p", { className: "text-xs text-text-secondary", children: tr(
+            "fluidgrids.agents.noConnections",
+            "This workspace has no connections yet."
+          ) }) : /* @__PURE__ */ jsx("div", { className: "grid gap-1 sm:grid-cols-2", children: connections.map((connection) => /* @__PURE__ */ jsxs(
+            "label",
+            {
+              className: "flex items-center gap-2 text-sm text-text-primary",
+              children: [
+                /* @__PURE__ */ jsx(
+                  Checkbox,
+                  {
+                    checked: form.connectionScope.includes(connection.id),
+                    onCheckedChange: (on) => toggleConnection(connection.id, on === true)
+                  }
+                ),
+                /* @__PURE__ */ jsx("span", { children: connection.name }),
+                /* @__PURE__ */ jsx("span", { className: "text-xs text-text-tertiary", children: connection.provider?.name ?? connection.providerId })
+              ]
+            },
+            connection.id
+          )) })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+          /* @__PURE__ */ jsx(
+            Switch,
+            {
+              id: "agent-approval",
+              checked: form.requireToolApproval,
+              onCheckedChange: (on) => setForm({ ...form, requireToolApproval: on })
+            }
+          ),
+          /* @__PURE__ */ jsx(Label, { htmlFor: "agent-approval", children: tr(
+            "fluidgrids.agents.requireApproval",
+            "Every tool call waits for a person's approval"
+          ) })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "flex gap-2", children: [
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              onClick: () => void submit(),
+              disabled: busy,
+              "data-testid": "agent-definition-save",
+              children: tr("fluidgrids.agents.save", "Save agent")
+            }
+          ),
+          /* @__PURE__ */ jsx(Button, { variant: "outline", onClick: onCancel, disabled: busy, children: tr("fluidgrids.agents.cancel", "Cancel") })
+        ] })
+      ]
+    }
+  );
+}
+function AgentGrants({
+  agent,
+  loadGrants,
+  onGrant,
+  onRevoke
+}) {
+  const tr = useTr();
+  const [grants, setGrants] = useState(null);
+  const [days, setDays] = useState(String(DEFAULT_GRANT_DAYS));
+  const [busy, setBusy] = useState(false);
+  const load = useCallback(async () => {
+    try {
+      setGrants(await loadGrants(agent.id));
+    } catch (err) {
+      setGrants([]);
+      toast.error(errorMessage(err));
+    }
+  }, [agent.id, loadGrants]);
+  useEffect(() => {
+    void load();
+  }, [load]);
+  const run = async (action, done) => {
+    setBusy(true);
+    try {
+      await action();
+      toast.success(done);
+      await load();
+    } catch (err) {
+      toast.error(errorMessage(err));
+    } finally {
+      setBusy(false);
+    }
+  };
+  const mine = grants?.find(
+    (grant) => grant.isMine && grant.status === "ACTIVE"
+  );
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-2", "data-testid": `agent-grants-${agent.id}`, children: [
+    /* @__PURE__ */ jsx("div", { className: "flex flex-wrap items-center gap-2", children: mine ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("span", { className: "text-sm text-text-primary", children: mine.expiresAt ? tr(
+        "fluidgrids.agents.myGrantUntil",
+        "This agent may act for you until {{date}}.",
+        { date: new Date(mine.expiresAt).toLocaleDateString() }
+      ) : tr(
+        "fluidgrids.agents.myGrant",
+        "This agent may act for you."
+      ) }),
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          variant: "outline",
+          size: "sm",
+          disabled: busy,
+          onClick: () => void run(
+            () => onRevoke(agent.id, null),
+            tr("fluidgrids.agents.withdrawn", "Grant withdrawn")
+          ),
+          "data-testid": "agent-grant-withdraw",
+          children: tr("fluidgrids.agents.withdraw", "Withdraw my grant")
+        }
+      )
+    ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Label, { htmlFor: `grant-days-${agent.id}`, className: "text-sm", children: tr("fluidgrids.agents.grantFor", "Let it act for me for") }),
+      /* @__PURE__ */ jsx(
+        Input,
+        {
+          id: `grant-days-${agent.id}`,
+          className: "w-20",
+          type: "number",
+          min: 1,
+          max: MAX_GRANT_DAYS,
+          value: days,
+          onChange: (e) => setDays(e.target.value)
+        }
+      ),
+      /* @__PURE__ */ jsx("span", { className: "text-sm text-text-secondary", children: tr("fluidgrids.agents.days", "days") }),
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          size: "sm",
+          disabled: busy || agent.status !== "ACTIVE",
+          onClick: () => void run(
+            async () => onGrant(agent.id, grantDays(days)),
+            tr("fluidgrids.agents.granted", "Grant given")
+          ),
+          "data-testid": "agent-grant-give",
+          children: tr("fluidgrids.agents.grant", "Grant")
+        }
+      )
+    ] }) }),
+    grants && grants.length > 0 ? /* @__PURE__ */ jsx("ul", { className: "space-y-1 text-xs text-text-secondary", children: grants.map((grant) => /* @__PURE__ */ jsxs("li", { className: "flex items-center gap-2", children: [
+      /* @__PURE__ */ jsx("span", { className: "font-mono", children: grant.userId }),
+      /* @__PURE__ */ jsx(Badge, { variant: "outline", children: grant.status }),
+      grant.expiresAt ? /* @__PURE__ */ jsx("span", { children: tr("fluidgrids.agents.until", "until {{date}}", {
+        date: new Date(grant.expiresAt).toLocaleDateString()
+      }) }) : null,
+      !grant.isMine && grant.status === "ACTIVE" ? /* @__PURE__ */ jsx(
+        Button,
+        {
+          variant: "ghost",
+          size: "sm",
+          disabled: busy,
+          onClick: () => void run(
+            () => onRevoke(agent.id, grant.userId),
+            tr("fluidgrids.agents.revoked", "Grant revoked")
+          ),
+          children: tr("fluidgrids.agents.revoke", "Revoke")
+        }
+      ) : null
+    ] }, grant.userId)) }) : null
+  ] });
+}
+function AgentsTab() {
+  const tr = useTr();
+  const { agents, loading, error, save, remove, grants, grant, revoke } = useAgentDefinitions();
+  const [editing, setEditing] = useState(null);
+  const onSave = async (form) => {
+    const input = formToInput(form);
+    await save(editing?.id ?? null, input);
+    toast.success(tr("fluidgrids.agents.saved", "Agent saved"));
+    setEditing(null);
+  };
+  const onDelete = async (agent) => {
+    try {
+      await remove(agent.id);
+      toast.success(tr("fluidgrids.agents.deleted", "Agent deleted"));
+    } catch (err) {
+      toast.error(errorMessage(err));
+    }
+  };
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-4", "data-testid": "agents-tab", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-start justify-between gap-2", children: [
+      /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsx("h3", { className: "text-base font-semibold text-text-primary", children: tr("fluidgrids.agents.title", "Agents") }),
+        /* @__PURE__ */ jsx("p", { className: "text-sm text-text-secondary", children: tr(
+          "fluidgrids.agents.subtitle",
+          "Give an AI Agent node an identity of its own. It can only call the tools and connections you allow, only for people who granted it, and every tool call is recorded under the agent and the person."
+        ) })
+      ] }),
+      !editing ? /* @__PURE__ */ jsxs(
+        Button,
+        {
+          onClick: () => setEditing({ id: null, form: emptyAgentForm() }),
+          "data-testid": "agent-definition-new",
+          children: [
+            /* @__PURE__ */ jsx(Icon, { icon: "mdi:plus", width: 16 }),
+            tr("fluidgrids.agents.new", "New agent")
+          ]
+        }
+      ) : null
+    ] }),
+    editing ? /* @__PURE__ */ jsx(
+      AgentEditor,
+      {
+        initial: editing.form,
+        onCancel: () => setEditing(null),
+        onSave
+      }
+    ) : null,
+    error ? /* @__PURE__ */ jsx("p", { className: "text-sm text-destructive", children: errorMessage(error) }) : null,
+    loading ? /* @__PURE__ */ jsx("p", { className: "text-sm text-text-secondary", children: tr("fluidgrids.agents.loading", "Loading agents\u2026") }) : agents.length === 0 && !error ? /* @__PURE__ */ jsx("p", { className: "text-sm text-text-secondary", children: tr("fluidgrids.agents.empty", "No agents yet.") }) : /* @__PURE__ */ jsx("ul", { className: "space-y-3", children: agents.map((agent) => /* @__PURE__ */ jsxs(
+      "li",
+      {
+        className: "rounded-lg border border-border-secondary bg-background-secondary p-3 space-y-2",
+        "data-testid": `agent-definition-${agent.id}`,
+        children: [
+          /* @__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(Icon, { icon: "mdi:robot-outline", width: 18 }),
+              /* @__PURE__ */ jsx("span", { className: "font-medium text-text-primary", children: agent.name }),
+              /* @__PURE__ */ jsx(Badge, { variant: "outline", children: agent.status }),
+              agent.requireToolApproval ? /* @__PURE__ */ jsx(Badge, { variant: "outline", children: tr(
+                "fluidgrids.agents.approvalBadge",
+                "Approval required"
+              ) }) : null
+            ] }),
+            /* @__PURE__ */ jsxs("div", { className: "flex gap-1", children: [
+              /* @__PURE__ */ jsx(
+                Button,
+                {
+                  variant: "ghost",
+                  size: "sm",
+                  onClick: () => setEditing({ id: agent.id, form: agentToForm(agent) }),
+                  children: tr("fluidgrids.agents.edit", "Edit")
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                Button,
+                {
+                  variant: "ghost",
+                  size: "sm",
+                  onClick: () => void onDelete(agent),
+                  children: tr("fluidgrids.agents.delete", "Delete")
+                }
+              )
+            ] })
+          ] }),
+          agent.description ? /* @__PURE__ */ jsx("p", { className: "text-sm text-text-secondary", children: agent.description }) : null,
+          /* @__PURE__ */ jsx("div", { className: "text-xs text-text-secondary", children: agent.toolAllowlist.length > 0 ? agent.toolAllowlist.map(describeRule).join(" \xB7 ") : tr("fluidgrids.agents.noTools", "No tools allowed") }),
+          /* @__PURE__ */ jsx("div", { className: "text-xs text-text-tertiary", children: tr(
+            "fluidgrids.agents.connectionCount",
+            "{{count}} connections in scope",
+            { count: agent.connectionScope.length }
+          ) }),
+          /* @__PURE__ */ jsx(
+            AgentGrants,
+            {
+              agent,
+              loadGrants: grants,
+              onGrant: grant,
+              onRevoke: revoke
+            }
+          )
+        ]
+      },
+      agent.id
+    )) })
+  ] });
+}
+var NONE = "__no_agent__";
+function AgentDefinitionSelectField({
+  value,
+  onChange,
+  sectionLabelClassName,
+  testIdPrefix = "ndv"
+}) {
+  const tr = useTr();
+  const { agents, loading } = useAgentDefinitionList();
+  const selected = value ? agents.find((agent) => agent.id === value) : void 0;
+  const missing = Boolean(value) && !loading && !selected;
+  return /* @__PURE__ */ jsxs(
+    "section",
+    {
+      className: "space-y-2",
+      "data-testid": `${testIdPrefix}-agent-identity`,
+      children: [
+        /* @__PURE__ */ jsx("div", { className: sectionLabelClassName, children: tr("fluidgrids.builder.agentIdentity.label", "Agent identity") }),
+        /* @__PURE__ */ jsxs(
+          Select,
+          {
+            value: value ?? NONE,
+            onValueChange: (next) => onChange(next === NONE ? null : next),
+            children: [
+              /* @__PURE__ */ jsx(
+                SelectTrigger,
+                {
+                  className: "w-full",
+                  "data-testid": `${testIdPrefix}-agent-identity-select`,
+                  children: /* @__PURE__ */ jsx(SelectValue, {})
+                }
+              ),
+              /* @__PURE__ */ jsxs(
+                SelectContent,
+                {
+                  style: { zIndex: 1100 },
+                  children: [
+                    /* @__PURE__ */ jsx(SelectItem, { value: NONE, children: tr(
+                      "fluidgrids.builder.agentIdentity.none",
+                      "None (tools run as the workflow)"
+                    ) }),
+                    agents.map((agent) => /* @__PURE__ */ jsx(
+                      SelectItem,
+                      {
+                        value: agent.id,
+                        disabled: agent.status !== "ACTIVE",
+                        children: agent.name
+                      },
+                      agent.id
+                    ))
+                  ]
+                }
+              )
+            ]
+          }
+        ),
+        selected ? /* @__PURE__ */ jsx("p", { className: "text-xs text-muted-foreground", children: selected.toolAllowlist.length > 0 ? tr(
+          "fluidgrids.builder.agentIdentity.allows",
+          "Allowed tools: {{tools}}. Each tool call needs a grant from the person the run is attributed to.",
+          { tools: selected.toolAllowlist.map(describeRule).join(" \xB7 ") }
+        ) : tr(
+          "fluidgrids.builder.agentIdentity.noTools",
+          "This agent allows no tools."
+        ) }) : null,
+        missing ? /* @__PURE__ */ jsx("p", { className: "text-xs text-destructive", children: tr(
+          "fluidgrids.builder.agentIdentity.missing",
+          "The selected agent no longer exists in this workspace; saving will be refused."
+        ) }) : null
+      ]
+    }
+  );
+}
+
+export { AgentDefinitionSelectField, AgentsTab, isAgentNodeType };