@burdenoff/fluidgrids-fe-sdk 2026.1104.3 → 2026.1105.2

package/dist/chunk-US5QSLPV.js

@@ -0,0 +1,316 @@
+import { getFluidGridsTokenRevision, config, setFluidGridsConfig } from './chunk-UEG2WC3G.js';
+import { CombinedGraphQLErrors, ServerError } from '@apollo/client/errors';
+import { ApolloLink, Observable } from '@apollo/client/core';
+
+// src/graphql/live-tokens.ts
+function createLiveTokenReader(initial) {
+  const createdAt = getFluidGridsTokenRevision();
+  return () => {
+    if (getFluidGridsTokenRevision() === createdAt) return initial;
+    return {
+      authToken: config.authToken ?? initial.authToken,
+      workspaceToken: config.workspaceToken ?? initial.workspaceToken
+    };
+  };
+}
+function describeGraphQLError(error) {
+  const code = typeof error.extensions?.code === "string" ? error.extensions.code : void 0;
+  switch (code) {
+    case "QUOTA_EXHAUSTED": {
+      const quota = /Quota exhausted for (\S+)/.exec(error.message)?.[1];
+      const allowance = quota ? `"${quota}" quota` : "usage quota";
+      return `Quota exhausted \u2014 your workspace has used up its ${allowance}. Upgrade your plan or wait for the quota to reset.`;
+    }
+    case "QUOTA_NOT_PROVISIONED":
+      return "This workspace's plan does not include this usage allowance yet. Contact your workspace admin or support to have it provisioned.";
+    case "UNAUTHENTICATED":
+      return "Your session has expired. Please sign in again.";
+    case "FORBIDDEN":
+      return error.message || "You don't have permission to perform this action.";
+    default:
+      return error.message || "Unknown error";
+  }
+}
+function firstGraphQLErrorInBody(bodyText) {
+  try {
+    const parsed = JSON.parse(bodyText);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const errors = parsed.errors;
+    if (!Array.isArray(errors) || errors.length === 0) return null;
+    const first = errors[0];
+    if (typeof first !== "object" || first === null) return null;
+    const message = first.message;
+    if (typeof message !== "string") return null;
+    return first;
+  } catch {
+    return null;
+  }
+}
+function describeOperationError(error, fallback = "Unknown error") {
+  if (CombinedGraphQLErrors.is(error)) {
+    const first = error.errors[0];
+    return first ? describeGraphQLError(first) : error.message || fallback;
+  }
+  if (ServerError.is(error)) {
+    const first = firstGraphQLErrorInBody(error.bodyText);
+    if (first) return describeGraphQLError(first);
+  }
+  if (error instanceof Error) {
+    return error.message || fallback;
+  }
+  if (typeof error === "string" && error.length > 0) {
+    return error;
+  }
+  return fallback;
+}
+function throwIfResultError(result) {
+  if (result.error) {
+    throw new Error(describeOperationError(result.error), {
+      cause: result.error
+    });
+  }
+  return result;
+}
+function hasForbiddenCode(errors) {
+  return (errors ?? []).some((error) => error.extensions?.code === "FORBIDDEN");
+}
+function isForbiddenError(error) {
+  if (CombinedGraphQLErrors.is(error)) {
+    return hasForbiddenCode(error.errors);
+  }
+  if (ServerError.is(error)) {
+    if (error.statusCode === 403) return true;
+    const first = firstGraphQLErrorInBody(error.bodyText);
+    return first ? hasForbiddenCode([first]) : false;
+  }
+  if (error instanceof Error && error.cause !== void 0) {
+    return isForbiddenError(error.cause);
+  }
+  return false;
+}
+var REFRESHABLE_AUTH_FAILURES = /* @__PURE__ */ new Set([
+  "CREDENTIAL_EXPIRED",
+  "CREDENTIAL_REVOKED"
+]);
+var EXPIRED_TOKEN_MESSAGE = /\b(?:jwt|token)\b[^.]{0,40}\bexpired\b|\bexpired\b[^.]{0,20}\b(?:jwt|token)\b/i;
+function isUnauthenticatedGraphQLError(error) {
+  const code = error.extensions?.code;
+  if (code === "UNAUTHENTICATED") return true;
+  const authFailure = error.extensions?.authFailure;
+  if (typeof authFailure === "string" && REFRESHABLE_AUTH_FAILURES.has(authFailure)) {
+    return true;
+  }
+  return typeof error.message === "string" && EXPIRED_TOKEN_MESSAGE.test(error.message);
+}
+function hasUnauthenticatedGraphQLError(errors) {
+  return (errors ?? []).some(isUnauthenticatedGraphQLError);
+}
+function isUnauthenticatedError(error) {
+  if (CombinedGraphQLErrors.is(error)) {
+    return hasUnauthenticatedGraphQLError(error.errors);
+  }
+  if (ServerError.is(error)) {
+    if (error.statusCode === 401) return true;
+    const first = firstGraphQLErrorInBody(error.bodyText);
+    return first ? isUnauthenticatedGraphQLError(first) : false;
+  }
+  if (error instanceof Error && error.cause !== void 0) {
+    return isUnauthenticatedError(error.cause);
+  }
+  return false;
+}
+function operationErrorCode(error) {
+  const codeOf = (graphQLError) => {
+    const code = graphQLError?.extensions?.code;
+    return typeof code === "string" ? code : void 0;
+  };
+  if (CombinedGraphQLErrors.is(error)) return codeOf(error.errors[0]);
+  if (ServerError.is(error)) {
+    return codeOf(firstGraphQLErrorInBody(error.bodyText) ?? void 0);
+  }
+  if (error instanceof Error && error.cause !== void 0) {
+    return operationErrorCode(error.cause);
+  }
+  return void 0;
+}
+
+// src/events/eventBus.ts
+var FLUIDGRIDS_EVENTS_VERSION = "1.0.0";
+var FLUIDGRIDS_EVENT_NAMES = [
+  "workflow:saved",
+  "workflow:activated",
+  "run:started",
+  "run:completed",
+  "node:selected",
+  "error",
+  "auth:failed"
+];
+function withoutUndefined(payload) {
+  return Object.fromEntries(
+    Object.entries(payload).filter(([, value]) => value !== void 0)
+  );
+}
+function emitFluidGridsEvent(name, payload) {
+  let handler;
+  try {
+    handler = config.onEvent;
+  } catch {
+    return;
+  }
+  if (typeof handler !== "function") return;
+  try {
+    const args = [name, withoutUndefined(payload)];
+    handler(...args);
+  } catch (error) {
+    console.warn(`[FluidGrids SDK] onEvent handler failed for ${name}`, error);
+  }
+}
+function emitOperationErrorEvent(source, error) {
+  emitFluidGridsEvent("error", {
+    source,
+    message: describeOperationError(error),
+    code: operationErrorCode(error)
+  });
+}
+var MAX_COMPLETED_RUNS = 500;
+var completedRuns = /* @__PURE__ */ new Set();
+function emitRunCompletedOnce(payload) {
+  if (!payload.runId || completedRuns.has(payload.runId)) return;
+  completedRuns.add(payload.runId);
+  if (completedRuns.size > MAX_COMPLETED_RUNS) {
+    const oldest = completedRuns.values().next().value;
+    if (oldest !== void 0) completedRuns.delete(oldest);
+  }
+  emitFluidGridsEvent("run:completed", payload);
+}
+var inFlight = null;
+var refreshGeneration = 0;
+var lastRefreshed = null;
+function normalizeTokens(value) {
+  if (typeof value === "string") {
+    return value.trim() ? { authToken: value } : null;
+  }
+  if (!value || typeof value !== "object") return null;
+  const tokens = {};
+  if (typeof value.authToken === "string" && value.authToken.trim()) {
+    tokens.authToken = value.authToken;
+  }
+  if (typeof value.workspaceToken === "string" && value.workspaceToken.trim()) {
+    tokens.workspaceToken = value.workspaceToken;
+  }
+  return tokens.authToken || tokens.workspaceToken ? tokens : null;
+}
+function storeInConfig(tokens) {
+  setFluidGridsConfig(tokens);
+}
+function refreshTokens(callback, store) {
+  if (inFlight) return inFlight;
+  const run = (async () => {
+    try {
+      const tokens = normalizeTokens(await callback());
+      if (!tokens) {
+        emitFluidGridsEvent("auth:failed", {
+          message: "onTokenExpired returned no token."
+        });
+        return null;
+      }
+      store(tokens);
+      refreshGeneration += 1;
+      lastRefreshed = tokens;
+      return tokens;
+    } catch (error) {
+      emitFluidGridsEvent("auth:failed", {
+        message: describeOperationError(error, "Token refresh failed.")
+      });
+      return null;
+    }
+  })();
+  inFlight = run;
+  void run.finally(() => {
+    if (inFlight === run) inFlight = null;
+  });
+  return run;
+}
+function withTokenHeaders(headers, tokens) {
+  return {
+    ...headers,
+    ...tokens.authToken && { authorization: `Bearer ${tokens.authToken}` },
+    ...tokens.workspaceToken && {
+      "x-workspace-authorization": `Bearer ${tokens.workspaceToken}`
+    }
+  };
+}
+function resultIsUnauthenticated(result) {
+  return hasUnauthenticatedGraphQLError(result.errors);
+}
+function createFluidGridsTokenRefreshLink(options = {}) {
+  return new ApolloLink((operation, forward) => {
+    const store = options.onTokenRefreshed ?? storeInConfig;
+    return new Observable((observer) => {
+      const sentInGeneration = refreshGeneration;
+      let retried = false;
+      let closed = false;
+      let current = null;
+      const retryOrFail = (fail) => {
+        const callback = options.onTokenExpired ?? config.auth?.onTokenExpired;
+        if (!callback) return false;
+        retried = true;
+        current?.unsubscribe();
+        current = null;
+        const refreshed = refreshGeneration !== sentInGeneration && lastRefreshed ? Promise.resolve(lastRefreshed) : refreshTokens(callback, store);
+        void refreshed.then((tokens) => {
+          if (closed) return;
+          if (!tokens) {
+            fail();
+            return;
+          }
+          const context = operation.getContext();
+          const headers = context.headers;
+          operation.setContext({
+            headers: withTokenHeaders(
+              headers && typeof headers === "object" ? (
+                // Apollo keeps request headers as a plain string map.
+                headers
+              ) : void 0,
+              tokens
+            )
+          });
+          subscribe();
+        });
+        return true;
+      };
+      const subscribe = () => {
+        let refreshing = false;
+        current = forward(operation).subscribe({
+          next: (result) => {
+            if (!retried && resultIsUnauthenticated(result) && retryOrFail(() => {
+              observer.next(result);
+              observer.complete();
+            })) {
+              refreshing = true;
+              return;
+            }
+            observer.next(result);
+          },
+          error: (error) => {
+            if (!retried && isUnauthenticatedError(error) && retryOrFail(() => observer.error(error))) {
+              refreshing = true;
+              return;
+            }
+            observer.error(error);
+          },
+          complete: () => {
+            if (!refreshing) observer.complete();
+          }
+        });
+      };
+      subscribe();
+      return () => {
+        closed = true;
+        current?.unsubscribe();
+      };
+    });
+  });
+}
+
+export { FLUIDGRIDS_EVENTS_VERSION, FLUIDGRIDS_EVENT_NAMES, createFluidGridsTokenRefreshLink, createLiveTokenReader, describeOperationError, emitFluidGridsEvent, emitOperationErrorEvent, emitRunCompletedOnce, isForbiddenError, isUnauthenticatedError, throwIfResultError };

