@zackbart/connecta 0.18.3 → 0.20.0

package/dist/index.js

@@ -42,71 +42,116 @@ function normalizeAuth(auth) {
         return rank(a) - rank(b);
     });
 }
-const LEGACY_CONFIG_MIGRATIONS = [
-    ["activityReadGate", "activity.readGate"],
-    ["activityDeploymentId", "activity.deploymentId"],
-    ["credentialEncryptionKey", "credentials.encryptionKey"],
-    ["toolCacheTtlSeconds", "discovery.catalogTtlSeconds"],
-    ["persistToolCatalog", "discovery.persistCatalog"],
-    ["toolCatalogStaleSeconds", "discovery.staleCatalogSeconds"],
-    ["probeTimeoutMs", "discovery.probeTimeoutMs"],
-    ["defaultToolTimeoutMs", "calls.defaultTimeoutMs"],
-    ["maxResultBytes", "calls.maxResultBytes"],
-];
-const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
-/**
- * Fail closed at the public boundary: a JavaScript caller on the v0.6 shape
- * must receive one complete migration error, never silently lose an option to
- * a default. This runs before createConnecta reads any other config field.
- */
-function assertNoLegacyConfig(config) {
-    const candidate = config;
-    if (hasOwn(candidate, "toolkits")) {
-        throw new Error("ConnectaConfig.toolkits was removed in issue #178. Deploy one " +
-            "connecta instance per audience instead; see ethos.md.");
-    }
-    const credentials = candidate.credentials;
-    const hasNestedHealth = typeof credentials === "object" &&
-        credentials !== null &&
-        hasOwn(credentials, "health");
-    if (hasOwn(candidate, "credentialHealth") || hasNestedHealth) {
-        throw new Error("`credentials.health` and legacy `credentialHealth` were removed in " +
-            "issue #179. Credentials now fail at use; see ethos.md.");
-    }
-    const calls = candidate.calls;
-    if (typeof calls === "object" &&
-        calls !== null &&
-        hasOwn(calls, "maxBatchResultBytes")) {
-        throw new Error("`calls.maxBatchResultBytes` was removed in issue #273 along with " +
-            "batch_call. Remove it; a program's batching is bounded by " +
-            "execute_code's own limits — connecta.batch's per-run call ceiling " +
-            "and the executor result cap — while each call inside it still honours " +
-            "calls.maxResultBytes and any per-connector override.");
-    }
-    const found = [];
-    if (hasOwn(candidate, "activity")) {
-        const activity = candidate.activity;
-        const isObject = typeof activity === "object" && activity !== null;
-        // A valid v0.6 ActivityStore can itself own a backend field named `store`.
-        // Its required `record` method (including a prototype method) therefore
-        // takes precedence over the otherwise-new wrapper shape.
-        const hasLegacyRecord = isObject &&
-            typeof activity.record === "function";
-        if (activity !== undefined &&
-            (!isObject ||
-                hasLegacyRecord ||
-                !hasOwn(activity, "store"))) {
-            found.push(["activity", "activity.store"]);
-        }
+const admissionPoolSchema = {
+    concurrency: null,
+    maxQueueSize: null,
+    queueTimeoutMs: null,
+    retryAfterMs: null,
+};
+const CONFIG_SCHEMA = {
+    connectors: null,
+    auth: null,
+    storage: null,
+    publicUrl: null,
+    activity: {
+        store: null,
+        readGate: null,
+        deploymentId: null,
+    },
+    credentials: {
+        encryptionKey: null,
+    },
+    accessTokens: {
+        maxActive: null,
+    },
+    discovery: {
+        concurrency: null,
+        catalogTtlSeconds: null,
+        persistCatalog: null,
+        staleCatalogSeconds: null,
+        probeTimeoutMs: null,
+    },
+    calls: {
+        defaultTimeoutMs: null,
+        maxResultBytes: null,
+    },
+    execute: {
+        maxEmittedBytes: null,
+        maxEmittedBlocks: null,
+    },
+    admission: {
+        requests: admissionPoolSchema,
+        code: admissionPoolSchema,
+    },
+    branding: {
+        productName: null,
+        productUrl: null,
+        ownerName: null,
+        ownerUrl: null,
+        description: null,
+        pageTitle: null,
+        favicon: {
+            svg: null,
+            ico: null,
+            href: null,
+        },
+        themeColor: null,
+    },
+    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]));
     }
-    for (const migration of LEGACY_CONFIG_MIGRATIONS) {
-        if (hasOwn(candidate, migration[0]))
-            found.push(migration);
+    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));
     }
