wizards 0.1.9

package/apps/runtime/dist/engenty/connections-external/importer/normalize-mcp.js

@@ -0,0 +1,63 @@
+import { mcpListTools } from "../invoke/mcp-client.js";
+import { classifyMcpTool } from "./classify.js";
+import { MAX_ACTIONS_PER_CONNECTOR } from "./normalize-openapi.js";
+function humanizeToolName(name) {
+    const words = name
+        .replace(/([a-z0-9])([A-Z])/gu, "$1 $2")
+        .replace(/[_\-.]+/gu, " ")
+        .trim();
+    return words ? words[0].toUpperCase() + words.slice(1).toLowerCase() : name;
+}
+/** MCP server tools/list → normalized actions. */
+export async function normalizeMcpServer(params) {
+    const tools = await mcpListTools(params);
+    const actions = [];
+    const skipped = [];
+    const seenIds = new Set();
+    let droppedCount = 0;
+    for (const tool of tools) {
+        if (actions.length >= MAX_ACTIONS_PER_CONNECTOR) {
+            droppedCount += 1;
+            continue;
+        }
+        const id = tool.name
+            .replace(/[^a-zA-Z0-9]+/gu, "_")
+            .replace(/^_+|_+$/gu, "")
+            .toLowerCase()
+            .slice(0, 60);
+        if (!id || seenIds.has(id)) {
+            skipped.push({
+                id: tool.name,
+                reason: id ? "duplicate tool name" : "unusable tool name",
+            });
+            continue;
+        }
+        seenIds.add(id);
+        // Humanize bare tool names ("read_wiki_structure" → "Read wiki structure")
+        // so catalogs, the permissions matrix, and approval cards read naturally.
+        const summary = tool.title ?? humanizeToolName(tool.name);
+        actions.push({
+            classification: classifyMcpTool(tool.annotations ?? {}),
+            description: tool.description ?? summary,
+            id,
+            input_json_schema: tool.inputSchema ?? {
+                additionalProperties: false,
+                properties: {},
+                type: "object",
+            },
+            invoke: { kind: "mcp", tool_name: tool.name },
+            summary,
+            tags: [],
+        });
+    }
+    return {
+        actions,
+        applied_overrides: 0,
+        base_url: null,
+        description: null,
+        dropped_count: droppedCount,
+        security_schemes: null,
+        skipped,
+        title: null,
+    };
+}

package/apps/runtime/dist/engenty/connections-external/importer/normalize-openapi.js

