@burdenoff/fluidgrids-fe-sdk 2026.1109.9 → 2026.1110.2

package/dist/chunk-ZZBZPBO5.js

@@ -0,0 +1,1644 @@
+import { emptyAgentForm, agentToForm, describeRule, formToInput, AgentFormError, DEFAULT_GRANT_DAYS, MAX_GRANT_DAYS, grantDays } from './chunk-WZ3EJVS6.js';
+import { SdkPermissionGate, FLUIDGRIDS_PERMISSIONS } from './chunk-ERT444RG.js';
+import { replaceAdapterConnections, connectionsForAdapter, matchesAdapterProvider, newConnectionProviderKey, isOptionalAdapter } from './chunk-DDINUPO3.js';
+import { useTr } from './chunk-UULVIT25.js';
+import { getFluidGridsClient } from './chunk-PDODDDHY.js';
+import { throwIfResultError, describeOperationError } from './chunk-JKLZ6YZ3.js';
+import { getFluidGridsConfig } from './chunk-UEG2WC3G.js';
+import { useState, useCallback, useEffect, useMemo } from 'react';
+import { gql } from '@apollo/client';
+import { ConnectionDialog, ProviderIcon } from '@burdenoff/fe-libs/connections';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { Icon } from '@iconify/react';
+import { DropdownMenu, DropdownMenuTrigger, Button, DropdownMenuContent, DropdownMenuLabel, DropdownMenuItem, DropdownMenuSeparator, Badge, Select, SelectTrigger, SelectValue, SelectContent, SelectItem, Label, Input, Switch, Textarea, Checkbox } from '@burdenoff/fe-libs/ui';
+import { formatDistanceToNow } from 'date-fns';
+import { Button as Button$1 } from '@burdenoff/fe-libs/button';
+import { toast } from 'sonner';
+
+var PROVIDER_FIELDS = gql`
+  fragment ProviderFields on IntegrationProvider {
+    id
+    key
+    name
+    description
+    category
+    authType
+    icon
+    color
+    website
+    docsUrl
+    isBuiltIn
+    isEnabled
+    availableScopes
+    # How this provider can be authenticated, as data. The builder renders the
+    # form from this rather than from a per-provider React component, so a
+    # provider or a new method added by an administrator shows up here with no
+    # frontend change.
+    authMethods {
+      key
+      displayName
+      description
+      flow
+      authType
+      configSchema
+      availableScopes
+      defaultScopes
+      isConfigured
+      isEnabled
+      displayOrder
+    }
+  }
+`;
+var CONNECTION_FIELDS = gql`
+  ${PROVIDER_FIELDS}
+  fragment ConnectionFields on IntegrationConnection {
+    id
+    name
+    description
+    providerId
+    provider {
+      ...ProviderFields
+    }
+    status
+    lastHealthCheck
+    lastUsedAt
+    errorMessage
+    externalAccountId
+    externalAccountEmail
+    externalAccountName
+    grantedScopes
+    createdBy
+    createdAt
+    updatedAt
+    visibility
+    myAccess
+    canUse
+  }
+`;
+var GET_CONNECTIONS = gql`
+  ${CONNECTION_FIELDS}
+  query GetConnections(
+    $filter: ConnectionFilterInput
+    $pagination: IntegrationsPaginationInput
+  ) {
+    getConnections(filter: $filter, pagination: $pagination) {
+      items {
+        ...ConnectionFields
+      }
+      total
+      hasMore
+    }
+  }
+`;
+var GET_CONNECTION = gql`
+  ${CONNECTION_FIELDS}
+  query GetConnection($id: ID!) {
+    getConnection(id: $id) {
+      ...ConnectionFields
+    }
+  }
+`;
+var GET_CONNECTIONS_BY_PROVIDER = gql`
+  ${CONNECTION_FIELDS}
+  query GetConnectionsByProvider(
+    $providerId: ID!
+    $pagination: IntegrationsPaginationInput
+  ) {
+    getConnectionsByProvider(providerId: $providerId, pagination: $pagination) {
+      items {
+        ...ConnectionFields
+      }
+      total
+      hasMore
+    }
+  }
+`;
+var GET_PROVIDERS = gql`
+  ${PROVIDER_FIELDS}
+  query GetProviders(
+    $filter: ProviderFilterInput
+    $pagination: IntegrationsPaginationInput
+  ) {
+    getProviders(filter: $filter, pagination: $pagination) {
+      items {
+        ...ProviderFields
+      }
+      total
+      hasMore
+    }
+  }
+`;
+var INITIATE_OAUTH = gql`
+  mutation InitiateOAuth($input: InitiateOAuthInput!) {
+    initiateOAuth(input: $input) {
+      redirectUrl
+      state
+    }
+  }
+`;
+var CREATE_CONNECTION = gql`
+  ${CONNECTION_FIELDS}
+  mutation CreateConnection($input: CreateConnectionInput!) {
+    createConnection(input: $input) {
+      ...ConnectionFields
+    }
+  }
+`;
+var CONNECTIONS_PAGE_SIZE = 100;
+async function fetchAllConnectionPages(fetchPage) {
+  const items = [];
+  const seen = /* @__PURE__ */ new Set();
+  let total = 0;
+  let hasMore = false;
+  for (let offset = 0; ; offset += CONNECTIONS_PAGE_SIZE) {
+    const result = await fetchPage(offset);
+    const fresh = (result?.items ?? []).filter((item) => !seen.has(item.id));
+    for (const item of fresh) {
+      seen.add(item.id);
+      items.push(item);
+    }
+    total = result?.total ?? items.length;
+    hasMore = result?.hasMore ?? false;
+    if (!hasMore || fresh.length === 0 || items.length >= total) break;
+  }
+  return { items, total, hasMore: hasMore && items.length < total };
+}
+function useConnections(filter) {
+  const [connections, setConnections] = useState([]);
+  const [total, setTotal] = useState(0);
+  const [hasMore, setHasMore] = useState(false);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const filterKey = JSON.stringify(filter);
+  const fetchData = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const client = getFluidGridsClient();
+      const parsedFilter = filterKey ? JSON.parse(filterKey) : void 0;
+      const list = await fetchAllConnectionPages(async (offset) => {
+        const result = await client.query({
+          query: GET_CONNECTIONS,
+          variables: {
+            filter: parsedFilter,
+            pagination: { limit: CONNECTIONS_PAGE_SIZE, offset }
+          },
+          fetchPolicy: "network-only"
+        });
+        return result.data?.getConnections;
+      });
+      setConnections(list.items);
+      setTotal(list.total);
+      setHasMore(list.hasMore);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setLoading(false);
+    }
+  }, [filterKey]);
+  useEffect(() => {
+    fetchData();
+  }, [fetchData]);
+  return {
+    connections,
+    total,
+    hasMore,
+    loading,
+    error,
+    refetch: fetchData
+  };
+}
+function useConnection(connectionId) {
+  const [connection, setConnection] = useState(
+    null
+  );
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const fetchData = useCallback(async () => {
+    if (!connectionId) {
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const client = getFluidGridsClient();
+      const result = await client.query({
+        query: GET_CONNECTION,
+        variables: { id: connectionId },
+        fetchPolicy: "cache-first"
+      });
+      setConnection(result.data?.getConnection ?? null);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setLoading(false);
+    }
+  }, [connectionId]);
+  useEffect(() => {
+    fetchData();
+  }, [fetchData]);
+  return {
+    connection,
+    loading,
+    error,
+    refetch: fetchData
+  };
+}
+function useConnectionsByProvider(providerId) {
+  const [connections, setConnections] = useState([]);
+  const [total, setTotal] = useState(0);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const fetchData = useCallback(async () => {
+    if (!providerId) {
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const client = getFluidGridsClient();
+      const result = await client.query({
+        query: GET_CONNECTIONS_BY_PROVIDER,
+        variables: { providerId, pagination: { limit: 100 } },
+        fetchPolicy: "network-only"
+      });
+      setConnections(result.data?.getConnectionsByProvider?.items ?? []);
+      setTotal(result.data?.getConnectionsByProvider?.total ?? 0);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setLoading(false);
+    }
+  }, [providerId]);
+  useEffect(() => {
+    fetchData();
+  }, [fetchData]);
+  return {
+    connections,
+    total,
+    loading,
+    error,
+    refetch: fetchData
+  };
+}
+function useProviders(filter) {
+  const [providers, setProviders] = useState([]);
+  const [total, setTotal] = useState(0);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const filterKey = JSON.stringify(filter);
+  const fetchData = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const client = getFluidGridsClient();
+      const parsedFilter = filterKey ? JSON.parse(filterKey) : void 0;
+      const result = await client.query({
+        query: GET_PROVIDERS,
+        variables: {
+          filter: parsedFilter,
+          pagination: { limit: 100 }
+        },
+        fetchPolicy: "cache-first"
+      });
+      setProviders(result.data?.getProviders?.items ?? []);
+      setTotal(result.data?.getProviders?.total ?? 0);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setLoading(false);
+    }
+  }, [filterKey]);
+  useEffect(() => {
+    fetchData();
+  }, [fetchData]);
+  return {
+    providers,
+    total,
+    loading,
+    error,
+    refetch: fetchData
+  };
+}
+function useCreateConnection() {
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const createConnection = useCallback(
+    async (input) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const client = getFluidGridsClient();
+        const result = throwIfResultError(
+          await client.mutate({
+            mutation: CREATE_CONNECTION,
+            variables: { input }
+          })
+        );
+        return result.data?.createConnection ?? null;
+      } catch (err) {
+        setError(err);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    []
+  );
+  return {
+    createConnection,
+    loading,
+    error
+  };
+}
+function useInitiateOAuth() {
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const initiateOAuth = useCallback(
+    async (input) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const client = getFluidGridsClient();
+        const result = throwIfResultError(
+          await client.mutate({
+            mutation: INITIATE_OAUTH,
+            variables: { input }
+          })
+        );
+        return result.data?.initiateOAuth ?? null;
+      } catch (err) {
+        setError(err);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    []
+  );
+  return {
+    initiateOAuth,
+    loading,
+    error
+  };
+}
+
+// src/modules/connections/utils/provider-helpers.ts
+function getOAuthCallbackUrl() {
+  const path = "/integrations/oauth/callback";
+  const gatewayBase = getFluidGridsConfig().apiGatewayUrl;
+  if (gatewayBase) {
+    try {
+      return new URL(path, gatewayBase).toString();
+    } catch {
+    }
+  }
+  if (typeof window !== "undefined" && window.location.hostname === "localhost") {
+    return `http://localhost:3713${path}`;
+  }
+  if (typeof window !== "undefined") {
+    return `${window.location.origin}${path}`;
+  }
+  return path;
+}
+var SDK_CATEGORIES = {
+  cloud_storage: "CLOUD_STORAGE",
+  communication: "COMMUNICATION",
+  productivity: "PRODUCTIVITY",
+  crm: "CRM",
+  email: "EMAIL",
+  calendar: "CALENDAR",
+  developer_tools: "DEVELOPMENT",
+  social: "SOCIAL",
+  finance: "PAYMENT",
+  analytics: "ANALYTICS"
+};
+var SDK_AUTH_TYPES = {
+  oauth2: "OAUTH2",
+  api_key: "API_KEY",
+  basic_auth: "BASIC_AUTH",
+  bearer_token: "BEARER_TOKEN"
+};
+function toSdkProvider(provider) {
+  return {
+    id: provider.id,
+    key: provider.key,
+    name: provider.name,
+    description: provider.description,
+    category: SDK_CATEGORIES[provider.category] ?? "CUSTOM",
+    authType: SDK_AUTH_TYPES[provider.authType] ?? "CUSTOM",
+    icon: provider.icon,
+    website: provider.website,
+    docsUrl: provider.docsUrl,
+    isBuiltIn: true,
+    isEnabled: provider.isEnabled
+  };
+}
+function ConnectionFormDialog({
+  open,
+  onClose,
+  providerKey,
+  providerId,
+  defaultName,
+  onConnectionCreated,
+  onError
+}) {
+  const tr = useTr();
+  const handleCreated = useCallback(
+    (connection) => {
+      onConnectionCreated?.({
+        id: connection.id,
+        name: connection.name,
+        status: connection.status,
+        provider: toSdkProvider(connection.provider)
+      });
+    },
+    [onConnectionCreated]
+  );
+  return /* @__PURE__ */ jsx(
+    ConnectionDialog,
+    {
+      open,
+      onClose,
+      client: getFluidGridsClient(),
+      callbackUrl: getOAuthCallbackUrl(),
+      translate: tr,
+      providerKey: providerKey ?? null,
+      providerId: providerId ?? null,
+      providerSource: "catalog",
+      requireVault: false,
+      defaultName,
+      showSharingTab: true,
+      defaultVisibility: "RESTRICTED",
+      onConnectionCreated: handleCreated,
+      onError
+    }
+  );
+}
+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)
+  }
+`;
+var AGENTS_USING_CONNECTION = gql`
+  query AgentDefinitionsUsingConnection($connectionId: ID!) {
+    agentDefinitionsUsingConnection(connectionId: $connectionId) {
+      id
+      name
+      status
+    }
+  }
+`;
+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 };
+}
+function useAgentsUsingConnection(connectionId) {
+  const [agents, setAgents] = useState([]);
+  useEffect(() => {
+    if (!connectionId) {
+      setAgents([]);
+      return;
+    }
+    let cancelled = false;
+    getFluidGridsClient().query({
+      query: AGENTS_USING_CONNECTION,
+      variables: { connectionId },
+      fetchPolicy: "network-only"
+    }).then((result) => {
+      throwIfResultError(result);
+      if (!cancelled) {
+        setAgents(result.data?.agentDefinitionsUsingConnection ?? []);
+      }
+    }).catch(() => {
+      if (!cancelled) setAgents([]);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [connectionId]);
+  return agents;
+}
+function ConnectionAgentUsage({
+  connectionId,
+  connectionName
+}) {
+  const tr = useTr();
+  const agents = useAgentsUsingConnection(connectionId);
+  if (agents.length === 0) return null;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "flex items-start gap-1.5 text-xs text-muted-foreground",
+      "data-testid": `connection-agent-usage-${connectionId}`,
+      children: [
+        /* @__PURE__ */ jsx(Icon, { icon: "mdi:robot-outline", className: "w-3.5 h-3.5 mt-0.5 shrink-0" }),
+        /* @__PURE__ */ jsxs("span", { children: [
+          connectionName ? tr(
+            "fluidgrids.agents.usedBy.namedLabel",
+            "{{connection}} is used by agents:",
+            { connection: connectionName }
+          ) : tr("fluidgrids.agents.usedBy.label", "Used by agents:"),
+          " ",
+          agents.map(
+            (agent) => agent.status === "ACTIVE" ? agent.name : tr("fluidgrids.agents.usedBy.disabled", "{{name}} (disabled)", {
+              name: agent.name
+            })
+          ).join(", ")
+        ] })
+      ]
+    }
+  );
+}
+function formatAge(dateString) {
+  try {
+    return formatDistanceToNow(new Date(dateString), { addSuffix: true });
+  } catch {
+    return "";
+  }
+}
+function getStatusColor(status) {
+  switch (status) {
+    case "ACTIVE":
+      return "text-[var(--color-status-success-text)]";
+    case "INACTIVE":
+      return "text-text-secondary";
+    case "ERROR":
+    case "REVOKED":
+      return "text-[var(--color-status-error-text)]";
+    case "EXPIRED":
+    case "PENDING_AUTH":
+      return "text-[var(--color-status-warning-text)]";
+    default:
+      return "text-text-secondary";
+  }
+}
+function getStatusIcon(status) {
+  switch (status) {
+    case "ACTIVE":
+      return "mdi:check-circle";
+    case "INACTIVE":
+      return "mdi:pause-circle";
+    case "ERROR":
+    case "REVOKED":
+      return "mdi:alert-circle";
+    case "EXPIRED":
+      return "mdi:clock-alert";
+    case "PENDING_AUTH":
+      return "mdi:account-clock";
+    default:
+      return "mdi:help-circle";
+  }
+}
+function ConnectionChip({
+  connection,
+  connectionData,
+  onRemove
+}) {
+  const tr = useTr();
+  const name = connectionData?.name || connection.connectionId;
+  const status = connectionData?.status;
+  return /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1.5 px-2 py-1 bg-accent/30 rounded-md text-sm group", children: [
+    /* @__PURE__ */ jsx(
+      ProviderIcon,
+      {
+        variant: "bare",
+        provider: connectionData?.provider ?? {
+          key: connection.adapter,
+          icon: void 0,
+          category: "CUSTOM"
+        },
+        size: 16
+      }
+    ),
+    /* @__PURE__ */ jsx("span", { className: "truncate max-w-32", children: name }),
+    status && /* @__PURE__ */ jsx(
+      Icon,
+      {
+        icon: getStatusIcon(status),
+        className: `w-3.5 h-3.5 ${getStatusColor(status)}`
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        "aria-label": tr(
+          "fluidgrids.connections.connectionSelector.removeConnection",
+          "Remove connection"
+        ),
+        onClick: (e) => {
+          e.stopPropagation();
+          onRemove();
+        },
+        className: "text-text-secondary hover:text-status-error-text opacity-0 group-hover:opacity-100 transition-opacity",
+        children: /* @__PURE__ */ jsx(Icon, { icon: "mdi:close", className: "w-3.5 h-3.5" })
+      }
+    )
+  ] });
+}
+function ConnectionSelector(props) {
+  const connectionList = useConnections();
+  if (props.adapters.length <= 1) {
+    return /* @__PURE__ */ jsx(AdapterConnectionSelector, { ...props, connectionList });
+  }
+  return /* @__PURE__ */ jsx("div", { className: props.compact ? "space-y-2" : "space-y-3", children: props.adapters.map((adapter) => /* @__PURE__ */ jsxs("fieldset", { className: "min-w-0 space-y-1.5", children: [
+    /* @__PURE__ */ jsx("legend", { className: "text-xs font-medium text-text-secondary", children: adapter.name }),
+    /* @__PURE__ */ jsx(
+      AdapterConnectionSelector,
+      {
+        ...props,
+        adapters: [adapter],
+        selectedConnections: connectionsForAdapter(
+          props.selectedConnections,
+          adapter.name
+        ),
+        onChange: (connections) => props.onChange(
+          replaceAdapterConnections(
+            props.selectedConnections,
+            adapter.name,
+            connections.map((connection) => connection.connectionId)
+          )
+        ),
+        showRequired: false,
+        connectionList
+      }
+    )
+  ] }, adapter.name)) });
+}
+function AdapterConnectionSelector({
+  adapters,
+  selectedConnections,
+  onChange,
+  multiple = false,
+  showStatus = true,
+  compact = false,
+  showRequired = true,
+  connectionList
+}) {
+  const tr = useTr();
+  const [isDropdownOpen, setIsDropdownOpen] = useState(false);
+  const [dialogOpen, setDialogOpen] = useState(false);
+  const [dialogProviderKey, setDialogProviderKey] = useState();
+  const { connections, loading: connectionsLoading, refetch } = connectionList;
+  const availableConnections = useMemo(() => {
+    if (!adapters || adapters.length === 0) return [];
+    return connections.filter(
+      (connection) => (
+        // BOFF-9726: an admin sees everyone's private connections but cannot
+        // run workflows with them, so only usable ones are offered for a node.
+        connection.canUse !== false && adapters.some(
+          (adapter) => matchesAdapterProvider(adapter, connection.provider?.key ?? "")
+        )
+      )
+    );
+  }, [connections, adapters]);
+  const mergedConnections = useMemo(() => {
+    const allConnections = [...availableConnections];
+    selectedConnections.forEach((selected) => {
+      const existsInAvailable = availableConnections.some(
+        (c) => c.id === selected.connectionId
+      );
+      if (!existsInAvailable) {
+        const fullConn = connections.find(
+          (c) => c.id === selected.connectionId
+        );
+        if (fullConn && fullConn.canUse !== false) {
+          allConnections.push(fullConn);
+        }
+      }
+    });
+    return allConnections;
+  }, [availableConnections, selectedConnections, connections]);
+  const groupedConnections = useMemo(() => {
+    const groups = {};
+    mergedConnections.forEach((conn) => {
+      const providerName = conn.provider?.name || "Other";
+      if (!groups[providerName]) {
+        groups[providerName] = [];
+      }
+      groups[providerName].push(conn);
+    });
+    return groups;
+  }, [mergedConnections]);
+  const handleSelect = useCallback(
+    (connection) => {
+      const providerKey = connection.provider?.key || "";
+      const adapter = adapters.find(
+        (candidate) => matchesAdapterProvider(candidate, providerKey)
+      );
+      if (!adapter) return;
+      const newSelection = {
+        connectionId: connection.id,
+        adapter: adapter.name
+      };
+      if (multiple) {
+        const isSelected = selectedConnections.some(
+          (c) => c.connectionId === connection.id
+        );
+        if (isSelected) {
+          onChange(
+            selectedConnections.filter((c) => c.connectionId !== connection.id)
+          );
+        } else {
+          onChange([...selectedConnections, newSelection]);
+        }
+      } else {
+        onChange([newSelection]);
+        setIsDropdownOpen(false);
+      }
+    },
+    [adapters, selectedConnections, onChange, multiple]
+  );
+  const handleRemove = useCallback(
+    (connectionId) => {
+      onChange(
+        selectedConnections.filter((c) => c.connectionId !== connectionId)
+      );
+    },
+    [selectedConnections, onChange]
+  );
+  const handleNewConnection = useCallback((providerKey) => {
+    setDialogProviderKey(providerKey);
+    setDialogOpen(true);
+    setIsDropdownOpen(false);
+  }, []);
+  const handleConnectionCreated = useCallback(
+    (conn) => {
+      const providerKey = conn.provider?.key || "";
+      const adapter = adapters.find(
+        (candidate) => matchesAdapterProvider(candidate, providerKey)
+      );
+      if (adapter) {
+        const newSelection = { connectionId: conn.id, adapter: adapter.name };
+        if (multiple) {
+          onChange([...selectedConnections, newSelection]);
+        } else {
+          onChange([newSelection]);
+        }
+      }
+      setDialogOpen(false);
+      refetch();
+    },
+    [adapters, selectedConnections, onChange, multiple, refetch]
+  );
+  const getConnectionData = useCallback(
+    (connectionId) => connections.find((c) => c.id === connectionId),
+    [connections]
+  );
+  if (!adapters || adapters.length === 0) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs("div", { className: compact ? "space-y-2" : "space-y-3", children: [
+    selectedConnections.length > 0 && /* @__PURE__ */ jsx("div", { className: "flex flex-wrap gap-1.5", children: selectedConnections.map((conn) => {
+      const connData = getConnectionData(conn.connectionId);
+      return /* @__PURE__ */ jsx(
+        ConnectionChip,
+        {
+          connection: conn,
+          connectionData: connData,
+          onRemove: () => handleRemove(conn.connectionId)
+        },
+        conn.connectionId
+      );
+    }) }),
+    selectedConnections.map((conn) => /* @__PURE__ */ jsx(
+      ConnectionAgentUsage,
+      {
+        connectionId: conn.connectionId,
+        connectionName: selectedConnections.length > 1 ? getConnectionData(conn.connectionId)?.name : null
+      },
+      `agents-${conn.connectionId}`
+    )),
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+      /* @__PURE__ */ jsxs(DropdownMenu, { open: isDropdownOpen, onOpenChange: setIsDropdownOpen, children: [
+        /* @__PURE__ */ jsx(DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ jsxs(
+          Button,
+          {
+            variant: "outline",
+            size: compact ? "sm" : "default",
+            className: "justify-between min-w-[200px]",
+            children: [
+              /* @__PURE__ */ jsxs("span", { className: "flex items-center gap-2", children: [
+                /* @__PURE__ */ jsx(
+                  Icon,
+                  {
+                    icon: "mdi:link-variant",
+                    className: "w-4 h-4 text-text-secondary"
+                  }
+                ),
+                selectedConnections.length === 0 ? tr(
+                  "fluidgrids.connections.connectionSelector.selectConnection",
+                  "Select connection"
+                ) : multiple ? `${selectedConnections.length} selected` : tr(
+                  "fluidgrids.connections.connectionSelector.changeConnection",
+                  "Change connection"
+                )
+              ] }),
+              /* @__PURE__ */ jsx(
+                Icon,
+                {
+                  icon: "mdi:chevron-down",
+                  className: "w-4 h-4 text-text-secondary"
+                }
+              )
+            ]
+          }
+        ) }),
+        /* @__PURE__ */ jsxs(
+          DropdownMenuContent,
+          {
+            align: "start",
+            style: { zIndex: 1100 },
+            className: "w-[280px] max-h-[400px] overflow-y-auto",
+            children: [
+              connectionsLoading ? /* @__PURE__ */ jsxs("div", { className: "p-4 text-center text-sm text-text-secondary", children: [
+                /* @__PURE__ */ jsx(
+                  Icon,
+                  {
+                    icon: "mdi:loading",
+                    className: "w-6 h-6 mx-auto mb-2 animate-spin"
+                  }
+                ),
+                /* @__PURE__ */ jsx("p", { children: tr(
+                  "fluidgrids.connections.connectionSelector.loading",
+                  "Loading connections..."
+                ) })
+              ] }) : Object.keys(groupedConnections).length === 0 ? /* @__PURE__ */ jsxs("div", { className: "p-4 text-center text-sm text-text-secondary", children: [
+                /* @__PURE__ */ jsx(
+                  Icon,
+                  {
+                    icon: "mdi:link-off",
+                    className: "w-8 h-8 mx-auto mb-2 opacity-50"
+                  }
+                ),
+                /* @__PURE__ */ jsx("p", { children: tr(
+                  "fluidgrids.connections.connectionSelector.emptyTitle",
+                  "No matching connections"
+                ) }),
+                /* @__PURE__ */ jsx("p", { className: "text-xs mt-1", children: tr(
+                  "fluidgrids.connections.connectionSelector.emptyHint",
+                  "Create one in Integrations"
+                ) })
+              ] }) : Object.entries(groupedConnections).map(
+                ([providerName, conns]) => /* @__PURE__ */ jsxs("div", { children: [
+                  /* @__PURE__ */ jsxs(DropdownMenuLabel, { className: "flex items-center gap-2 text-xs font-semibold text-text-secondary uppercase tracking-wide", children: [
+                    /* @__PURE__ */ jsx(
+                      ProviderIcon,
+                      {
+                        variant: "bare",
+                        provider: conns[0]?.provider ?? {
+                          key: "generic",
+                          icon: void 0,
+                          category: "CUSTOM"
+                        },
+                        size: 16
+                      }
+                    ),
+                    providerName
+                  ] }),
+                  conns.map((conn) => {
+                    const isSelected = selectedConnections.some(
+                      (c) => c.connectionId === conn.id
+                    );
+                    const isActive = conn.status === "ACTIVE";
+                    return /* @__PURE__ */ jsxs(
+                      DropdownMenuItem,
+                      {
+                        onSelect: (event) => {
+                          if (multiple) event.preventDefault();
+                          handleSelect(conn);
+                        },
+                        className: `flex items-center justify-between cursor-pointer ${isSelected ? "bg-action-primary-bg/10" : ""} ${!isActive ? "opacity-60" : ""}`,
+                        children: [
+                          /* @__PURE__ */ jsxs("div", { className: "flex flex-col min-w-0", children: [
+                            /* @__PURE__ */ jsxs("span", { className: "font-medium truncate flex items-center gap-1.5", children: [
+                              conn.name,
+                              showStatus && /* @__PURE__ */ jsx("span", { title: conn.status, children: /* @__PURE__ */ jsx(
+                                Icon,
+                                {
+                                  icon: getStatusIcon(conn.status),
+                                  className: `w-3.5 h-3.5 ${getStatusColor(conn.status)}`
+                                }
+                              ) })
+                            ] }),
+                            /* @__PURE__ */ jsx("span", { className: "text-xs text-text-secondary", children: conn.externalAccountEmail || conn.updatedAt && `Updated ${formatAge(conn.updatedAt)}` })
+                          ] }),
+                          isSelected && /* @__PURE__ */ jsx(
+                            Icon,
+                            {
+                              icon: "mdi:check",
+                              className: "w-4 h-4 text-primary flex-shrink-0"
+                            }
+                          )
+                        ]
+                      },
+                      conn.id
+                    );
+                  }),
+                  /* @__PURE__ */ jsx(DropdownMenuSeparator, {})
+                ] }, providerName)
+              ),
+              /* @__PURE__ */ jsx(
+                SdkPermissionGate,
+                {
+                  permission: FLUIDGRIDS_PERMISSIONS.INTEGRATION_CONNECTION_CREATE,
+                  children: /* @__PURE__ */ jsxs(
+                    DropdownMenuItem,
+                    {
+                      onClick: () => {
+                        handleNewConnection(newConnectionProviderKey(adapters));
+                      },
+                      className: "text-primary cursor-pointer",
+                      children: [
+                        /* @__PURE__ */ jsx(Icon, { icon: "mdi:plus", className: "w-4 h-4 mr-2" }),
+                        tr(
+                          "fluidgrids.connections.connectionSelector.newConnection",
+                          "New connection"
+                        )
+                      ]
+                    }
+                  )
+                }
+              )
+            ]
+          }
+        )
+      ] }),
+      selectedConnections.length === 0 && !compact && /* @__PURE__ */ jsx(
+        SdkPermissionGate,
+        {
+          permission: FLUIDGRIDS_PERMISSIONS.INTEGRATION_CONNECTION_CREATE,
+          children: /* @__PURE__ */ jsxs(
+            Button,
+            {
+              variant: "ghost",
+              size: "sm",
+              onClick: () => handleNewConnection(newConnectionProviderKey(adapters)),
+              className: "text-primary hover:text-primary/80",
+              children: [
+                /* @__PURE__ */ jsx(Icon, { icon: "mdi:plus", className: "w-4 h-4 mr-1" }),
+                tr("fluidgrids.connections.connectionSelector.new", "New")
+              ]
+            }
+          )
+        }
+      )
+    ] }),
+    showStatus && showRequired && selectedConnections.length === 0 && adapters.some((adapter) => !isOptionalAdapter(adapter)) && /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1.5 text-xs text-[var(--color-status-warning-text)]", children: [
+      /* @__PURE__ */ jsx(Icon, { icon: "mdi:alert-circle", className: "w-3.5 h-3.5" }),
+      /* @__PURE__ */ jsx("span", { children: tr(
+        "fluidgrids.connections.connectionSelector.connectionRequired",
+        "Connection required for this node"
+      ) })
+    ] }),
+    /* @__PURE__ */ jsx(
+      ConnectionFormDialog,
+      {
+        open: dialogOpen,
+        onClose: () => setDialogOpen(false),
+        providerKey: dialogProviderKey,
+        onConnectionCreated: handleConnectionCreated
+      }
+    )
+  ] });
+}
+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$1,
+                  {
+                    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$1,
+            {
+              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$1,
+            {
+              onClick: () => void submit(),
+              disabled: busy,
+              "data-testid": "agent-definition-save",
+              children: tr("fluidgrids.agents.save", "Save agent")
+            }
+          ),
+          /* @__PURE__ */ jsx(Button$1, { 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$1,
+        {
+          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$1,
+        {
+          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$1,
+        {
+          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$1,
+        {
+          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$1,
+                {
+                  variant: "ghost",
+                  size: "sm",
+                  onClick: () => setEditing({ id: agent.id, form: agentToForm(agent) }),
+                  children: tr("fluidgrids.agents.edit", "Edit")
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                Button$1,
+                {
+                  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, ConnectionFormDialog, ConnectionSelector, useConnection, useConnections, useConnectionsByProvider, useCreateConnection, useInitiateOAuth, useProviders };