-    if (found.length === 0)
+    return unknown;
+}
+function rejectUnknownOptions(paths) {
+    if (paths.length === 0)
         return;
-    throw new Error("Unsupported v0.6.x ConnectaConfig options. Migrate each path for v0.7.0:\n" +
-        found.map(([oldPath, newPath]) => `- ${oldPath} -> ${newPath}`).join("\n"));
+    throw new Error(`Unknown Connecta configuration option${paths.length === 1 ? "" : "s"}:\n` +
+        paths.map((path) => `- ${path}`).join("\n"));
+}
+/** Reject JavaScript typos and removed options before construction does work. */
+function assertKnownConfig(config) {
+    rejectUnknownOptions(unknownOptionPaths(config, "ConnectaConfig", CONFIG_SCHEMA));
+    const activity = config.activity;
+    if (activity !== undefined &&
+        (typeof activity !== "object" ||
+            activity === null ||
+            typeof activity.store?.record !== "function")) {
+        throw new Error("ConnectaConfig.activity.store must implement record(event)");
+    }
 }
 /**
  * One-time construction warnings for deployment shapes that run fine but are
@@ -193,11 +238,7 @@ function warnInsecureConfig(config, inboundAuth, logger) {
     }
 }
 export function createConnecta(config) {
-    assertNoLegacyConfig(config);
-    if (Object.prototype.hasOwnProperty.call(config, "surface")) {
-        throw new Error("ConnectaConfig.surface was removed in issue #273. Remove it; connecta " +
-            "now serves one seven-tool surface.");
-    }
+    assertKnownConfig(config);
     if (!config.executor) {
         throw new Error("ConnectaConfig.executor is required. Configure quickJsExecutor() from " +
             '"@zackbart/connecta/quickjs" on Node, or ' +
@@ -233,30 +274,20 @@ export function createConnecta(config) {
     const registry = new Registry(config.connectors, {
         storage,
         logger,
-        ...(credentialVault !== undefined ? { credentialVault } : {}),
-        ...(config.activity?.store !== undefined
+        credentialVault,
+        catalogDriftActivity: config.activity?.store
             ? {
-                catalogDriftActivity: {
-                    sink: config.activity.store,
-                    serverInfo,
-                    ...(config.activity.deploymentId !== undefined
-                        ? { deploymentId: config.activity.deploymentId }
-                        : {}),
-                },
+                sink: config.activity.store,
+                serverInfo,
+                ...(config.activity.deploymentId !== undefined
+                    ? { deploymentId: config.activity.deploymentId }
+                    : {}),
             }
-            : {}),
-        ...(config.discovery?.catalogTtlSeconds !== undefined
-            ? { toolCacheTtlSeconds: config.discovery.catalogTtlSeconds }
-            : {}),
-        ...(config.discovery?.persistCatalog !== undefined
-            ? { persistToolCatalog: config.discovery.persistCatalog }
-            : {}),
-        ...(config.discovery?.staleCatalogSeconds !== undefined
-            ? { toolCatalogStaleSeconds: config.discovery.staleCatalogSeconds }
-            : {}),
-        ...(config.calls?.maxResultBytes !== undefined
-            ? { maxResultBytes: config.calls.maxResultBytes }
-            : {}),
+            : undefined,
+        toolCacheTtlSeconds: config.discovery?.catalogTtlSeconds,
+        persistToolCatalog: config.discovery?.persistCatalog,
+        toolCatalogStaleSeconds: config.discovery?.staleCatalogSeconds,
+        maxResultBytes: config.calls?.maxResultBytes,
     });
     const inboundAuth = normalizeAuth(accessTokens ? [accessTokens.auth, ...configuredAuth] : configuredAuth);
     warnInsecureConfig(config, inboundAuth, logger);
@@ -279,44 +310,24 @@ export function createConnecta(config) {
     const handler = createFetchHandler({
         registry,
         auth: inboundAuth,
-        ...(config.publicUrl !== undefined ? { publicUrl: config.publicUrl } : {}),
+        publicUrl: config.publicUrl,
         serverInfo,
         logger,
-        ...(config.activity?.store !== undefined
-            ? { activity: config.activity.store }
-            : {}),
-        ...(config.activity?.readGate !== undefined
-            ? { activityReadGate: config.activity.readGate }
-            : {}),
-        ...(config.activity?.deploymentId !== undefined
-            ? { activityDeploymentId: config.activity.deploymentId }
-            : {}),
+        activity: config.activity?.store,
+        activityReadGate: config.activity?.readGate,
+        activityDeploymentId: config.activity?.deploymentId,
         executor,
-        ...(configuredExecutorName !== undefined
-            ? { executorName: configuredExecutorName }
-            : {}),
+        executorName: configuredExecutorName,
         requestAdmission,
-        ...(config.calls?.defaultTimeoutMs !== undefined
-            ? { defaultToolTimeoutMs: config.calls.defaultTimeoutMs }
-            : {}),
-        ...(config.discovery?.probeTimeoutMs !== undefined
-            ? { probeTimeoutMs: config.discovery.probeTimeoutMs }
-            : {}),
-        ...(config.discovery?.concurrency !== undefined
-            ? { discoveryConcurrency: config.discovery.concurrency }
-            : {}),
-        ...(config.execute?.maxEmittedBytes !== undefined
-            ? { maxEmittedBytes: config.execute.maxEmittedBytes }
-            : {}),
-        ...(config.execute?.maxEmittedBlocks !== undefined
-            ? { maxEmittedBlocks: config.execute.maxEmittedBlocks }
-            : {}),
-        ...(credentialVault !== undefined ? { credentialVault } : {}),
-        ...(accessTokens !== undefined ? { accessTokens } : {}),
-        ...(config.deploymentInfo !== undefined
-            ? { deploymentInfo: config.deploymentInfo }
-            : {}),
-        ...(config.branding !== undefined ? { branding: config.branding } : {}),
+        defaultToolTimeoutMs: config.calls?.defaultTimeoutMs,
+        probeTimeoutMs: config.discovery?.probeTimeoutMs,
+        discoveryConcurrency: config.discovery?.concurrency,
+        maxEmittedBytes: config.execute?.maxEmittedBytes,
+        maxEmittedBlocks: config.execute?.maxEmittedBlocks,
+        credentialVault,
+        accessTokens,
+        deploymentInfo: config.deploymentInfo,
+        branding: config.branding,
     });
     let closePromise;
     return {

package/dist/invocation.d.ts

@@ -57,7 +57,7 @@ export interface InvocationContext<T> {
     requestSignal?: AbortSignal;
     unwrapResult?: boolean;
     /**
-     * Caller-owned result policy. MCP passes fields + paging here; code mode
+     * Caller-owned result policy. MCP applies result paging here; code mode
      * normally accepts the already-unwrapped value unchanged.
      */
     processResult?: (value: unknown, resolved: ResolvedCatalogTool) => T | Promise<T>;