@@ -0,0 +1,130 @@
+import { ImportValidationError } from "../errors.js";
+import { classifyHttpOperation } from "./classify.js";
+/**
+ * OpenAPI spec text → normalized actions, via the executor openapi core
+ * (`parse` + `extract` handle $refs, parameter styles, and merge path/query/
+ * header/body params into one JSON-Schema input with the body under `body`).
+ *
+ * The executor/effect packages are imported LAZILY: they run ONLY at admin
+ * import/refresh time, never at plugin boot or action execute time — the
+ * stored `NormalizedAction[]` is what boot and execute consume. (Same
+ * lazy-import posture the AI app uses for heavyweight optional deps.)
+ *
+ * Registry `specOverrides` are RFC 6902 patches the registry publishes to
+ * correct a published spec (Figma's truncated OAuth scopes, say). They are
+ * applied to the parsed document *before* extraction, and a patch that does
+ * not apply fails the import instead of silently normalizing the unpatched
+ * spec.
+ */
+/** Hard cap per connector; drops are counted and surfaced, never silent. */
+export const MAX_ACTIONS_PER_CONNECTOR = 500;
+/** Spec size ceiling, checked before the body is read and again after. */
+export const MAX_SPEC_BYTES = 5 * 1024 * 1024;
+function snakeCaseId(raw) {
+    return raw
+        .replace(/([a-z0-9])([A-Z])/gu, "$1_$2")
+        .replace(/[^a-zA-Z0-9]+/gu, "_")
+        .replace(/^_+|_+$/gu, "")
+        .toLowerCase()
+        .slice(0, 60);
+}
+export async function normalizeOpenApiSpec(specText, options) {
+    if (Buffer.byteLength(specText, "utf8") > MAX_SPEC_BYTES) {
+        throw new ImportValidationError(`spec too large (> ${MAX_SPEC_BYTES / (1024 * 1024)} MB); import a smaller spec or use a filtered variant`);
+    }
+    const overrides = options?.specOverrides ?? [];
+    const [{ extract, parse }, { Effect, Option }] = await Promise.all([
+        import("@executor-js/plugin-openapi/core"),
+        import("effect"),
+    ]);
+    const optional = (value) => Option.getOrUndefined(value);
+    const doc = await Effect.runPromise(parse(specText));
+    if (overrides.length > 0) {
+        const { applyPatch } = await import("rfc6902");
+        const failures = applyPatch(doc, overrides).filter((error) => error !== null);
+        if (failures.length > 0) {
+            throw new ImportValidationError(`registry spec overrides do not apply to this spec: ${failures
+                .map((error) => error.message)
+                .join("; ")}`);
+        }
+    }
+    const extracted = await Effect.runPromise(extract(doc));
+    /** Substitute server-URL variables with their declared defaults. */
+    const resolveServerBaseUrl = () => {
+        const server = extracted.servers[0];
+        if (!server) {
+            return null;
+        }
+        const variables = optional(server.variables) ?? {};
+        const url = server.url.replace(/\{([^}]+)\}/gu, (match, name) => variables[name]?.default ?? match);
+        return url.replace(/\/+$/u, "");
+    };
+    const actions = [];
+    const skipped = [];
+    const seenIds = new Set();
+    let droppedCount = 0;
+    for (const op of extracted.operations) {
+        if (op.deprecated) {
+            skipped.push({ id: op.operationId, reason: "deprecated" });
+            continue;
+        }
+        if (actions.length >= MAX_ACTIONS_PER_CONNECTOR) {
+            droppedCount += 1;
+            continue;
+        }
+        let id = snakeCaseId(op.operationId);
+        if (!id) {
+            id = snakeCaseId(`${op.method}_${op.pathTemplate}`);
+        }
+        if (!id) {
+            skipped.push({ id: op.operationId, reason: "unusable operation id" });
+            continue;
+        }
+        while (seenIds.has(id)) {
+            id = `${id}_${op.method.toLowerCase()}`.slice(0, 60);
+            if (seenIds.has(id)) {
+                id = `${id}2`;
+            }
+        }
+        seenIds.add(id);
+        const inputSchema = optional(op.inputSchema);
+        const requestBody = optional(op.requestBody);
+        const summary = optional(op.summary) ??
+            `${op.method.toUpperCase()} ${op.pathTemplate}`;
+        actions.push({
+            classification: classifyHttpOperation(op.method, op.pathTemplate),
+            description: optional(op.description) ?? summary,
+            id,
+            input_json_schema: inputSchema ?? {
+                additionalProperties: false,
+                properties: {},
+                type: "object",
+            },
+            invoke: {
+                body_content_type: requestBody?.contentType ?? null,
+                kind: "http",
+                method: op.method,
+                params: op.parameters.map((param) => ({
+                    location: param.location,
+                    name: param.name,
+                    required: param.required,
+                })),
+                path_template: op.pathTemplate,
+            },
+            summary,
+            tags: [...op.tags],
+        });
+    }
+    const securitySchemes = doc
+        .components?.securitySchemes ?? null;
+    return {
+        actions,
+        applied_overrides: overrides.length,
+        base_url: resolveServerBaseUrl(),
+        description: optional(extracted.description) ?? null,
+        dropped_count: droppedCount,
+        security_schemes: securitySchemes,
+        skipped,
+        title: optional(extracted.title) ?? null,
+    };
+}

package/apps/runtime/dist/engenty/connections-external/invoke/http-invoker.js

