@zackbart/connecta 0.28.1 → 0.29.0

package/dist/index.js

@@ -1,232 +1,14 @@
-import { credentialTestRule, describeCredentialTestMismatch, } from "./credential-rules.js";
+import { describeConfigSources } from "./config-value-sources.js";
+import { credentialTestRule, describeCredentialTestMismatch } from "./credential-rules.js";
 import { Registry } from "./registry.js";
-import { intersectAccess, parseConnectorAccess, POOL_NAME_RE } from "./connector-access.js";
+import { parseConnectorAccess, POOL_NAME_RE } from "./connector-access.js";
 import { createFetchHandler } from "./server.js";
-import { createExecuteTool, runClaimMs } from "./execute.js";
-import { droppedBrandingUrls, droppedThemeTokens, droppedUiAuthUrls, } from "./branding.js";
-import { memoryStorage } from "./storage/memory.js";
-import { CONNECTA_VERSION } from "./version.js";
-import { AdmissionController, executorName, isAdmittingExecutor, withExecutorAdmission, } from "./executor-admission.js";
-import { DEFAULT_MAX_WRITES } from "./exempt-writes.js";
-import { disposeEdgeRuntime } from "./runtime/run.js";
-import { NO_EXEMPTIONS } from "./tool-safety.js";
-import { createCoreRuntime, resolveLogger } from "./runtime/services.js";
-const REQUEST_ADMISSION_DEFAULTS = {
-    concurrency: 16,
-    maxQueueSize: 32,
-    queueTimeoutMs: 5_000,
-    retryAfterMs: 1_000,
-};
-const DEFAULT_REQUEST_MAX_DURATION_MS = 300_000;
-const CODE_ADMISSION_DEFAULTS = {
-    concurrency: 2,
-    maxQueueSize: 8,
-    queueTimeoutMs: 5_000,
-    retryAfterMs: 1_000,
-};
-function admissionController(options, defaults, maxDurationMs) {
-    return new AdmissionController({
-        concurrency: options?.concurrency ?? defaults.concurrency,
-        maxQueueSize: options?.maxQueueSize ?? defaults.maxQueueSize,
-        queueTimeoutMs: options?.queueTimeoutMs ?? defaults.queueTimeoutMs,
-        retryAfterMs: options?.retryAfterMs ?? defaults.retryAfterMs,
-        ...(maxDurationMs !== undefined ? { maxDurationMs } : {}),
-    });
-}
-/** Bearer providers are checked before Clerk (per spec). */
-function normalizeAuth(auth) {
-    const list = auth ? (Array.isArray(auth) ? auth : [auth]) : [];
-    return [...list].sort((a, b) => {
-        const rank = (x) => (x.kind === "bearer" ? 0 : 1);
-        return rank(a) - rank(b);
-    });
-}
-const admissionPoolSchema = {
-    concurrency: null,
-    maxQueueSize: null,
-    queueTimeoutMs: null,
-    retryAfterMs: null,
-};
-const requestAdmissionSchema = {
-    ...admissionPoolSchema,
-    maxDurationMs: null,
-};
-const CONFIG_SCHEMA = {
-    connectors: null,
-    auth: null,
-    identity: {
-        connectorAccess: null,
-        activityAccess: null,
-        credentialAdministration: null,
-        personalConnection: null,
-        accessTokenManagement: null,
-    },
-    pools: null,
-    storage: null,
-    publicUrl: null,
-    allowedOrigins: null,
-    activity: null,
-    vault: null,
-    ui: null,
-    artifacts: null,
-    accessTokens: null,
-    artifactOrigin: null,
-    discovery: {
-        concurrency: null,
-        catalogTtlSeconds: null,
-        persistCatalog: null,
-        staleCatalogSeconds: null,
-        probeTimeoutMs: null,
-    },
-    results: {
-        maxStashBytes: null,
-        maxStashEntries: null,
-    },
-    calls: {
-        defaultTimeoutMs: null,
-        maxResultBytes: null,
-    },
-    execute: {
-        maxEmittedBytes: null,
-        maxEmittedBlocks: null,
-        maxHostCalls: null,
-        hostCallTimeoutMs: null,
-        watchdogMs: null,
-        maxWrites: null,
-        approval: null,
-    },
-    admission: {
-        requests: requestAdmissionSchema,
-        code: admissionPoolSchema,
-    },
-    logger: null,
-    serverInfo: {
-        name: null,
-        version: null,
-        title: null,
-        websiteUrl: null,
-        icons: [
-            {
-                src: null,
-                mimeType: null,
-                sizes: null,
-            },
-        ],
-    },
-    deploymentInfo: null,
-    executor: null,
-};
-function unknownOptionPaths(value, path, schema) {
-    if (schema === null)
-        return [];
-    if (Array.isArray(schema)) {
-        if (!Array.isArray(value))
-            return [];
-        return value.flatMap((entry, index) => unknownOptionPaths(entry, `${path}[${index}]`, schema[0]));
-    }
-    if (typeof value !== "object" || value === null)
-        return [];
-    const known = new Set(Object.keys(schema));
-    const unknown = Reflect.ownKeys(value)
-        .filter((key) => typeof key !== "string" || !known.has(key))
-        .map((key) => `${path}.${String(key)}`)
-        .sort();
-    if (unknown.length > 0)
-        return unknown;
-    for (const [key, childSchema] of Object.entries(schema)) {
-        unknown.push(...unknownOptionPaths(value[key], `${path}.${key}`, childSchema));
-    }
-    return unknown;
-}
-/** Pause-only options #672 removed with `resume_execution`. */
-const RETIRED_PAUSE_OPTIONS = [
-    "ConnectaConfig.execute.resumableWrites",
-    "ConnectaConfig.execute.pausedRunTtlSeconds",
-];
-function rejectUnknownOptions(paths) {
-    if (paths.length === 0)
-        return;
-    throw new Error(`Unknown Connecta configuration option${paths.length === 1 ? "" : "s"}:\n` +
-        paths.map((path) => `- ${path}`).join("\n") +
-        (paths.includes("ConnectaConfig.credentials") ? "\nUse vault: encryptedCredentialVault(storage, key) from @zackbart/connecta/credentials." : "") +
-        (paths.includes("ConnectaConfig.branding") ? "\nMove branding into ui: operatorUi({ branding }) from @zackbart/connecta/ui." : "") +
-        (paths.some((path) => RETIRED_PAUSE_OPTIONS.includes(path))
-            ? "\nPrograms no longer pause at writes, so there is nothing to configure: execute_code runs read-only and config-exempt tools, and every other write goes through call_destructive_tool (issue #672). Delete the option."
-            : ""));
-}
-/** Reject JavaScript typos and removed options before construction does work. */
-function assertKnownConfig(config) {
-    rejectUnknownOptions(unknownOptionPaths(config, "ConnectaConfig", CONFIG_SCHEMA));
-    if (config.results !== undefined) {
-        if (!config.results || typeof config.results !== "object" || Array.isArray(config.results)) {
-            throw new Error("ConnectaConfig.results must be an object");
-        }
-        for (const key of ["maxStashBytes", "maxStashEntries"]) {
-            const value = config.results[key];
-            if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) {
-                throw new Error(`ConnectaConfig.results.${key} must be a non-negative safe integer`);
-            }
-        }
-    }
-    if (config.vault && (["get", "getAll", "set", "setAll", "metadata", "delete"].some(key => typeof config.vault[key] !== "function") || ["seal", "open"].some(key => !["undefined", "function"].includes(typeof config.vault[key]))))
-        throw new Error("ConnectaConfig.vault must implement CredentialVault");
-    if (config.ui && (typeof config.ui.handle !== "function" || typeof config.ui.credentialHandoffUrl !== "function" || !Array.isArray(config.ui.reservedPaths)))
-        throw new Error("ConnectaConfig.ui must be created with operatorUi(...)");
-    const activity = config.activity;
-    if (activity !== undefined &&
-        (typeof activity !== "object" ||
-            activity === null ||
-            typeof activity.recordTool !== "function")) {
-        throw new Error("ConnectaConfig.activity must be created with activityHistory(...)");
-    }
-    if (config.accessTokens !== undefined && (!config.accessTokens ||
-        typeof config.accessTokens.auth?.authorize !== "function" ||
-        config.accessTokens.auth.interactiveOperator ||
-        typeof config.accessTokens.handle !== "function")) {
-        throw new Error("ConnectaConfig.accessTokens must be created with accessTokens(storage) from @zackbart/connecta/auth/access-tokens; reuse your existing storage to preserve tokens");
-    }
-    const artifacts = config.artifacts;
-    if (artifacts !== undefined) {
-        const connector = artifacts?.connector;
-        if (typeof artifacts !== "object" ||
-            artifacts === null ||
-            !connector ||
-            connector.id !== "artifacts" ||
-            typeof connector.callTool !== "function" ||
-            typeof artifacts.handle !== "function") {
-            throw new Error("ConnectaConfig.artifacts must be created with artifacts(...) from @zackbart/connecta/artifacts");
-        }
-        if (config.connectors?.some((candidate) => candidate?.id === "artifacts")) {
-            throw new Error('Connector id "artifacts" is reserved by the artifacts module; rename ' +
-                "your connector or drop the artifacts option");
-        }
-        if (!config.publicUrl) {
-            throw new Error("ConnectaConfig.artifacts needs publicUrl: artifact links are shared " +
-                "with teammates, so they must name the deployment's own origin, never " +
-                "one taken from a request's Host header");
-        }
-    }
-    if (config.artifactOrigin !== undefined) {
-        if (!config.artifacts || !config.ui || !config.publicUrl) {
-            throw new Error("ConnectaConfig.artifactOrigin needs artifacts, ui, and publicUrl");
-        }
-        if (typeof config.artifactOrigin !== "string") {
-            throw new Error("ConnectaConfig.artifactOrigin must be an HTTPS origin");
-        }
-        let origin;
-        try {
-            origin = new URL(config.artifactOrigin);
-        }
-        catch {
-            throw new Error("ConnectaConfig.artifactOrigin must be an HTTPS origin");
-        }
-        if (origin.protocol !== "https:" ||
-            origin.toString() !== `${origin.origin}/` ||
-            origin.origin === new URL(config.publicUrl).origin) {
-            throw new Error("ConnectaConfig.artifactOrigin must be a distinct HTTPS origin");
-        }
-    }
-}
+import { droppedBrandingUrls, droppedThemeTokens, droppedUiAuthUrls } from "./branding.js";
+import { readConfig } from "./config.js";
+import { describeConfig } from "./describe-config.js";
+export { customExecutor } from "./executor-contract.js";
+import { AdmissionController, executorName, isAdmittingExecutor, withExecutorAdmission } from "./executor-admission.js";
+export { defineConfig } from "./config.js";
 /**
  * Validate declared pools against the connector set. Everything checkable at
  * construction throws here: a malformed name, an unparseable grant, an
@@ -238,27 +20,13 @@ function resolvePools(pools, registry) {
     const resolved = new Map();
     if (!pools)
         return resolved;
-    if (typeof pools !== "object" || Array.isArray(pools)) {
-        throw new Error("ConnectaConfig.pools must be an object keyed by pool name");
-    }
+    // The schema has already refused a pool that is not an object, a missing or
+    // non-array `tools`, a non-function `grant`, and a misspelled key — a
+    // misspelled `grant` would otherwise boot as a deny-all pool.
     for (const [name, pool] of Object.entries(pools)) {
         if (!POOL_NAME_RE.test(name)) {
             throw new Error(`ConnectaConfig.pools: pool name "${name}" must match [a-z0-9_-]+`);
         }
-        if (!pool || typeof pool !== "object" || !Array.isArray(pool.tools)) {
-            throw new Error(`ConnectaConfig.pools.${name}: tools must be an array of connector ids or connector.tool addresses`);
-        }
-        if (pool.grant !== undefined && typeof pool.grant !== "function") {
-            throw new Error(`ConnectaConfig.pools.${name}: grant must be a function`);
-        }
-        // A misspelled `grant` would otherwise boot as a deny-all pool with only a
-        // per-request log line to say so; that is fail-closed, but the rule here
-        // is that structural mistakes refuse to boot.
-        for (const key of Object.keys(pool)) {
-            if (key !== "tools" && key !== "grant") {
-                throw new Error(`ConnectaConfig.pools.${name}: unknown option "${key}"`);
-            }
-        }
         let access;
         try {
             access = parseConnectorAccess(pool.tools);
@@ -284,92 +52,24 @@ function resolvePools(pools, registry) {
                 }
             }
         }
-        resolved.set(name, { access, grant: pool.grant ?? (() => false) });
+        resolved.set(name, { access, trust: pool.trust, grant: pool.grant ?? (() => false) });
     }
     return resolved;
 }
-/**
- * Validate `execute.approval` against the connector set, like the pools: a
- * malformed key or value, an unknown connector, and an `api()` address its
- * tools do not include all throw. Remote catalogs load lazily, so an address
- * on one is kept and simply never matches a tool it does not serve.
- */
-function resolveApprovalPolicy(approval, registry) {
-    for (const connector of registry.listConnectors()) {
-        if (connector.approval !== undefined && connector.approval !== "never") {
-            throw new Error(`Connector "${connector.id}": approval must be "never" or omitted`);
-        }
-    }
-    if (approval === undefined)
-        return NO_EXEMPTIONS;
-    if (!approval || typeof approval !== "object" || Array.isArray(approval)) {
-        throw new Error("ConnectaConfig.execute.approval must be an object keyed by connector ids and connector.tool addresses");
-    }
-    const connectors = new Map();
-    const tools = new Map();
-    for (const [key, value] of Object.entries(approval)) {
-        const where = `ConnectaConfig.execute.approval[${JSON.stringify(key)}]`;
-        if (value !== "never" && value !== "ask") {
-            throw new Error(`${where} must be "never" or "ask"`);
-        }
-        const dot = key.indexOf(".");
-        const id = dot === -1 ? key : key.slice(0, dot);
-        const tool = dot === -1 ? undefined : key.slice(dot + 1);
-        if (!id || tool === "") {
-            throw new Error(`${where}: keys are connector ids or connector.tool addresses`);
-        }
-        const connector = registry.getConnector(id);
-        if (!connector)
-            throw new Error(`${where}: unknown connector "${id}"`);
-        if (tool === undefined) {
-            connectors.set(id, value);
-            continue;
-        }
-        if (connector.staticTools &&
-            !connector.staticTools.some((candidate) => candidate.name === tool)) {
-            throw new Error(`${where}: connector "${id}" has no tool "${tool}"`);
-        }
-        tools.set(key, value);
-    }
-    return { connectors, tools };
-}
-/** A positive whole number, or the default when the value is unusable. */
-function positiveWhole(value, fallback) {
-    return typeof value === "number" && Number.isFinite(value) && value >= 1
-        ? Math.trunc(value)
-        : fallback;
-}
-/**
- * One-time construction warnings for deployment shapes that run fine but are
- * usually unintended. Warning-only — never throws and never changes behavior;
- * each deployment-wide condition emits at most one `logger.warn`, and each
- * per-connector condition at most one per connector it names.
- */
-function warnInsecureConfig(config, inboundAuth, logger) {
+/** Construction warnings for valid but usually unintended deployment choices. */
+function warnInsecureConfig(config) {
+    const { auth: inboundAuth, logger } = config;
     const oauthConnectors = config.connectors.filter((c) => c.finishAuth);
     const hasCredentialConnector = config.connectors.some((c) => c.credential);
     // Static API headers can carry secrets without declaring credential hooks.
     // Any configured connector warrants the open-deployment warning.
-    if (inboundAuth.length === 0 &&
-        (config.connectors.length > 0 || config.artifacts)) {
+    if (inboundAuth.length === 0 && config.connectors.length > 0) {
         logger.warn("[connecta] running with no inbound authentication: any caller can " +
             "invoke every shared connector. " +
             (hasCredentialConnector || oauthConnectors.length > 0
                 ? "Configured credentials and downstream OAuth grants are exposed to those calls. "
                 : "") +
-            "Configure `auth` (for example bearerToken(...) or Clerk) to gate access.");
-    }
-    // Artifact pages mount inside the operator UI and open only for an
-    // authenticated viewer; either missing leaves the connector with no page.
-    if (config.artifacts && !config.ui) {
-        logger.warn("[connecta] artifacts is configured without ui: agents can publish and " +
-            "read artifacts, but there is no viewer, so their links answer 404. " +
-            "Add ui: operatorUi() to serve artifact pages.");
-    }
-    else if (config.artifacts && inboundAuth.length === 0) {
-        logger.warn("[connecta] artifacts is configured with no inbound authentication: " +
-            "artifact pages refuse every request, because there is no team to " +
-            "show them to. Configure `auth` to open them.");
+            "Configure Clerk, Cloudflare Access on Workers, or accessTokens(storage) to gate access.");
     }
     // Unset publicUrl with OAuth connectors: the downstream redirect_uri is
     // derived per-request from the attacker-influenced inbound Host header.
@@ -463,177 +163,68 @@ function warnInsecureConfig(config, inboundAuth, logger) {
     }
 }
 export function createConnecta(config) {
-    assertKnownConfig(config);
-    if (!config.executor) {
-        throw new Error("ConnectaConfig.executor is required. Configure quickJsExecutor() from " +
-            '"@zackbart/connecta/quickjs" on Node, or ' +
-            "new DynamicWorkerExecutor({ loader: env.LOADER }) from " +
-            '"@cloudflare/codemode" on Workers.');
-    }
-    const storage = config.storage ?? memoryStorage();
-    const logger = resolveLogger(config.logger);
-    const credentialVault = config.vault;
-    const configuredAuth = normalizeAuth([
-        ...(config.accessTokens ? [config.accessTokens.auth] : []),
-        ...normalizeAuth(config.auth),
-    ]);
-    const serverInfo = {
-        ...config.serverInfo,
-        name: config.serverInfo?.name ?? "connecta",
-        version: config.serverInfo?.version ?? CONNECTA_VERSION,
-    };
-    // The artifacts module contributes one prebuilt connector, appended like any
-    // configured one: same catalog, invocation, admission, and activity.
-    const connectors = config.artifacts
-        ? [...config.connectors, config.artifacts.connector]
-        : config.connectors;
-    const registry = new Registry(connectors, {
+    // Every structural check runs here, before any work: what comes back is the
+    // configuration the deployment runs with, defaults applied once.
+    const { input, resolved } = readConfig(config);
+    const { logger } = resolved;
+    const storage = resolved.storage;
+    const registry = new Registry([...resolved.connectors], {
         storage,
         logger,
-        credentialVault,
-        credentialUi: Boolean(config.ui),
-        catalogDriftActivity: config.activity?.store
+        publicUrl: resolved.publicUrl,
+        oauthClientName: resolved.serverInfo.name,
+        credentialVault: resolved.vault,
+        credentialUi: Boolean(resolved.ui),
+        catalogDriftActivity: resolved.activity?.store
             ? {
-                sink: config.activity.store,
-                recordDrift: config.activity.recordDrift,
-                serverInfo,
-                ...(config.activity.deploymentId !== undefined
-                    ? { deploymentId: config.activity.deploymentId }
-                    : {}),
+                sink: resolved.activity.store,
+                recordChange: resolved.activity.recordChange,
+                serverInfo: resolved.serverInfo,
+                ...(resolved.activity.deploymentId !== undefined ? { deploymentId: resolved.activity.deploymentId } : {}),
             }
             : undefined,
-        toolCacheTtlSeconds: config.discovery?.catalogTtlSeconds,
-        persistToolCatalog: config.discovery?.persistCatalog,
-        toolCatalogStaleSeconds: config.discovery?.staleCatalogSeconds,
-        maxResultBytes: config.calls?.maxResultBytes,
-        results: config.results,
+        toolCacheTtlSeconds: resolved.discovery.catalogTtlSeconds,
+        catalogMinTtlSeconds: resolved.discovery.catalogMinTtlSeconds,
+        catalogMaxTtlSeconds: resolved.discovery.catalogMaxTtlSeconds,
+        maxResultBytes: resolved.calls.maxResultBytes,
+        results: resolved.results,
+        classification: resolved.classification,
     });
-    const inboundAuth = configuredAuth;
-    const pools = resolvePools(config.pools, registry);
-    const approval = resolveApprovalPolicy(config.execute?.approval, registry);
-    const maxWrites = positiveWhole(config.execute?.maxWrites, DEFAULT_MAX_WRITES);
-    warnInsecureConfig(config, inboundAuth, logger);
-    const requestAdmission = admissionController(config.admission?.requests, REQUEST_ADMISSION_DEFAULTS, config.admission?.requests?.maxDurationMs ?? DEFAULT_REQUEST_MAX_DURATION_MS);
-    const configuredCodeAdmission = admissionController(config.admission?.code, CODE_ADMISSION_DEFAULTS);
+    const pools = resolvePools(resolved.pools, registry);
+    warnInsecureConfig(resolved);
+    const requestAdmission = new AdmissionController(resolved.admission.requests);
     let codeAdmission;
-    let executor = config.executor;
+    let executor = resolved.executor;
     // Read the identity off the configured executor, before any wrapper hides
     // it behind an anonymous object literal.
     const configuredExecutorName = executorName(executor);
-    if (!isAdmittingExecutor(executor)) {
-        codeAdmission = configuredCodeAdmission;
+    const executorAdmits = isAdmittingExecutor(executor);
+    if (!executorAdmits) {
+        codeAdmission = new AdmissionController(resolved.admission.code);
         executor = withExecutorAdmission(executor, codeAdmission);
     }
-    else if (config.admission?.code) {
+    else if (input.admission?.code) {
         logger.warn("[connecta] admission.code is ignored because the configured executor " +
             "implements acquire() and owns its admission pool; configure that " +
             "executor's concurrency and queue options instead.");
     }
-    if (config.artifacts?.bindRefresh) {
-        const sharedIds = registry.listConnectors()
-            .filter((connector) => connector.id !== "artifacts" && connector.authScope !== "personal")
-            .map((connector) => connector.id);
-        const refreshConfig = {
-            discoveryConcurrency: config.discovery?.concurrency,
-            probeTimeoutMs: config.discovery?.probeTimeoutMs,
-            maxEmittedBytes: config.execute?.maxEmittedBytes,
-            maxEmittedBlocks: config.execute?.maxEmittedBlocks,
-            maxHostCalls: config.execute?.maxHostCalls,
-            hostCallTimeoutMs: config.execute?.hostCallTimeoutMs,
-            watchdogMs: config.execute?.watchdogMs,
-            failOnInvocationFailure: true,
-            // A connector's own `approval: "never"` still applies when policy maps
-            // are empty. Override every shared connector explicitly for refresh.
-            approval: {
-                connectors: new Map(sharedIds.map((id) => [id, "ask"])),
-                tools: new Map(),
-            },
-        };
-        config.artifacts.bindRefresh({
-            ...(config.ui?.branding ? { branding: config.ui.branding } : {}),
-            claimMs: runClaimMs(refreshConfig),
-            execute: async (program, owner, signal) => {
-                if (!owner)
-                    throw new Error("Refresh owner is missing; reconfigure this program.");
-                let access = parseConnectorAccess(config.identity?.connectorAccess
-                    ? await config.identity.connectorAccess(owner.identity) : "all", { allowReadOnly: true });
-                if (owner.pool) {
-                    const pool = pools.get(owner.pool);
-                    if (!pool || await pool.grant(owner.identity) !== true) {
-                        throw new Error("Refresh owner's pool grant is no longer available.");
-                    }
-                    access = intersectAccess(access, pool.access);
-                }
-                if (access.connectorIds !== "all" && !access.connectorIds.includes("artifacts")) {
-                    throw new Error("Refresh owner no longer has artifact publishing access.");
-                }
-                if (access.toolAccess?.get("artifacts") &&
-                    !access.toolAccess.get("artifacts").has("set_refresh")) {
-                    throw new Error("Refresh owner no longer has refresh configuration access.");
-                }
-                if (access.guardedToolAccess?.get("artifacts")?.has("set_refresh")) {
-                    throw new Error("A read-only guarded grant cannot configure refresh.");
-                }
-                access = intersectAccess(access, { connectorIds: sharedIds });
-                if (signal.aborted)
-                    throw new Error("Refresh deadline expired before execution.");
-                const view = registry.scoped({ connectorIds: access.connectorIds,
-                    ...(access.toolAccess ? { toolAccess: access.toolAccess } : {}),
-                    ...(access.guardedToolAccess ? { guardedToolAccess: access.guardedToolAccess } : {}) });
-                const execute = createExecuteTool(view, config.publicUrl, executor, logger, undefined, refreshConfig);
-                return execute({ code: program }, { signal });
-            },
-        });
-    }
-    // Every structural check has passed, so this is the configuration the
-    // deployment runs with. Creating the runtime builds nothing — a Worker may
-    // construct its Connecta at global scope, where no fiber may start.
-    const runtime = createCoreRuntime(registry, {
-        storage,
-        logger,
-        vault: credentialVault,
-        activity: config.activity,
-        config: {
-            config,
-            serverInfo,
-            auth: inboundAuth,
-            pools,
-            executorName: configuredExecutorName,
-        },
+    // Built once, from values construction already validated; never per call.
+    const description = describeConfig({
+        registry,
+        raw: input,
+        config: resolved,
+        executorName: configuredExecutorName,
+        executorAdmits,
     });
     const handler = createFetchHandler({
+        config: resolved,
+        configDescription: description,
+        configValueSources: describeConfigSources(description, input),
         registry,
-        auth: inboundAuth,
-        identity: config.identity,
         pools,
-        publicUrl: config.publicUrl,
-        artifactOrigin: config.artifactOrigin,
-        allowedOrigins: config.allowedOrigins,
-        serverInfo,
-        logger,
-        activity: config.activity?.store,
-        activityModule: config.activity,
-        artifactsModule: config.artifacts,
-        accessTokens: config.accessTokens,
-        activityReadGate: config.activity?.readGate,
-        activityDeploymentId: config.activity?.deploymentId,
         executor,
         executorName: configuredExecutorName,
         requestAdmission,
-        defaultToolTimeoutMs: config.calls?.defaultTimeoutMs,
-        probeTimeoutMs: config.discovery?.probeTimeoutMs,
-        discoveryConcurrency: config.discovery?.concurrency,
-        maxEmittedBytes: config.execute?.maxEmittedBytes,
-        maxEmittedBlocks: config.execute?.maxEmittedBlocks,
-        maxHostCalls: config.execute?.maxHostCalls,
-        hostCallTimeoutMs: config.execute?.hostCallTimeoutMs,
-        watchdogMs: config.execute?.watchdogMs,
-        approval,
-        maxWrites,
-        credentialVault,
-        ui: config.ui,
-        deploymentInfo: config.deploymentInfo,
-        branding: config.ui?.branding,
     });
     let closePromise;
     return {
@@ -641,20 +232,13 @@ export function createConnecta(config) {
             ? ctx
             : undefined),
         registry,
+        describeConfig: () => description,
         close: async () => {
             closePromise ??= Promise.resolve().then(async () => {
-                try {
-                    requestAdmission.close();
-                    codeAdmission?.close();
-                    registry.closeCallAdmission();
-                    await config.executor?.close?.();
-                }
-                finally {
-                    // Last, and whether or not the executor closed cleanly. A fiber
-                    // already running keeps the services it was given; only a run
-                    // started after this is refused.
-                    await disposeEdgeRuntime(runtime);
-                }
+                requestAdmission.close();
+                codeAdmission?.close();
+                registry.closeCallAdmission();
+                await resolved.executor.close?.();
             });
             await closePromise;
         },
@@ -662,6 +246,8 @@ export function createConnecta(config) {
 }
 export { remoteMcp } from "./connectors/remote-mcp.js";
 export { api } from "./connectors/api.js";
+export { keys, optionsOf, array, opaque, instance, strings, variants } from "./config-schema.js";
+export { defineProvider, PROVIDER_COMMON } from "./provider.js";
 export { ConnectorCallError } from "./errors.js";
 // The same argument validation api() performs, usable by connectors that
 // implement the Connector interface directly. Returns the error rather than
@@ -669,3 +255,4 @@ export { ConnectorCallError } from "./errors.js";
 export { validateToolInput } from "./validate.js";
 export { memoryStorage } from "./storage/memory.js";
 export { CONNECTA_VERSION } from "./version.js";
+export { META_TOOL_NAMES } from "./meta-tool-names.js";