@zackbart/connecta 0.38.0 → 0.40.0

package/dist/connectors/remote-mcp/catalog.js

@@ -0,0 +1,278 @@
+// Catalog intake: every tools/resources listing page is checked before the
+// SDK can aggregate or cache it (INV-8), and listTools serves the result.
+import { authFlow, authCall, authInvoke, authMethod } from "../../auth/native.js";
+import { SdkHttpError, specTypeSchemas, UnauthorizedError } from "@modelcontextprotocol/client";
+import { redactCatalog } from "../../sent-secrets.js";
+import { MAX_CATALOG_TOOLS, MAX_SERIALIZED_CATALOG_BYTES } from "../../catalog-limits.js";
+import { catalogItems, observeCompletedCatalogRefresh, observeCatalogFetch, observeCatalogExpiry, } from "../../catalog-cache.js";
+import { ConnectorCallError, msg } from "../../errors.js";
+import { carryFailureFacts, failureRecord, logFailure } from "../../operator-record.js";
+import { assertDownstreamOutputSafe } from "../../downstream-input-context.js";
+import { hasSdkPayload, ownAbortReason, requiresAuthorization } from "./errors.js";
+/** SDK aggregation cap; intake also refuses loops and non-progress (INV-8). */
+export const MAX_TOOL_PAGES = 10_000;
+/**
+ * Compatibility concession for hand-rolled servers that serialize
+ * end-of-pagination as `null`. Only the cursor is widened; every tool and every
+ * other result field still passes through the SDK's pinned schema.
+ */
+const CompatibleListToolsResultSchema = {
+    "~standard": {
+        version: 1,
+        vendor: "connecta",
+        validate(value) {
+            const normalized = typeof value === "object" && value !== null && "nextCursor" in value && value.nextCursor === null
+                ? (() => {
+                    const copy = { ...value };
+                    delete copy.nextCursor;
+                    return copy;
+                })()
+                : value;
+            return specTypeSchemas.ListToolsResult["~standard"].validate(normalized);
+        },
+    },
+};
+/**
+ * True for a result-parse failure caused by the page's `nextCursor` itself.
+ * `null` is accepted deliberately; other non-string values remain a named
+ * downstream nonconformance instead of surfacing as a raw validation dump.
+ * Duck-typed rather than `instanceof ZodError`: the SDK may parse with its own
+ * zod instance, and cross-instance `instanceof` is a coin flip.
+ */
+function isCursorShapeError(err) {
+    const issues = err?.issues;
+    if (Array.isArray(issues) &&
+        issues.some((issue) => {
+            const path = issue.path;
+            return Array.isArray(path) && path[0] === "nextCursor";
+        })) {
+        return true;
+    }
+    // SDK v2 wraps Standard Schema failures in a ProtocolError and preserves the
+    // failing path in the message rather than exposing the validator's issues.
+    return msg(err).startsWith("Invalid result for tools/list: nextCursor:");
+}
+/** One connector's catalog intake and listTools operation. */
+export function remoteMcpCatalog(rt) {
+    const { id } = rt;
+    // Listings that must reach the downstream: a credential test proves the
+    // stored value against the server, never against a cached catalog.
+    const liveListings = new WeakSet();
+    /** Wrap the public request seam, before listTools aggregates or auto-caches.
+     * SDK 2.3.1 treats an identical repeated page as completion. Refuse it here:
+     * an advertised successor is never proof of a complete catalog (INV-8). */
+    const listingContexts = new WeakMap();
+    const installCatalogIntake = (client, ctx, cache) => {
+        let toolPages = 0;
+        const listingContext = (options) => {
+            const { signal: _signal, timeoutMs: _timeout, ...base } = ctx;
+            return ((options && listingContexts.get(options)) ?? {
+                ...base,
+                requestScope: ctx.requestScope ?? ctx,
+                ...(options?.signal ? { signal: options.signal } : {}),
+                ...(options?.timeout ? { timeoutMs: options.timeout } : {}),
+            });
+        };
+        const listTools = client.listTools.bind(client);
+        client.listTools = authMethod((params, options) => authInvoke(cache, "withListing", [
+            listingContext(options),
+            authMethod(() => authFlow(function* () {
+                const before = toolPages;
+                let result;
+                try {
+                    result = (yield authCall(listTools, [params, options]));
+                }
+                catch (error) {
+                    const bounded = rt.atMcpBoundary(cache.currentContext(), error, "tools/list", client.transport, [
+                        cache.currentContext().signal,
+                    ]);
+                    const transient = (error instanceof SdkHttpError && [502, 503, 504].includes(error.status)) ||
+                        (bounded instanceof ConnectorCallError && bounded.code === "unavailable");
+                    const fallback = transient && toolPages === before
+                        ? (yield authInvoke(cache, "fallbackTools", []))
+                        : undefined;
+                    if (!fallback)
+                        throw error;
+                    return fallback;
+                }
+                if (toolPages !== before && params?.cursor === undefined) {
+                    const refresh = (yield authInvoke(cache, "completeCatalogRefresh", [result]));
+                    if (refresh) {
+                        try {
+                            (yield authCall(observeCompletedCatalogRefresh, [cache.currentContext(), refresh]));
+                        }
+                        catch (error) {
+                            logFailure(cache.currentContext().logger, "catalog refresh observation failed", failureRecord({ connector: id }, error));
+                        }
+                    }
+                }
+                return result;
+            })),
+        ]));
+        const listResources = client.listResources.bind(client);
+        client.listResources = authMethod((params, options) => authInvoke(cache, "withListing", [
+            listingContext(options),
+            authMethod(() => authCall(listResources, [params, options])),
+        ]));
+        const listResourceTemplates = client.listResourceTemplates.bind(client);
+        client.listResourceTemplates = authMethod((params, options) => authInvoke(cache, "withListing", [
+            listingContext(options),
+            authMethod(() => authCall(listResourceTemplates, [params, options])),
+        ]));
+        const request = client.request.bind(client);
+        const walks = new WeakMap();
+        client.request = authMethod((...args) => authFlow(function* () {
+            const message = args[0];
+            if (message.method !== "tools/list" &&
+                message.method !== "resources/list" &&
+                message.method !== "resources/templates/list")
+                return yield authCall(request, args, client);
+            const method = message.method;
+            const ctx = cache.currentContext();
+            const options = (args.length === 3 ? args[2] : args[1]);
+            if (rt.isClosed(rt.entryFor(ctx)))
+                throw rt.scopeEndedError();
+            if (options?.signal?.aborted)
+                throw options.signal.reason;
+            const key = options ?? message;
+            let walk = walks.get(key);
+            if (message.params?.cursor === undefined || !walk) {
+                walk = { names: new Set(), cursors: new Set(), barren: 0, bytes: 0 };
+                walks.set(key, walk);
+            }
+            let page;
+            try {
+                page = (yield authCall(request, [
+                    message,
+                    method === "tools/list"
+                        ? CompatibleListToolsResultSchema
+                        : method === "resources/list"
+                            ? specTypeSchemas.ListResourcesResult
+                            : specTypeSchemas.ListResourceTemplatesResult,
+                    options,
+                ]));
+            }
+            catch (error) {
+                if (isCursorShapeError(error))
+                    throw new ConnectorCallError("connector_call_failed", "Downstream catalog nextCursor must be a string, null, or absent.", { retryable: false });
+                throw error;
+            }
+            assertDownstreamOutputSafe(ctx.requestScope ?? ctx, page);
+            const clean = cache.intake(ctx, method, page);
+            if (method === "tools/list")
+                toolPages++;
+            if (message.params?.cursor === undefined)
+                observeCatalogFetch(ctx, Date.now(), method);
+            const tools = catalogItems(method, clean).filter((item) => {
+                const name = method === "tools/list"
+                    ? item.name
+                    : method === "resources/list"
+                        ? item.uri
+                        : item.uriTemplate;
+                if (walk.names.has(name))
+                    return false;
+                walk.names.add(name);
+                return true;
+            });
+            walk.bytes += new TextEncoder().encode(JSON.stringify(tools)).byteLength;
+            if (walk.names.size > MAX_CATALOG_TOOLS || walk.bytes > MAX_SERIALIZED_CATALOG_BYTES) {
+                throw new ConnectorCallError("connector_call_failed", "Downstream catalog exceeds the complete-catalog ceiling.", { retryable: false });
+            }
+            if (clean.nextCursor !== undefined) {
+                if (walk.cursors.has(clean.nextCursor))
+                    throw new ConnectorCallError("connector_call_failed", "Downstream catalog pagination chain loops.", {
+                        retryable: false,
+                    });
+                if (tools.length === 0 && ++walk.barren > 1)
+                    throw new ConnectorCallError("connector_call_failed", "Downstream catalog pagination is not advancing.", {
+                        retryable: false,
+                    });
+                if (tools.length > 0)
+                    walk.barren = 0;
+                walk.cursors.add(clean.nextCursor);
+            }
+            const field = method === "tools/list" ? "tools" : method === "resources/list" ? "resources" : "resourceTemplates";
+            const result = { ...clean, [field]: tools };
+            if (!walk.first)
+                walk.first = result;
+            else {
+                walk.first.ttlMs = Math.min(walk.first.ttlMs, clean.ttlMs);
+                if (clean.cacheScope !== "public")
+                    walk.first.cacheScope = "private";
+            }
+            observeCatalogExpiry(ctx, method, walk.first.ttlMs);
+            return result;
+        }));
+    };
+    // The SDK walks the whole chain and writes one complete result. Intake
+    // runs on its public request seam before any page can enter that cache.
+    const listToolsOperation = authMethod((ctx) => authFlow(function* () {
+        const state = rt.stateFor(ctx);
+        // Without a connection in this scope, a complete cached catalog is
+        // served as it stands. A live connection reads the same cache through
+        // the SDK, and a credential test always lists live.
+        const cached = state.client || state.connecting || state.authRequired || liveListings.has(ctx)
+            ? {}
+            : (yield authCall(rt.cachedCatalog, [ctx]));
+        let clean;
+        if (cached.tools)
+            clean = redactCatalog(ctx, cached.tools);
+        else {
+            const client = (yield authCall(rt.ensureConnected, [ctx, state, cached]));
+            // A credential test must observe the downstream answer itself, never
+            // the SDK cache a modern connection reads without any request.
+            const options = {
+                ...rt.requestOptions(ctx),
+                ...(liveListings.has(ctx) ? { cacheMode: "bypass" } : {}),
+            };
+            listingContexts.set(options, ctx);
+            try {
+                const result = (yield authInvoke(client, "listTools", [undefined, options]));
+                clean = redactCatalog(ctx, result.tools);
+            }
+            catch (err) {
+                if (ownAbortReason(err, [ctx.signal]) && !hasSdkPayload(err))
+                    throw err;
+                const bounded = rt.atMcpBoundary(ctx, err, "tools/list", client.transport, [ctx.signal]);
+                if (requiresAuthorization(bounded)) {
+                    if (state.client === client)
+                        state.authRequired = true;
+                    if (bounded instanceof UnauthorizedError)
+                        throw carryFailureFacts(bounded, rt.authRequiredError(ctx));
+                }
+                throw bounded;
+            }
+            finally {
+                listingContexts.delete(options);
+            }
+        }
+        state.toolDefinitions = new Map(clean.map((tool) => [tool.name, tool]));
+        return clean.map((t) => ({
+            name: t.name,
+            ...(t.title !== undefined ? { title: t.title } : {}),
+            ...(t.icons !== undefined
+                ? {
+                    icons: t.icons.filter((icon) => !/^data:/i.test(icon.src)),
+                }
+                : {}),
+            ...(t.execution !== undefined ? { execution: t.execution } : {}),
+            ...(t.description !== undefined ? { description: t.description } : {}),
+            ...(t.inputSchema !== undefined
+                ? {
+                    inputSchema: t.inputSchema,
+                }
+                : {}),
+            ...(t.outputSchema !== undefined
+                ? {
+                    outputSchema: t.outputSchema,
+                }
+                : {}),
+            ...(t.annotations !== undefined
+                ? {
+                    annotations: t.annotations,
+                }
+                : {}),
+        }));
+    }));
+    return { installCatalogIntake, listingContexts, liveListings, listToolsOperation };
+}