@@ -0,0 +1,143 @@
+import { createGuardedFetch } from "../net/guarded-fetch.js";
+/**
+ * Execute an imported HTTP action: substitute path params, place query/header
+ * params, serialize the JSON body, inject credentials per the stored auth
+ * config, and clamp the response for model context. Deliberately small and
+ * fetch-based — the executor request pipeline stays confined to import time.
+ *
+ * `base_url` came from a spec fetched over the network, so the request goes
+ * through the SSRF guard on every hop like the import-time fetches do.
+ */
+/** Response clamp: tool output feeds model context; oversize bodies truncate. */
+export const MAX_RESPONSE_CHARS = 200_000;
+const REQUEST_TIMEOUT_MS = 30_000;
+export class ExternalActionError extends Error {
+    body;
+    status;
+    constructor(message, status, body) {
+        super(message);
+        this.name = "ExternalActionError";
+        this.status = status;
+        this.body = body;
+    }
+}
+function renderTemplate(template, credentials) {
+    return template.replace(/\{\{\s*([a-z0-9_]+)\s*\}\}/giu, (_m, key) => credentials[key] ?? "");
+}
+/** Credential placement per auth kind; oauth2 bearer uses the fresh token. */
+function applyAuth(params) {
+    const { accessToken, auth, headers, url } = params;
+    if (auth.kind === "oauth2") {
+        headers.set("authorization", `Bearer ${accessToken}`);
+        return;
+    }
+    if (auth.kind === "api_key") {
+        let credentials = {};
+        try {
+            credentials = JSON.parse(accessToken);
+        }
+        catch {
+            throw new ExternalActionError("stored credentials are not valid JSON — reconnect the connection", null, null);
+        }
+        const value = renderTemplate(auth.placement.value_template, credentials);
+        if (auth.placement.in === "query") {
+            url.searchParams.set(auth.placement.name, value);
+        }
+        else {
+            headers.set(auth.placement.name, value);
+        }
+    }
+}
+export function buildHttpRequest(params) {
+    const { accessToken, auth, baseUrl, input, invoke } = params;
+    let path = invoke.path_template;
+    const headers = new Headers({ accept: "application/json" });
+    // Set before operation params and auth so neither is silently overwritten.
+    for (const header of params.requiredHeaders ?? []) {
+        headers.set(header.name, header.value);
+    }
+    const query = [];
+    for (const param of invoke.params) {
+        const value = input[param.name];
+        if (value === undefined || value === null) {
+            if (param.required && param.location === "path") {
+                throw new ExternalActionError(`missing required path parameter "${param.name}"`, null, null);
+            }
+            continue;
+        }
+        if (param.location === "path") {
+            path = path.replaceAll(`{${param.name}}`, encodeURIComponent(String(value)));
+        }
+        else if (param.location === "query") {
+            query.push([param.name, value]);
+        }
+        else if (param.location === "header") {
+            headers.set(param.name, String(value));
+        }
+        // cookie params are unsupported in v1 — ignored by design.
+    }
+    const url = new URL(baseUrl.replace(/\/+$/u, "") + path);
+    for (const [name, value] of query) {
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                url.searchParams.append(name, String(item));
+            }
+        }
+        else {
+            url.searchParams.append(name, String(value));
+        }
+    }
+    let body;
+    if (invoke.body_content_type && input.body !== undefined) {
+        headers.set("content-type", invoke.body_content_type);
+        body =
+            invoke.body_content_type.includes("json") ||
+                typeof input.body !== "string"
+                ? JSON.stringify(input.body)
+                : input.body;
+    }
+    applyAuth({ accessToken, auth, headers, url });
+    return { body, headers, method: invoke.method.toUpperCase(), url };
+}
+export async function executeHttpAction(params) {
+    const { accessToken, input, invoke, record } = params;
+    const fetchImpl = createGuardedFetch({
+        fetchImpl: params.fetchImpl,
+        ...(params.lookupImpl ? { lookupImpl: params.lookupImpl } : {}),
+    });
+    if (!record.base_url) {
+        throw new ExternalActionError("imported connector has no base URL — set one via refresh/import", null, null);
+    }
+    const request = buildHttpRequest({
+        accessToken,
+        auth: record.auth_config,
+        baseUrl: record.base_url,
+        input,
+        invoke,
+        requiredHeaders: record.required_headers,
+    });
+    const response = await fetchImpl(request.url, {
+        body: request.body,
+        headers: request.headers,
+        method: request.method,
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+    });
+    const text = await response.text();
+    if (!response.ok) {
+        throw new ExternalActionError(`provider request failed (${response.status} ${request.method} ${request.url.pathname})`, response.status, text.slice(0, 2000));
+    }
+    const truncated = text.length > MAX_RESPONSE_CHARS;
+    const clamped = truncated ? text.slice(0, MAX_RESPONSE_CHARS) : text;
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("json")) {
+        try {
+            return truncated
+                ? { body: clamped, truncated: true }
+                : JSON.parse(clamped);
+        }
+        catch {
+            return { body: clamped, truncated };
+        }
+    }
+    return { body: clamped, content_type: contentType || null, truncated };
+}

package/apps/runtime/dist/engenty/connections-external/invoke/mcp-client.js

