@rafads/plugin-openapi 1.5.38

package/README.md

@@ -0,0 +1,83 @@
+# @rafads/plugin-openapi
+
+Load [OpenAPI](https://www.openapis.org/) specifications into an executor. Every operation in the spec becomes an invokable tool with a JSON-Schema input, automatic request building, and optional secret-backed auth.
+
+## Install
+
+```sh
+bun add @rafads/sdk @rafads/plugin-openapi
+# or
+npm install @rafads/sdk @rafads/plugin-openapi
+```
+
+## Usage
+
+```ts
+import { createExecutor } from "@rafads/sdk";
+import { openApiPlugin } from "@rafads/plugin-openapi";
+
+const executor = await createExecutor({
+  onElicitation: "accept-all",
+  plugins: [openApiPlugin()] as const,
+});
+
+// Load a spec by URL (JSON or YAML, remote or file://)
+await executor.openapi.addSpec({
+  scope: executor.scopes[0]!.id,
+  spec: "https://petstore3.swagger.io/api/v3/openapi.json",
+  namespace: "petstore",
+});
+
+// List and invoke tools like any other plugin
+const tools = await executor.tools.list();
+const result = await executor.tools.invoke("petstore.listPets", {});
+```
+
+## Secret-backed auth headers
+
+Wire API keys or bearer tokens through the executor's secret store — never hard-code them in integration configs:
+
+```ts
+import { createExecutor } from "@rafads/sdk";
+import { openApiPlugin } from "@rafads/plugin-openapi";
+import { fileSecretsPlugin } from "@rafads/plugin-file-secrets";
+
+const executor = await createExecutor({
+  onElicitation: "accept-all",
+  plugins: [fileSecretsPlugin(), openApiPlugin()] as const,
+});
+
+const scope = executor.scopes[0]!.id;
+
+await executor.secrets.set({
+  id: "stripe-key",
+  name: "Stripe Key",
+  value: "sk_live_...",
+  scope,
+});
+
+await executor.openapi.addSpec({
+  scope,
+  spec: "https://raw.githubusercontent.com/stripe/openapi/master/openapi/spec3.json",
+  namespace: "stripe",
+  headers: {
+    Authorization: { secretId: "stripe-key", prefix: "Bearer " },
+  },
+});
+```
+
+## Using with Effect
+
+If you're building on `@rafads/sdk/core` (the raw Effect entry), import this plugin from its `/core` subpath instead — it returns the Effect-shaped plugin with `Effect.Effect<...>`-returning methods rather than promisified wrappers:
+
+```ts
+import { openApiPlugin } from "@rafads/plugin-openapi/core";
+```
+
+## Status
+
+Pre-`1.0`. APIs may still change between beta releases. Part of the [executor monorepo](https://github.com/UsefulSoftwareCo/executor).
+
+## License
+
+MIT

package/dist/AddOpenApiIntegration-JPAEXE56.js

@@ -0,0 +1,512 @@
+import {
+  authenticationFromEditorValue,
+  editorValueFromAuthentication,
+  openApiWireAuthInput
+} from "./chunk-IG6QTTZB.js";
+import {
+  detectedAuthenticationTemplates
+} from "./chunk-O2LMSZ2Z.js";
+import {
+  addOpenApiSpec,
+  previewOpenApiSpec
+} from "./chunk-6V45G2XQ.js";
+import {
+  resolveServerUrl
+} from "./chunk-HTHEUUJA.js";
+import "./chunk-R7TVM3XD.js";
+import "./chunk-CXFO6TLJ.js";
+
+// src/react/AddOpenApiIntegration.tsx
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useAtomSet } from "@effect/atom-react";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Option from "effect/Option";
+import {
+  AuthTemplateSlug
+} from "@rafads/sdk/shared";
+import { useIntegrationPlugins } from "@rafads/sdk/client";
+import { integrationWriteKeys, healthCheckWriteKeys } from "@rafads/react/api/reactivity-keys";
+import { setIntegrationHealthCheck } from "@rafads/react/api/atoms";
+import {
+  slugifyNamespace,
+  useIntegrationIdentity
+} from "@rafads/react/plugins/integration-identity";
+import { Button } from "@rafads/react/components/button";
+import { HealthCheckConfigFields } from "@rafads/react/components/health-check-editor";
+import {
+  AuthMethodListEditor,
+  useAuthMethodList
+} from "@rafads/react/components/auth-method-list-editor";
+import { CardStack as CardStack2, CardStackContent as CardStackContent2 } from "@rafads/react/components/card-stack";
+import { FieldLabel } from "@rafads/react/components/field";
+import { FloatActions } from "@rafads/react/components/float-actions";
+import { Textarea as Textarea2 } from "@rafads/react/components/textarea";
+import { IOSSpinner } from "@rafads/react/components/spinner";
+import {
+  addIntegrationErrorMessage,
+  errorMessageFromExit,
+  FormErrorAlert,
+  SlugCollisionAlert,
+  useSlugAlreadyExists
+} from "@rafads/react/lib/integration-add";
+
+// src/react/OpenApiIntegrationDetailsFields.tsx
+import {
+  CardStack,
+  CardStackContent,
+  CardStackEntry,
+  CardStackEntryContent,
+  CardStackEntryDescription,
+  CardStackEntryField,
+  CardStackEntryTitle
+} from "@rafads/react/components/card-stack";
+import { FreeformCombobox } from "@rafads/react/components/combobox";
+import { Input } from "@rafads/react/components/input";
+import { Textarea } from "@rafads/react/components/textarea";
+import { IntegrationFavicon } from "@rafads/react/components/integration-favicon";
+import {
+  IntegrationIdentityFieldRows
+} from "@rafads/react/plugins/integration-identity";
+import { jsx, jsxs } from "react/jsx-runtime";
+var isUrlInput = (value) => URL.canParse(value.trim());
+function OpenApiIntegrationDetailsFields(props) {
+  const specIsUrl = props.specUrl !== void 0 && isUrlInput(props.specUrl);
+  return /* @__PURE__ */ jsx(CardStack, { children: /* @__PURE__ */ jsxs(CardStackContent, { className: "border-t-0", children: [
+    /* @__PURE__ */ jsxs(CardStackEntry, { children: [
+      (props.faviconIcon || props.faviconUrl) && /* @__PURE__ */ jsx(IntegrationFavicon, { icon: props.faviconIcon, url: props.faviconUrl, size: 16 }),
+      /* @__PURE__ */ jsxs(CardStackEntryContent, { children: [
+        /* @__PURE__ */ jsx(CardStackEntryTitle, { children: props.title }),
+        props.subtitle && /* @__PURE__ */ jsx(CardStackEntryDescription, { children: props.subtitle })
+      ] }),
+      props.saveState && props.saveState !== "idle" && /* @__PURE__ */ jsx("span", { className: "text-xs text-muted-foreground", children: props.saveState === "saving" ? "Saving\u2026" : "Saved" })
+    ] }),
+    /* @__PURE__ */ jsx(
+      IntegrationIdentityFieldRows,
+      {
+        identity: props.identity,
+        namespaceReadOnly: props.namespaceReadOnly
+      }
+    ),
+    props.onDescriptionChange && /* @__PURE__ */ jsx(CardStackEntryField, { label: "Description", children: /* @__PURE__ */ jsx(
+      Textarea,
+      {
+        value: props.description ?? "",
+        onChange: (e) => props.onDescriptionChange?.(e.target.value),
+        placeholder: "What this API is and when to reach for it",
+        rows: 2,
+        maxRows: 6,
+        className: "text-sm"
+      }
+    ) }),
+    /* @__PURE__ */ jsxs("div", { className: "grid grid-cols-1 md:grid-cols-2", children: [
+      /* @__PURE__ */ jsxs(CardStackEntryField, { label: props.baseUrlLabel ?? "Base URL", children: [
+        props.baseUrlOptions && props.baseUrlOptions.length > 0 ? /* @__PURE__ */ jsx(
+          FreeformCombobox,
+          {
+            value: props.baseUrl,
+            onValueChange: props.onBaseUrlChange,
+            options: props.baseUrlOptions,
+            placeholder: props.baseUrlPlaceholder ?? "https://api.example.com",
+            className: "w-full",
+            inputClassName: "font-mono text-sm"
+          }
+        ) : /* @__PURE__ */ jsx(
+          Input,
+          {
+            value: props.baseUrl,
+            onChange: (e) => props.onBaseUrlChange(e.target.value),
+            placeholder: props.baseUrlPlaceholder ?? "https://api.example.com",
+            className: "font-mono text-sm"
+          }
+        ),
+        props.baseUrlMissingMessage && !props.baseUrl && /* @__PURE__ */ jsx("p", { className: "text-[11px] text-muted-foreground", children: props.baseUrlMissingMessage }),
+        props.baseUrlHint && /* @__PURE__ */ jsx("p", { className: "text-[11px] text-muted-foreground", children: props.baseUrlHint })
+      ] }),
+      specIsUrl && props.onSpecUrlChange && /* @__PURE__ */ jsx(CardStackEntryField, { label: "Spec URL", children: /* @__PURE__ */ jsx(
+        Input,
+        {
+          value: props.specUrl,
+          onChange: (e) => props.onSpecUrlChange?.(e.target.value),
+          placeholder: "https://api.example.com/openapi.json",
+          className: "font-mono text-sm",
+          disabled: props.specUrlDisabled
+        }
+      ) })
+    ] }),
+    props.specUrl !== void 0 && !specIsUrl && props.onSpecUrlChange && /* @__PURE__ */ jsx(CardStackEntryField, { label: "Spec", children: /* @__PURE__ */ jsx(
+      Textarea,
+      {
+        value: props.specUrl,
+        onChange: (e) => props.onSpecUrlChange?.(e.target.value),
+        placeholder: "Pasted OpenAPI JSON/YAML",
+        rows: 4,
+        maxRows: 12,
+        className: "font-mono text-xs",
+        disabled: props.specUrlDisabled
+      }
+    ) }),
+    props.footer && /* @__PURE__ */ jsx(CardStackEntry, { children: /* @__PURE__ */ jsx(CardStackEntryContent, { children: /* @__PURE__ */ jsx(CardStackEntryTitle, { children: props.footer }) }) })
+  ] }) });
+}
+
+// src/react/AddOpenApiIntegration.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var normalizePresetUrl = (url) => {
+  const trimmed = url.trim();
+  if (!URL.canParse(trimmed)) return trimmed.replace(/\/$/, "");
+  const parsed = new URL(trimmed);
+  parsed.hash = "";
+  parsed.searchParams.sort();
+  return parsed.toString().replace(/\/$/, "");
+};
+var specInputForAdd = (input) => {
+  const value = input.trim();
+  const parsed = Effect.runSyncExit(
+    Effect.try({
+      try: () => new URL(value),
+      catch: () => null
+    })
+  );
+  return Exit.isSuccess(parsed) ? { kind: "url", url: value } : { kind: "blob", value };
+};
+var baseUrlFromSpecInput = (input) => {
+  const value = input.trim();
+  if (!URL.canParse(value)) return "";
+  const parsed = new URL(value);
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return "";
+  return parsed.origin;
+};
+var openApiPreviewFailureMessage = (message) => `Couldn't load or parse this spec: ${message && message.trim().length > 0 ? message : "unknown error"}`;
+function AddOpenApiHealthCheckSection(props) {
+  if (props.presetHealthCheck) {
+    return /* @__PURE__ */ jsxs2("section", { className: "space-y-2", children: [
+      /* @__PURE__ */ jsx2("h3", { className: "text-sm font-medium text-foreground", children: "Health check" }),
+      /* @__PURE__ */ jsxs2("p", { className: "text-[11px] text-muted-foreground", children: [
+        /* @__PURE__ */ jsx2("span", { className: "font-mono text-foreground", children: props.presetHealthCheck.operation }),
+        " ",
+        "From the catalog. Change it later from the integration page."
+      ] })
+    ] });
+  }
+  if (props.candidates.length === 0) return null;
+  return /* @__PURE__ */ jsxs2("section", { className: "space-y-4", children: [
+    /* @__PURE__ */ jsxs2("div", { className: "space-y-1", children: [
+      /* @__PURE__ */ jsx2("h3", { className: "text-sm font-medium text-foreground", children: "Health check (optional)" }),
+      /* @__PURE__ */ jsx2("p", { className: "text-[11px] text-muted-foreground", children: "An optional read-only probe adds live upstream depth. For OAuth connections, validity and identity come from the OAuth grant itself. For non-OAuth methods, the probe can validate the credential and identify the account." })
+    ] }),
+    /* @__PURE__ */ jsx2(
+      HealthCheckConfigFields,
+      {
+        candidates: props.candidates,
+        selected: props.selected,
+        operation: props.operation,
+        onOperationChange: props.onOperationChange,
+        identityField: props.identityField,
+        onIdentityFieldChange: props.onIdentityFieldChange,
+        args: props.args,
+        onArgChange: props.onArgChange,
+        disabled: props.disabled,
+        idPrefix: "add-health-check"
+      }
+    )
+  ] });
+}
+function AddOpenApiIntegration(props) {
+  const integrationPlugins = useIntegrationPlugins();
+  const openApiPlugin = integrationPlugins.find((plugin) => plugin.key === "openapi");
+  const openApiPresets = openApiPlugin?.presets;
+  const initialPreset = openApiPresets?.find((preset) => preset.id === props.initialPreset) ?? null;
+  const [specUrl, setSpecUrl] = useState(props.initialUrl ?? "");
+  const [analyzing, setAnalyzing] = useState(false);
+  const [analyzeError, setAnalyzeError] = useState(null);
+  const [preview, setPreview] = useState(null);
+  const [baseUrl, setBaseUrl] = useState("");
+  const [descriptionDraft, setDescriptionDraft] = useState(null);
+  const identityFallbackName = initialPreset?.name ?? (preview ? Option.getOrElse(preview.title, () => "") : "");
+  const identity = useIntegrationIdentity({
+    fallbackName: identityFallbackName,
+    fallbackNamespace: props.initialNamespace
+  });
+  const [adding, setAdding] = useState(false);
+  const [addError, setAddError] = useState(null);
+  const [hcOperation, setHcOperation] = useState("");
+  const [hcIdentityField, setHcIdentityField] = useState("");
+  const [hcArgs, setHcArgs] = useState({});
+  const doPreview = useAtomSet(previewOpenApiSpec, { mode: "promiseExit" });
+  const doAdd = useAtomSet(addOpenApiSpec, { mode: "promiseExit" });
+  const doSetHealthCheck = useAtomSet(setIntegrationHealthCheck, { mode: "promiseExit" });
+  const handleAnalyzeRef = useRef(() => {
+  });
+  useEffect(() => {
+    const trimmed = specUrl.trim();
+    if (!trimmed) return;
+    if (preview) return;
+    const handle = setTimeout(() => {
+      handleAnalyzeRef.current();
+    }, 400);
+    return () => clearTimeout(handle);
+  }, [specUrl, preview]);
+  const previewHasNoServers = preview !== null && preview.servers.length === 0;
+  const baseUrlOptions = preview && preview.servers.length > 1 ? preview.servers.map((server) => {
+    const url = resolveServerUrl(server.url, Option.getOrUndefined(server.variables), {});
+    return { value: url, label: url };
+  }) : void 0;
+  const firstServer = preview?.servers[0];
+  const firstServerUrl = firstServer ? resolveServerUrl(firstServer.url, Option.getOrUndefined(firstServer.variables), {}) : "";
+  const previewPresetIcon = openApiPresets?.find(
+    (preset) => preset.url && normalizePresetUrl(preset.url) === normalizePresetUrl(specUrl)
+  )?.icon ?? null;
+  const resolvedBaseUrl = baseUrl.trim();
+  const resolvedIntegrationId = initialPreset?.defaultSlug || slugifyNamespace(identity.namespace) || (preview ? Option.getOrElse(preview.title, () => "openapi") : "openapi");
+  const resolvedDisplayName = identity.name.trim() || (preview ? Option.getOrElse(preview.title, () => resolvedIntegrationId) : resolvedIntegrationId);
+  const resolvedDescription = descriptionDraft ?? (preview ? Option.getOrElse(preview.description, () => "") : "");
+  const authenticationTemplate = useMemo(() => {
+    if (initialPreset?.authTemplate) {
+      return initialPreset.authTemplate.flatMap(
+        (template) => template.kind === "oauth2" ? [
+          {
+            ...template,
+            slug: AuthTemplateSlug.make(template.slug),
+            resource: template.resource ?? void 0
+          }
+        ] : []
+      );
+    }
+    return detectedAuthenticationTemplates(
+      preview?.headerPresets ?? [],
+      preview?.oauth2Presets ?? [],
+      resolvedBaseUrl
+    );
+  }, [initialPreset?.authTemplate, preview, resolvedBaseUrl]);
+  const authMethodSeeds = useMemo(() => {
+    const labels = [
+      ...(preview?.headerPresets ?? []).map((preset) => preset.label),
+      ...(preview?.oauth2Presets ?? []).map((preset) => preset.label)
+    ];
+    return authenticationTemplate.map(
+      (template, index) => ({
+        value: editorValueFromAuthentication(template),
+        slug: String(template.slug),
+        ...labels[index] !== void 0 ? { label: labels[index] } : {}
+      })
+    );
+  }, [preview, authenticationTemplate]);
+  const authMethodList = useAuthMethodList(authMethodSeeds);
+  const editedAuthenticationTemplate = useMemo(() => {
+    const templates = [];
+    authMethodList.rows.forEach((row, index) => {
+      const slug = row.seedSlug ?? (row.value.kind === "oauth" ? `oauth-${index}` : `apikey-${index}`);
+      const template = authenticationFromEditorValue(row.value, slug);
+      if (template !== null) templates.push(template);
+    });
+    return templates;
+  }, [authMethodList.rows]);
+  const healthCheckCandidates = useMemo(
+    () => preview?.healthCheckCandidates ?? [],
+    [preview?.healthCheckCandidates]
+  );
+  const hcSelected = useMemo(
+    () => healthCheckCandidates.find((c) => c.operation === hcOperation) ?? null,
+    [healthCheckCandidates, hcOperation]
+  );
+  const hcRequiredParams = useMemo(
+    () => (hcSelected?.parameters ?? []).filter((p) => p.required),
+    [hcSelected]
+  );
+  const hcMissingRequired = hcRequiredParams.some(
+    (p) => (hcArgs[p.name] ?? "").trim().length === 0
+  );
+  const onHcOperationChange = (next) => {
+    setHcOperation(next);
+    setHcArgs({});
+    setHcIdentityField("");
+  };
+  const onHcArgChange = (name, value) => setHcArgs((prev) => ({ ...prev, [name]: value }));
+  const slugAlreadyExists = useSlugAlreadyExists(resolvedIntegrationId);
+  const canAdd = preview !== null && !slugAlreadyExists && (!previewHasNoServers || resolvedBaseUrl.length > 0) && !(hcOperation.length > 0 && hcMissingRequired);
+  const handleAnalyze = async () => {
+    setAnalyzing(true);
+    setAnalyzeError(null);
+    setAddError(null);
+    const exit = await doPreview({
+      payload: { spec: specUrl, specFormat: initialPreset?.specFormat }
+    });
+    if (Exit.isFailure(exit)) {
+      setAnalyzeError(errorMessageFromExit(exit, "Failed to parse spec"));
+      setAnalyzing(false);
+      return;
+    }
+    const result = exit.value;
+    setPreview(result);
+    setBaseUrl(result.servers.length === 0 ? baseUrlFromSpecInput(specUrl) : "");
+    setAnalyzing(false);
+  };
+  handleAnalyzeRef.current = handleAnalyze;
+  const ensureIntegration = useCallback(async () => {
+    const exit = await doAdd({
+      payload: {
+        spec: specInputForAdd(specUrl),
+        slug: resolvedIntegrationId,
+        name: resolvedDisplayName,
+        ...resolvedDescription.trim().length > 0 ? { description: resolvedDescription.trim() } : {},
+        baseUrl: resolvedBaseUrl,
+        specFormat: initialPreset?.specFormat,
+        family: initialPreset?.family,
+        healthCheck: initialPreset?.healthCheck,
+        // Always send the edited method list (even empty) when the user has
+        // inspected a preview: an explicit [] means "no auth methods", while
+        // OMITTING the field tells the server to derive defaults from the
+        // spec, which would silently resurrect methods the user deleted.
+        // Serialize to the wire input dialect (apikey -> request-shaped).
+        authenticationTemplate: editedAuthenticationTemplate.map(openApiWireAuthInput)
+      },
+      reactivityKeys: integrationWriteKeys
+    });
+    if (Exit.isFailure(exit)) {
+      setAddError(
+        addIntegrationErrorMessage(exit, resolvedIntegrationId, "Failed to add integration")
+      );
+      return null;
+    }
+    return exit.value.slug;
+  }, [
+    specUrl,
+    doAdd,
+    resolvedIntegrationId,
+    resolvedDisplayName,
+    resolvedDescription,
+    resolvedBaseUrl,
+    editedAuthenticationTemplate,
+    initialPreset?.family,
+    initialPreset?.healthCheck,
+    initialPreset?.specFormat
+  ]);
+  const handleAdd = async () => {
+    setAdding(true);
+    setAddError(null);
+    const integration = await ensureIntegration();
+    if (!integration) {
+      setAdding(false);
+      return;
+    }
+    if (hcOperation.length > 0) {
+      const identity2 = hcIdentityField.trim();
+      const argEntries = Object.entries(hcArgs).map(([key, value]) => [key, value.trim()]).filter(([, value]) => value.length > 0);
+      const spec = {
+        operation: hcOperation,
+        ...argEntries.length > 0 ? { args: Object.fromEntries(argEntries) } : {},
+        ...identity2.length > 0 ? { identityField: identity2 } : {}
+      };
+      await doSetHealthCheck({
+        params: { slug: integration },
+        payload: { spec },
+        reactivityKeys: healthCheckWriteKeys
+      });
+    }
+    props.onComplete(String(integration));
+  };
+  return /* @__PURE__ */ jsxs2("div", { className: "flex flex-1 flex-col gap-6", children: [
+    /* @__PURE__ */ jsx2("div", { children: /* @__PURE__ */ jsx2("h1", { className: "text-xl font-semibold text-foreground", children: "Add OpenAPI integration" }) }),
+    !preview ? /* @__PURE__ */ jsx2(CardStack2, { children: /* @__PURE__ */ jsx2(CardStackContent2, { className: "border-t-0", children: /* @__PURE__ */ jsxs2("div", { className: "space-y-2 p-3", children: [
+      /* @__PURE__ */ jsx2(FieldLabel, { children: "OpenAPI Spec" }),
+      /* @__PURE__ */ jsxs2("div", { className: "relative", children: [
+        /* @__PURE__ */ jsx2(
+          Textarea2,
+          {
+            value: specUrl,
+            onChange: (e) => {
+              setSpecUrl(e.target.value);
+              setAnalyzeError(null);
+            },
+            placeholder: "https://api.example.com/openapi.json",
+            rows: 3,
+            maxRows: 10,
+            className: "font-mono text-sm"
+          }
+        ),
+        analyzing && /* @__PURE__ */ jsx2("div", { className: "pointer-events-none absolute right-2 top-2", children: /* @__PURE__ */ jsx2(IOSSpinner, { className: "size-4" }) })
+      ] }),
+      /* @__PURE__ */ jsx2("p", { className: "text-[11px] text-muted-foreground", children: "Paste a URL or raw JSON/YAML content." }),
+      analyzing && /* @__PURE__ */ jsxs2("p", { className: "flex items-center gap-2 text-xs text-muted-foreground", children: [
+        /* @__PURE__ */ jsx2(IOSSpinner, { className: "size-3.5" }),
+        "Checking spec\u2026"
+      ] }),
+      analyzeError && !analyzing && /* @__PURE__ */ jsxs2("div", { className: "flex flex-wrap items-center gap-2 text-xs text-destructive", children: [
+        /* @__PURE__ */ jsx2("span", { children: openApiPreviewFailureMessage(analyzeError) }),
+        /* @__PURE__ */ jsx2(
+          Button,
+          {
+            type: "button",
+            variant: "ghost",
+            size: "sm",
+            className: "h-7 px-2",
+            onClick: () => void handleAnalyze(),
+            children: "Retry"
+          }
+        )
+      ] })
+    ] }) }) }) : null,
+    preview ? /* @__PURE__ */ jsx2(
+      OpenApiIntegrationDetailsFields,
+      {
+        title: Option.getOrElse(preview.title, () => "API"),
+        subtitle: `${Option.getOrElse(preview.version, () => "")}${Option.isSome(preview.version) ? " \xB7 " : ""}${preview.operationCount} operation${preview.operationCount !== 1 ? "s" : ""}${preview.tags.length > 0 ? ` \xB7 ${preview.tags.length} tag${preview.tags.length !== 1 ? "s" : ""}` : ""}`,
+        identity,
+        description: resolvedDescription,
+        onDescriptionChange: setDescriptionDraft,
+        baseUrl: resolvedBaseUrl,
+        onBaseUrlChange: setBaseUrl,
+        baseUrlOptions,
+        baseUrlLabel: previewHasNoServers ? "Base URL" : "Base URL override (optional)",
+        baseUrlPlaceholder: firstServerUrl || "https://api.example.com",
+        baseUrlHint: previewHasNoServers ? void 0 : "Overrides the spec's servers; leave empty to choose the server (and variables) per tool call.",
+        baseUrlMissingMessage: previewHasNoServers ? "This spec declares no servers, enter a base URL." : void 0,
+        specUrl,
+        onSpecUrlChange: (value) => {
+          setSpecUrl(value);
+          setPreview(null);
+          setBaseUrl("");
+        },
+        faviconIcon: previewPresetIcon,
+        faviconUrl: resolvedBaseUrl || firstServerUrl
+      }
+    ) : null,
+    preview && /* @__PURE__ */ jsx2(
+      AuthMethodListEditor,
+      {
+        list: authMethodList,
+        emptyHint: "No authentication detected. Add a method, or add the integration without auth and connect an account from the integration page later.",
+        footerHint: "Every method here is registered with the integration. Connect an account from the integration page after adding."
+      }
+    ),
+    preview ? /* @__PURE__ */ jsx2(
+      AddOpenApiHealthCheckSection,
+      {
+        presetHealthCheck: initialPreset?.healthCheck,
+        candidates: healthCheckCandidates,
+        selected: hcSelected,
+        operation: hcOperation,
+        onOperationChange: onHcOperationChange,
+        identityField: hcIdentityField,
+        onIdentityFieldChange: setHcIdentityField,
+        args: hcArgs,
+        onArgChange: onHcArgChange,
+        disabled: adding
+      }
+    ) : null,
+    preview && slugAlreadyExists && !adding && /* @__PURE__ */ jsx2(SlugCollisionAlert, { slug: resolvedIntegrationId }),
+    addError && /* @__PURE__ */ jsx2(FormErrorAlert, { message: addError }),
+    /* @__PURE__ */ jsxs2(FloatActions, { children: [
+      /* @__PURE__ */ jsx2(Button, { variant: "ghost", onClick: () => props.onCancel(), disabled: adding, children: "Cancel" }),
+      /* @__PURE__ */ jsx2(Button, { onClick: () => void handleAdd(), disabled: !canAdd || analyzing, loading: adding, children: "Add integration" })
+    ] })
+  ] });
+}
+export {
+  AddOpenApiHealthCheckSection,
+  baseUrlFromSpecInput,
+  AddOpenApiIntegration as default,
+  openApiPreviewFailureMessage
+};
+//# sourceMappingURL=AddOpenApiIntegration-JPAEXE56.js.map