package/dist/{chunk-5UHAB75U.js → chunk-W5WML3OO.js}

@@ -1,4 +1,4 @@
-import { resolveInputHandles } from './chunk-AAIZ6S6E.js';
+import { resolveInputHandles } from './chunk-3QCRKKTI.js';
 
 // src/builder/hooks/attach-node-helpers.ts
 var ATTACH_GAP_X = 120;

package/dist/chunk-WZ3EJVS6.js

@@ -0,0 +1,93 @@
+// 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");
+}
+
+export { AgentFormError, DEFAULT_GRANT_DAYS, MAX_GRANT_DAYS, agentToForm, describeRule, emptyAgentForm, formToInput, grantDays, isAgentNodeType };

package/dist/{chunk-Q72EOY4T.js → chunk-X25NCWG2.js}

@@ -1,8 +1,8 @@
-import { Card, FluidGridsMark } from './chunk-DFIX6YWP.js';
+import { Card, FluidGridsMark } from './chunk-62CCBMDC.js';
 import { Input } from './chunk-IEVSFCFS.js';
 import { Button } from './chunk-BQXVT32O.js';
-import { useWorkflowDefinition } from './chunk-AFX3EKFN.js';
-import { FluidGridsProvider, useFlowStore } from './chunk-AAIZ6S6E.js';
+import { useWorkflowDefinition } from './chunk-QFGZXWTM.js';
+import { FluidGridsProvider, useFlowStore } from './chunk-3QCRKKTI.js';
 import { cn } from './chunk-JL7CASN5.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { useState, useRef, useEffect, useCallback } from 'react';