@@ -0,0 +1,143 @@
+import { z } from "zod";
+import { createGuardedFetch } from "../net/guarded-fetch.js";
+/**
+ * Adapter over the official MCP client (`@modelcontextprotocol/client`) for
+ * imported MCP connectors. It owns three things and nothing else:
+ *
+ * - **transport choice** — streamable HTTP by default; SSE only when the
+ *   registry declares that transport or an admin picked it for a legacy URL,
+ *   and as the fallback when a server rejects the streamable handshake;
+ * - **credentials** — Connections resolves the connection's token and this
+ *   module turns it into request headers; the SDK's own OAuth provider is
+ *   deliberately not used, since grants live in the connections store;
+ * - **session lifetime** — every call opens a client and releases it in
+ *   `finally`: the streamable transport's session is terminated (DELETE) and
+ *   the client closed, so a failed `tools/call` never leaks a server-side
+ *   session.
+ *
+ * Every request the SDK makes goes through the injected guarded fetch, so an
+ * MCP endpoint cannot be pointed at a private address.
+ */
+const REQUEST_TIMEOUT_MS = 30_000;
+const CLIENT_INFO = {
+    name: "engenty-connections-external",
+    version: "0.0.1",
+};
+export const mcpToolSchema = z
+    .object({
+    annotations: z
+        .object({
+        destructiveHint: z.boolean().optional(),
+        readOnlyHint: z.boolean().optional(),
+    })
+        .loose()
+        .nullish(),
+    description: z.string().nullish(),
+    inputSchema: z.record(z.string(), z.unknown()).nullish(),
+    name: z.string(),
+    title: z.string().nullish(),
+})
+    .loose();
+export class McpRequestError extends Error {
+    status;
+    constructor(message, status = null) {
+        super(message);
+        this.name = "McpRequestError";
+        this.status = status;
+    }
+}
+function httpStatusFromUnknown(error) {
+    if (error instanceof McpRequestError && error.status !== null) {
+        return error.status;
+    }
+    if (error && typeof error === "object" && "code" in error) {
+        const code = error.code;
+        if (typeof code === "number" && code >= 400 && code < 600) {
+            return code;
+        }
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    const http = message.match(/\bHTTP\s+(\d{3})\b/iu);
+    if (http) {
+        return Number(http[1]);
+    }
+    const unauthorized = message.match(/\b(401)\b/u);
+    return unauthorized ? Number(unauthorized[1]) : null;
+}
+/** Anonymous MCP handshake / tools/list was refused as unauthorized. */
+export function isUnauthorizedMcpError(error) {
+    if (httpStatusFromUnknown(error) === 401) {
+        return true;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return /\b401\b|unauthorized/iu.test(message);
+}
+/**
+ * Transport factories are resolved lazily so the SDK (and its OAuth/JOSE
+ * dependency tree) is loaded only when an MCP connector actually runs.
+ */
+async function connectClient(params, transport) {
+    const sdk = await import("@modelcontextprotocol/client");
+    const url = new URL(params.endpoint);
+    const options = {
+        fetch: params.fetchImpl ?? createGuardedFetch(),
+        requestInit: params.headers ? { headers: params.headers } : undefined,
+    };
+    const clientTransport = transport === "sse"
+        ? new sdk.SSEClientTransport(url, options)
+        : new sdk.StreamableHTTPClientTransport(url, options);
+    const client = new sdk.Client(CLIENT_INFO);
+    await client.connect(clientTransport);
+    return { client, transport: clientTransport };
+}
+/**
+ * Run `fn` against a connected client, closing the session in `finally`.
+ * A streamable-HTTP server that refuses the handshake is retried once over
+ * SSE — the legacy transport many hosted servers still answer on.
+ */
+async function withMcpClient(params, fn) {
+    const declared = params.transport ?? "streamable-http";
+    const attempts = declared === "sse" ? ["sse"] : ["streamable-http", "sse"];
+    let lastError;
+    for (const transport of attempts) {
+        let session;
+        try {
+            session = await connectClient(params, transport);
+        }
+        catch (error) {
+            lastError = error;
+            continue;
+        }
+        try {
+            return await fn(session.client);
+        }
+        catch (error) {
+            throw new McpRequestError(error instanceof Error ? error.message : String(error), httpStatusFromUnknown(error));
+        }
+        finally {
+            // Best effort in both steps: the session is already gone if either
+            // fails, and neither may mask the caller's own error.
+            await session.transport.terminateSession?.().catch(() => {
+                // Server does not allow client-side termination.
+            });
+            await session.client.close().catch(() => {
+                // Already closed.
+            });
+        }
+    }
+    throw new McpRequestError(`cannot connect to MCP server ${params.endpoint}: ${lastError instanceof Error ? lastError.message : String(lastError)}`, httpStatusFromUnknown(lastError));
+}
+export async function mcpListTools(params) {
+    return await withMcpClient(params, async (client) => {
+        const result = await client.listTools(undefined, {
+            timeout: REQUEST_TIMEOUT_MS,
+        });
+        return z
+            .object({ tools: z.array(mcpToolSchema).default([]) })
+            .loose()
+            .parse(result ?? {}).tools;
+    });
+}
+export async function mcpCallTool(params) {
+    return await withMcpClient(params, (client) => client.callTool({ arguments: params.args, name: params.toolName }, { timeout: REQUEST_TIMEOUT_MS }));
+}

package/apps/runtime/dist/engenty/connections-external/net/guarded-fetch.js

@@ -0,0 +1,119 @@
+import { assertPublicHttpHost } from "../../shims/web-ingest.js";
+/**
+ * Every network call this module makes reaches a URL that came from the
+ * registry, an admin-pasted field, or a stored import record — attacker
+ * influenceable in all three cases. `createGuardedFetch` is the single way out:
+ * it validates the host (DNS-resolved, private/link-local ranges blocked)
+ * before the first request and again before following each redirect.
+ *
+ * `safeFetchFollowingRedirects` in `@engenty/web-ingest` covers GET/HEAD only;
+ * the MCP transport POSTs JSON-RPC bodies and DELETEs sessions, so the redirect
+ * chain is walked here with method and body carried the way the HTTP spec
+ * prescribes (307/308 replay, 301/302/303 downgrade to GET).
+ */
+const DEFAULT_MAX_REDIRECTS = 5;
+const REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
+/** Redirects that must not replay the original method and body. */
+const DOWNGRADE_TO_GET = new Set([301, 302, 303]);
+/** A `fetch` drop-in that refuses private/non-HTTP targets on every hop. */
+export function createGuardedFetch(options) {
+    const fetchImpl = options?.fetchImpl ?? fetch;
+    const maxRedirects = options?.maxRedirects ?? DEFAULT_MAX_REDIRECTS;
+    return (async (input, init) => {
+        let currentUrl = typeof input === "string" ? input : String(input);
+        let currentInit = { ...init, redirect: "manual" };
+        let hops = 0;
+        await assertPublicHttpHost(currentUrl, options?.lookupImpl);
+        while (true) {
+            const response = await fetchImpl(currentUrl, currentInit);
+            if (!REDIRECT_STATUSES.has(response.status)) {
+                return response;
+            }
+            hops += 1;
+            if (hops > maxRedirects) {
+                throw new Error(`Too many redirects (max ${maxRedirects}) following ${currentUrl}`);
+            }
+            const location = response.headers.get("location");
+            if (!location?.trim()) {
+                throw new Error(`Redirect response (HTTP ${response.status}) missing Location header`);
+            }
+            let nextUrl;
+            try {
+                nextUrl = new URL(location, currentUrl).toString();
+            }
+            catch {
+                throw new Error(`Malformed Location header in redirect: ${location}`);
+            }
+            await assertPublicHttpHost(nextUrl, options?.lookupImpl);
+            if (DOWNGRADE_TO_GET.has(response.status)) {
+                currentInit = { ...currentInit, body: undefined, method: "GET" };
+            }
+            else if (currentInit.body !== undefined &&
+                currentInit.body !== null &&
+                typeof currentInit.body !== "string") {
+                // A stream body cannot be replayed; refuse rather than send a
+                // truncated request to a host we were redirected to.
+                throw new Error(`Cannot follow HTTP ${response.status} redirect: request body is not replayable`);
+            }
+            currentUrl = nextUrl;
+        }
+    });
+}
+export class SpecTooLargeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "SpecTooLargeError";
+    }
+}
+/**
+ * GET a text document through the guard, refusing oversize payloads *before*
+ * reading them: `content-length` is checked first, then the body is consumed
+ * chunk by chunk and abandoned the moment it crosses `maxBytes`.
+ */
+export async function fetchTextBounded(params) {
+    const response = await params.fetchImpl(params.url, {
+        ...(params.headers ? { headers: params.headers } : {}),
+        ...(params.signal ? { signal: params.signal } : {}),
+    });
+    if (!response.ok) {
+        throw new Error(`spec fetch failed (${response.status}): ${params.url}`);
+    }
+    const declared = Number(response.headers.get("content-length"));
+    if (Number.isFinite(declared) && declared > params.maxBytes) {
+        throw new SpecTooLargeError(`spec too large (${declared} bytes > ${params.maxBytes}); import a smaller spec or use a filtered variant`);
+    }
+    const body = response.body;
+    if (!body) {
+        const text = await response.text();
+        if (Buffer.byteLength(text, "utf8") > params.maxBytes) {
+            throw new SpecTooLargeError(`spec too large (> ${params.maxBytes} bytes); import a smaller spec or use a filtered variant`);
+        }
+        return text;
+    }
+    const reader = body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            if (!value) {
+                continue;
+            }
+            total += value.byteLength;
+            if (total > params.maxBytes) {
+                throw new SpecTooLargeError(`spec too large (> ${params.maxBytes} bytes); import a smaller spec or use a filtered variant`);
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+        await body.cancel().catch(() => {
+            // Already drained or errored — nothing to release.
+        });
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}

package/apps/runtime/dist/engenty/connections-external/oauth-dcr.js

@@ -0,0 +1,88 @@
+import { createGuardedFetch } from "./net/guarded-fetch.js";
+/**
+ * RFC 7591 dynamic client registration for imported OAuth MCP servers.
+ * The MCP SDK's own OAuth provider is unused — the registered client is
+ * stored on the import row and the token still lands in the connections store.
+ *
+ * Prefer a public client (`token_endpoint_auth_method: "none"`, no secret) so
+ * Figma-style MCP authorization servers accept registration; fall back to a
+ * confidential `client_secret_post` client for servers that require it.
+ */
+const REQUEST_TIMEOUT_MS = 20_000;
+const AUTH_METHODS = ["none", "client_secret_post"];
+export function connectionsRedirectUri() {
+    const override = process.env.CONNECTIONS_REDIRECT_URI?.trim();
+    if (override) {
+        return override;
+    }
+    const base = process.env.ENGENTY_API_BASE_URL?.trim()?.replace(/\/$/u, "");
+    if (!base) {
+        throw new Error("Missing ENGENTY_API_BASE_URL (run pnpm portless:env:sync)");
+    }
+    return `${base}/api/connections/oauth/callback`;
+}
+function registrationErrorMessage(status, data, rawBody) {
+    const fromJson = data.error_description?.trim() ||
+        data.error?.trim() ||
+        (typeof data === "object" && data && "message" in data
+            ? String(data.message ?? "").trim()
+            : "");
+    const fromBody = rawBody.trim().slice(0, 300);
+    const detail = fromJson || fromBody || "no error body";
+    return `dynamic client registration failed (${status}): ${detail}`;
+}
+async function postRegistration(params) {
+    return params.fetchImpl(params.registrationEndpoint, {
+        body: JSON.stringify({
+            client_name: params.clientName,
+            grant_types: ["authorization_code", "refresh_token"],
+            redirect_uris: [params.redirectUri],
+            response_types: ["code"],
+            scope: params.scopes.join(" "),
+            token_endpoint_auth_method: params.authMethod,
+        }),
+        headers: {
+            accept: "application/json",
+            "content-type": "application/json",
+        },
+        method: "POST",
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+    });
+}
+export async function registerDynamicClient(params) {
+    const fetchImpl = params.fetchImpl ?? createGuardedFetch();
+    const errors = [];
+    for (const authMethod of AUTH_METHODS) {
+        const response = await postRegistration({
+            authMethod,
+            clientName: params.clientName,
+            fetchImpl,
+            redirectUri: params.redirectUri,
+            registrationEndpoint: params.registrationEndpoint,
+            scopes: params.scopes,
+        });
+        const rawBody = await response.text();
+        const data = (() => {
+            try {
+                return JSON.parse(rawBody);
+            }
+            catch {
+                return {};
+            }
+        })();
+        if (!response.ok) {
+            errors.push(registrationErrorMessage(response.status, data, rawBody));
+            continue;
+        }
+        if (!data.client_id?.trim()) {
+            errors.push(`dynamic client registration returned no client_id (${authMethod})`);
+            continue;
+        }
+        // Public clients (`none`) omit client_secret; confidential ones return it.
+        return {
+            clientId: data.client_id,
+            clientSecret: data.client_secret ?? "",
+        };
+    }
+    throw new Error(errors.at(-1) ?? "dynamic client registration failed");
+}