package/dist/connectors/remote-mcp/config.js

@@ -0,0 +1,263 @@
+// remoteMcp() options and validation: the closed option set, resource and
+// credential header rules, and every construction-time refusal, in order.
+import { authorizationParamsFor } from "../../auth/oauth-authorization-params.js";
+import { assertRemoteOAuthClient } from "../../auth/downstream-client-metadata.js";
+import { assertOAuthScope } from "../../auth/downstream-oauth.js";
+import { shortSecretWarning } from "../../sent-secrets.js";
+import { assertKnownOptions, keys, optionsOf, strings } from "../../config-schema.js";
+import { READ_ONLY, CALL_ADMISSION, REMOTE_MCP_AUTH, USAGE_GUIDE } from "../option-shapes.js";
+/** The closed options remoteMcp() accepts; see `assertKnownOptions`. */
+const REMOTE_MCP_OPTIONS = optionsOf()({
+    ...keys("url", "title", "description", "authScope", "maxResultBytes", "versionNegotiation", "redirects", "requireHttps", "logger", "fetch", "_transportFactory", "skills"),
+    readOnly: READ_ONLY,
+    callAdmission: CALL_ADMISSION,
+    usageGuide: USAGE_GUIDE,
+    auth: REMOTE_MCP_AUTH,
+    headers: strings(),
+});
+/** Extra headers are immutable code configuration, not another auth channel. */
+function extraResourceHeaders(id, opts) {
+    if (opts.headers === undefined)
+        return undefined;
+    const refuse = () => new Error(`remoteMcp(${JSON.stringify(id)}).headers requires non-secret resource headers without reserved or auth-owned names; use auth for credentials.`);
+    if (opts.auth?.type === "headers")
+        throw refuse();
+    const authNames = new Set([
+        "authorization",
+        ...(opts.auth?.type === "credential" ? [opts.auth.header?.trim().toLowerCase() || "authorization"] : []),
+        ...(opts.auth?.type === "request" ? Object.keys(opts.auth.headers ?? {}).map((name) => name.toLowerCase()) : []),
+    ]);
+    const normalized = Object.create(null);
+    for (const [name, value] of Object.entries(opts.headers)) {
+        const lower = name.toLowerCase();
+        if (!HEADER_NAME_TOKEN.test(name) ||
+            typeof value !== "string" ||
+            /[\r\n]/.test(value) ||
+            Object.hasOwn(normalized, lower) ||
+            authNames.has(lower) ||
+            /^(?:accept|cookie|host|origin|connection|keep-alive|proxy-authenticate|proxy-authorization|te|trailer|transfer-encoding|upgrade|last-event-id|dpop|www-authenticate)$/.test(lower) ||
+            /^(?:content-|mcp-)/.test(lower) ||
+            /(?:api[-_]?key|token|secret|password|credential|authorization|signature|session)/.test(lower))
+            throw refuse();
+        try {
+            normalized[lower] = new Headers({ [lower]: value }).get(lower);
+        }
+        catch {
+            throw refuse();
+        }
+    }
+    return Object.freeze(Object.fromEntries(Object.entries(normalized).sort(([a], [b]) => a.localeCompare(b))));
+}
+const encoder = new TextEncoder();
+/** Base64 of a UTF-8 string, Web-API only so the core still runs on workerd. */
+function base64Utf8(value) {
+    let binary = "";
+    for (const byte of encoder.encode(value)) {
+        binary += String.fromCharCode(byte);
+    }
+    return btoa(binary);
+}
+/**
+ * Assemble the one header a credential-auth connector sends.
+ *
+ * A scheme ending in `Basic` names HTTP Basic credentials wherever a provider
+ * nests it, so the `user:secret` it frames is base64-encoded — that is what
+ * makes plain `Basic` and nested `Bearer Basic` one rule instead of two.
+ */
+export function credentialHeaderValue(scheme, value) {
+    if (scheme === null)
+        return value;
+    return /(?:^|\s)basic$/i.test(scheme) ? `${scheme} ${base64Utf8(value)}` : `${scheme} ${value}`;
+}
+/**
+ * True when a stored credential carries a character a header cannot.
+ *
+ * The fetch specification refuses NUL, CR, and LF outright, and the runtime
+ * that refuses them says so in a `TypeError` that quotes the whole offending
+ * value — a message that would otherwise travel to the agent. The remaining C0
+ * controls and DEL are refused here too: no real API key contains one, and a
+ * paste that picked one up is a paste to redo rather than a request to send.
+ * Leading and trailing whitespace is already gone by the time this runs.
+ *
+ * A scan rather than a regular expression, because a character class over the
+ * control range is exactly what `no-control-regex` exists to flag, and the
+ * suppression would be less readable than the loop it suppressed.
+ */
+export function carriesIllegalHeaderChar(value) {
+    for (let index = 0; index < value.length; index++) {
+        const code = value.charCodeAt(index);
+        if (code <= 0x1f || code === 0x7f)
+            return true;
+    }
+    return false;
+}
+/** RFC 9110 field-name token, checked once at construction. */
+const HEADER_NAME_TOKEN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+function isLoopbackHost(hostname) {
+    return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]" || hostname === "::1";
+}
+/** Validate `opts` once, at construction, and derive what every seam reads. */
+export function remoteMcpConfig(id, opts) {
+    opts = assertKnownOptions(opts, `remoteMcp(${JSON.stringify(id)})`, REMOTE_MCP_OPTIONS);
+    if (opts.readOnly !== undefined)
+        READ_ONLY.parse(opts.readOnly, `Connector(${JSON.stringify(id)}).readOnly`);
+    if (opts.callAdmission !== undefined)
+        CALL_ADMISSION.parse(opts.callAdmission, `remoteMcp(${JSON.stringify(id)}).callAdmission`);
+    const extraHeaders = extraResourceHeaders(id, opts);
+    const skillsEnabled = opts.skills;
+    if (skillsEnabled !== undefined && typeof skillsEnabled !== "boolean") {
+        throw new Error(`[connecta] connector "${id}" skills must be a boolean.`);
+    }
+    const clientMetadataUrl = opts.auth?.type === "oauth" ? opts.auth.clientMetadataUrl : undefined;
+    const oauthScope = opts.auth?.type === "oauth" ? opts.auth.scope : undefined;
+    assertOAuthScope(id, oauthScope);
+    const authorizationParams = authorizationParamsFor(opts.auth?.type === "oauth" ? opts.auth.authorizationParams : undefined, `remoteMcp(${JSON.stringify(id)}).auth.authorizationParams`);
+    const staticClient = opts.auth?.type === "oauth" && opts.auth.client ? { ...opts.auth.client } : undefined;
+    assertRemoteOAuthClient(id, staticClient);
+    if (staticClient && clientMetadataUrl !== undefined)
+        throw new Error(`[connecta] connector "${id}" OAuth client and clientMetadataUrl are mutually exclusive.`);
+    if (clientMetadataUrl !== undefined) {
+        let valid = false;
+        try {
+            const url = new URL(clientMetadataUrl);
+            valid = url.protocol === "https:" && url.pathname !== "/" && !url.username && !url.password && !url.hash;
+        }
+        catch {
+            /* Invalid configuration is rejected below without echoing its value. */
+        }
+        if (!valid)
+            throw new Error(`[connecta] connector "${id}" clientMetadataUrl must be an HTTPS URL with a non-root path, without credentials or a fragment.`);
+    }
+    if (opts.authScope === "personal" && opts.auth?.type === "headers") {
+        throw new Error(`[connecta] connector "${id}" cannot combine authScope "personal" ` +
+            "with static headers. Use credential or OAuth auth so each principal " +
+            "can own a different grant.");
+    }
+    const isOauth = opts.auth?.type === "oauth";
+    const logger = opts.logger ?? console;
+    const warnShortSecret = shortSecretWarning();
+    warnShortSecret(staticClient?.clientSecret, logger);
+    if (opts.auth?.type === "headers") {
+        for (const [name, value] of Object.entries(opts.auth.headers)) {
+            if (!/key|token|secret|password|auth|signature|session/i.test(name))
+                continue;
+            const basic = /^Basic\s+(.+)$/i.exec(value);
+            if (basic) {
+                try {
+                    const decoded = atob(basic[1]);
+                    const colon = decoded.indexOf(":");
+                    if (colon !== -1)
+                        warnShortSecret(decoded.slice(colon + 1), logger);
+                }
+                catch {
+                    /* Invalid Basic configuration is not a short password. */
+                }
+            }
+            else
+                warnShortSecret(value.replace(/^(?:Bearer|token)\s+/i, ""), logger);
+        }
+    }
+    const credentialAuth = opts.auth?.type === "credential" ? opts.auth : undefined;
+    if (credentialAuth?.credential?.fields?.length) {
+        throw new Error(`[connecta] connector "${id}" credential auth declares named fields; ` +
+            "this shape sends one secret in one header and reads the reserved " +
+            "`value` field only.");
+    }
+    // Both request shapes, read field by field; a mixture is refused below.
+    const requestAuth = opts.auth?.type === "request" ? opts.auth : undefined;
+    // Opt-in only: without it the resolver keeps receiving the context alone.
+    // `principal` replaces `token`; a malformed or mixed shape has no resolver.
+    const forwarding = requestAuth?.principal;
+    const requestToken = forwarding
+        ? requestAuth?.token === undefined && (forwarding.accept === "human" || forwarding.accept === "human-or-agent")
+            ? forwarding.token
+            : undefined
+        : requestAuth?.token;
+    if (requestAuth && (typeof requestToken !== "function" || opts.authScope === "personal")) {
+        throw new Error(`remoteMcp(${JSON.stringify(id)}) requires a request token callback and shared authScope.`);
+    }
+    const principalPolicy = forwarding?.accept;
+    const customFetch = opts.fetch;
+    // OAuth discovery, registration and token requests reach authorization
+    // servers the downstream names, through the owned credential sender. A
+    // custom fetch would split that traffic between two transports.
+    if (customFetch !== undefined && (typeof customFetch !== "function" || opts.auth?.type === "oauth")) {
+        throw new Error(`remoteMcp(${JSON.stringify(id)}).fetch must be a function, without OAuth auth.`);
+    }
+    // No delayed dispatch: a write counts as sent once it is handed to the function.
+    const customSender = customFetch && { send: customFetch };
+    if (requestAuth?.headers) {
+        try {
+            if (Object.keys(requestAuth.headers).some((name) => name.toLowerCase() === "authorization"))
+                throw new Error();
+            new Headers(requestAuth.headers);
+        }
+        catch {
+            throw new Error(`remoteMcp(${JSON.stringify(id)}) requires valid request auth headers without Authorization.`);
+        }
+    }
+    const credentialConfig = credentialAuth?.credential ?? {
+        label: "API key",
+    };
+    const credentialHeader = credentialAuth?.header?.trim() || "Authorization";
+    // A structural mistake in the deployment file, beside the `fields` refusal
+    // above: an unsendable header name is not worth discovering on the first
+    // request, where only a runtime error can report it.
+    if (credentialAuth && !HEADER_NAME_TOKEN.test(credentialHeader)) {
+        throw new Error(`[connecta] connector "${id}" credential auth declares header ` +
+            `"${credentialHeader}", which is not a valid HTTP field name.`);
+    }
+    // `undefined` means "not stated" and takes the bearer default; `null` and
+    // `""` both mean "send the stored value verbatim", which some providers
+    // require for a bare API key.
+    const credentialScheme = credentialAuth === undefined || credentialAuth.scheme === undefined
+        ? "Bearer"
+        : (credentialAuth.scheme?.trim() ?? "") || null;
+    // Check the destination scheme once at construction: buildTransport (and the
+    // SDK's fetch) attach any static credentials to every request, so an http://
+    // endpoint sends bearer tokens / API keys in cleartext. Loopback is exempt
+    // for local development.
+    const destination = new URL(opts.url);
+    // Only a web URL reaches a remote MCP server. Another scheme cannot, and a
+    // wrapping one (`blob:https://…`) would also carry its inner URL, userinfo
+    // and all, into every place the endpoint is reported; the value is not echoed.
+    if (destination.protocol !== "https:" && destination.protocol !== "http:") {
+        throw new Error(`[connecta] connector "${id}" url must be an http(s) URL.`);
+    }
+    const insecureDestination = destination.protocol !== "https:" && !isLoopbackHost(destination.hostname);
+    if (insecureDestination) {
+        if (opts.requireHttps || requestAuth) {
+            throw new Error(`[connecta] connector "${id}" url ${opts.url} is not https:// (and not loopback) — refusing to connect (requireHttps).`);
+        }
+        // Both static shapes send a secret on every request; that an operator
+        // typed one into the operator UI rather than a deployment file changes
+        // who owns it, not whether the wire carries it in the clear.
+        if (opts.auth?.type === "headers" || credentialAuth) {
+            logger.warn(`[connecta] connector "${id}" sends static credentials to ${opts.url} over a non-https:// connection — those tokens will be transmitted in cleartext.`);
+        }
+    }
+    const endpointOrigin = new URL(opts.url).origin;
+    return {
+        id,
+        opts,
+        requestAuth,
+        forwarding,
+        staticClient,
+        clientMetadataUrl,
+        oauthScope,
+        authorizationParams,
+        destination,
+        isOauth,
+        extraHeaders,
+        credentialHeader,
+        credentialScheme,
+        skillsEnabled,
+        principalPolicy,
+        credentialAuth,
+        customFetch,
+        customSender,
+        requestToken,
+        endpointOrigin,
+        credentialConfig,
+    };
+}