@@ -494,6 +494,9 @@ function WorkflowBuilder({
   organizationId,
   workspaceClient,
   globalClient,
+  theme,
+  auth,
+  onEvent,
   ...coreProps
 }) {
   const workflow = initialWorkflow || createDefaultWorkflow(workflowId, workflowVersion);
@@ -511,6 +514,9 @@ function WorkflowBuilder({
       organizationId,
       workspaceClient,
       globalClient,
+      theme,
+      auth,
+      onEvent,
       children: /* @__PURE__ */ jsx(WorkflowBuilderCore, { workflow, ...coreProps })
     }
   );

package/dist/{chunk-VDJFTZ2H.js → chunk-XFH6SLDK.js}

@@ -1,5 +1,7 @@
-import { useAgentDefinitions, useAgentDefinitionList, useConnections, describeOperationError } from './chunk-AAIZ6S6E.js';
+import { emptyAgentForm, agentToForm, describeRule, formToInput, AgentFormError, DEFAULT_GRANT_DAYS, MAX_GRANT_DAYS, grantDays } from './chunk-WZ3EJVS6.js';
+import { useAgentDefinitions, useAgentDefinitionList, useConnections } from './chunk-3QCRKKTI.js';
 import { useTr } from './chunk-UULVIT25.js';
+import { describeOperationError } from './chunk-US5QSLPV.js';
 import { useState, useCallback, useEffect } from 'react';
 import { Icon } from '@iconify/react';
 import { Button } from '@burdenoff/fe-libs/button';
@@ -7,97 +9,6 @@ import { Badge, Select, SelectTrigger, SelectValue, SelectContent, SelectItem, L
 import { toast } from 'sonner';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
 
-// 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);
@@ -587,4 +498,4 @@ function AgentDefinitionSelectField({
   );
 }
 
-export { AgentDefinitionSelectField, AgentsTab, isAgentNodeType };
+export { AgentDefinitionSelectField, AgentsTab };

package/dist/{chunk-TBHAZK52.js → chunk-Y6M7K4UG.js}

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