@zackbart/connecta 0.34.1 → 0.35.0

package/dist/oauth-handoff.js

@@ -1,3 +1,6 @@
+import { upwardStep } from "./upward.js";
+import { authCall, authInvoke, authFlow, authStorage, registerAuth } from "./auth/native.js";
+import { runEdge } from "./runtime/run.js";
 import { oauthConnectKeys } from "./storage/keys.js";
 const HANDOFF_TTL_MS = 15 * 60_000;
 const INTERACTIVE_OAUTH_REQUIRED = "An interactive provider (Clerk or Cloudflare Access) is required to connect OAuth connectors.";
@@ -71,124 +74,194 @@ export function oauthConnectUnavailable(opts) {
     }
     return undefined;
 }
-export async function oauthConnectUrl(opts, baseUrl, connectorId, principal, force = false, opaque = false) {
-    return (await oauthConnectLink(opts, baseUrl, connectorId, principal, force, opaque)).url;
+export function oauthConnectUrl(opts, baseUrl, connectorId, principal, force = false, opaque = false) {
+    return runEdge(oauthConnectUrlNative(opts, baseUrl, connectorId, principal, force, opaque));
 }
-export async function oauthConnectLink(opts, baseUrl, connectorId, principal, force = false, opaque = false, after) {
-    const unavailable = oauthConnectUnavailable(opts);
-    if (unavailable)
-        throw new Error(unavailable);
-    const connector = opts.registry.getConnector(connectorId);
-    if (!connector || !principal)
-        throw new Error("OAuth connection requires an initiating user identity.");
-    const handoff = {
-        connector: connectorId,
-        owner: connector.authScope === "personal" ? principal : "shared",
-        principal,
-        origin: new URL(baseUrl).origin,
-        expiresAt: Date.now() + HANDOFF_TTL_MS,
-        nonce: crypto.randomUUID(),
-        force,
-        ...(after ? { after } : {}),
-    };
-    const vault = opts.config.vault;
-    if (opaque && (!vault.seal || !vault.open))
-        throw new Error("URL elicitation requires a sealing credential vault.");
-    const compact = encodeHandoff(handoff);
-    const payload = opaque
-        ? `v4.${encodeSegment(await vault.seal(connectorId, "connecta:connect-link:v4", compact))}`
-        : `v3.${encodeSegment(compact)}`;
-    // Preserve the vault's entire signature and its representation, including
-    // custom vaults, while keeping every URL segment unpadded base64url.
-    const signature = encodeSegment(await vault.signOAuthHandoff(payload));
-    const url = new URL(`/connect/${connectorId}`, baseUrl);
-    url.searchParams.set("h", `${payload}.${signature}`);
-    return { url: url.toString(), nonce: handoff.nonce };
+const oauthConnectUrlNative = /* @__PURE__ */ registerAuth(oauthConnectUrl, function (opts, baseUrl, connectorId, principal, force = false, opaque = false) {
+    return authFlow(function* () {
+        return (yield* upwardStep(authCall(oauthConnectLink, [
+            opts,
+            baseUrl,
+            connectorId,
+            principal,
+            force,
+            opaque,
+        ]))).url;
+    });
+});
+export function oauthConnectLink(opts, baseUrl, connectorId, principal, force = false, opaque = false, after) {
+    return runEdge(oauthConnectLinkNative(opts, baseUrl, connectorId, principal, force, opaque, after));
 }
+const oauthConnectLinkNative = /* @__PURE__ */ registerAuth(oauthConnectLink, function (opts, baseUrl, connectorId, principal, force = false, opaque = false, after) {
+    return authFlow(function* () {
+        const unavailable = oauthConnectUnavailable(opts);
+        if (unavailable)
+            throw new Error(unavailable);
+        const connector = opts.registry.getConnector(connectorId);
+        if (!connector || !principal)
+            throw new Error("OAuth connection requires an initiating user identity.");
+        const handoff = {
+            connector: connectorId,
+            owner: connector.authScope === "personal" ? principal : "shared",
+            principal,
+            origin: new URL(baseUrl).origin,
+            expiresAt: Date.now() + HANDOFF_TTL_MS,
+            nonce: crypto.randomUUID(),
+            force,
+            ...(after ? { after } : {}),
+        };
+        const vault = opts.config.vault;
+        if (opaque && (!vault.seal || !vault.open))
+            throw new Error("URL elicitation requires a sealing credential vault.");
+        const compact = encodeHandoff(handoff);
+        const payload = opaque
+            ? `v4.${encodeSegment(yield* upwardStep(authInvoke(vault, "seal", [connectorId, "connecta:connect-link:v4", compact])))}`
+            : `v3.${encodeSegment(compact)}`;
+        // Preserve the vault's entire signature and its representation, including
+        // custom vaults, while keeping every URL segment unpadded base64url.
+        const signature = encodeSegment(yield* upwardStep(authInvoke(vault, "signOAuthHandoff", [payload])));
+        const url = new URL(`/connect/${connectorId}`, baseUrl);
+        url.searchParams.set("h", `${payload}.${signature}`);
+        return { url: url.toString(), nonce: handoff.nonce };
+    });
+});
 /** A claim precedes OAuth reset; only a completed start can prove recovery. */
-export async function oauthConnectLinkProgress(opts, baseUrl, id, nonce) {
-    const stage = await opts.registry.contextFor(id, baseUrl).storage.get(oauthConnectKeys.used(nonce));
-    return stage === "used" ? "claimed" : stage === "started" || stage === "failed" ? stage : undefined;
+export function oauthConnectLinkProgress(opts, baseUrl, id, nonce) {
+    return runEdge(oauthConnectLinkProgressNative(opts, baseUrl, id, nonce));
 }
+const oauthConnectLinkProgressNative = /* @__PURE__ */ registerAuth(oauthConnectLinkProgress, function (opts, baseUrl, id, nonce) {
+    return authFlow(function* () {
+        const stage = yield* upwardStep(authStorage(opts.registry.contextFor(id, baseUrl).storage, "get", [
+            oauthConnectKeys.used(nonce),
+        ]));
+        return stage === "used" ? "claimed" : stage === "started" || stage === "failed" ? stage : undefined;
+    });
+});
 /** Make outstanding flow links single-use refusals before a completion check. */
-export async function closeOAuthConnectLinks(opts, baseUrl, id, nonces) {
-    const storage = opts.registry.contextFor(id, baseUrl).storage;
-    for (const nonce of nonces) {
-        await storage.compareAndSet(oauthConnectKeys.used(nonce), null, "closed", { ttlSeconds: HANDOFF_TTL_MS / 1000 });
-    }
+export function closeOAuthConnectLinks(opts, baseUrl, id, nonces) {
+    return runEdge(closeOAuthConnectLinksNative(opts, baseUrl, id, nonces));
 }
+const closeOAuthConnectLinksNative = /* @__PURE__ */ registerAuth(closeOAuthConnectLinks, function (opts, baseUrl, id, nonces) {
+    return authFlow(function* () {
+        const storage = opts.registry.contextFor(id, baseUrl).storage;
+        for (const nonce of nonces) {
+            yield* upwardStep(authStorage(storage, "compareAndSet", [
+                oauthConnectKeys.used(nonce),
+                null,
+                "closed",
+                { ttlSeconds: HANDOFF_TTL_MS / 1000 },
+            ]));
+        }
+    });
+});
 /** Consuming a round prevents replay from creating sibling retry lineages. */
-export async function claimAuthRetry(opts, baseUrl, id, nonce) {
-    return opts.registry
-        .contextFor(id, baseUrl)
-        .storage.compareAndSet(oauthConnectKeys.retry(nonce), null, "used", { ttlSeconds: HANDOFF_TTL_MS / 1000 });
+export function claimAuthRetry(opts, baseUrl, id, nonce) {
+    return runEdge(claimAuthRetryNative(opts, baseUrl, id, nonce));
+}
+const claimAuthRetryNative = /* @__PURE__ */ registerAuth(claimAuthRetry, function (opts, baseUrl, id, nonce) {
+    return authFlow(function* () {
+        return yield* upwardStep(authStorage(opts.registry.contextFor(id, baseUrl).storage, "compareAndSet", [
+            oauthConnectKeys.retry(nonce),
+            null,
+            "used",
+            { ttlSeconds: HANDOFF_TTL_MS / 1000 },
+        ]));
+    });
+});
+export function verifyOAuthHandoff(opts, baseUrl, connectorId, token) {
+    return runEdge(verifyOAuthHandoffNative(opts, baseUrl, connectorId, token));
 }
-export async function verifyOAuthHandoff(opts, baseUrl, connectorId, token) {
-    if (!token || token.length > 4096)
-        return null;
-    try {
-        const parts = token.split(".");
-        let h;
-        if (parts.length === 3 && (parts[0] === "v3" || parts[0] === "v4")) {
-            const [version, body, signature] = parts;
-            const payload = `${version}.${body}`;
-            if (!(await opts.config.vault?.verifyOAuthHandoff?.(payload, decodeSegment(signature))))
+const verifyOAuthHandoffNative = /* @__PURE__ */ registerAuth(verifyOAuthHandoff, function (opts, baseUrl, connectorId, token) {
+    return authFlow(function* () {
+        if (!token || token.length > 4096)
+            return null;
+        try {
+            const parts = token.split(".");
+            let h;
+            if (parts.length === 3 && (parts[0] === "v3" || parts[0] === "v4")) {
+                const [version, body, signature] = parts;
+                const payload = `${version}.${body}`;
+                if (!(yield* upwardStep(authInvoke(opts.config.vault, "verifyOAuthHandoff", [
+                    payload,
+                    decodeSegment(signature),
+                ]))))
+                    return null;
+                const decoded = decodeSegment(body);
+                h = decodeHandoff(version === "v4"
+                    ? yield* upwardStep(authInvoke(opts.config.vault, "open", [connectorId, "connecta:connect-link:v4", decoded]))
+                    : decoded);
+            }
+            else {
+                // Keep pre-upgrade JSON and sealed v2 links until their original expiry.
+                // Authenticate their exact original text; never normalize before verifying.
+                const [payload, signature, ...rest] = parts;
+                if (!payload || !signature || rest.length)
+                    return null;
+                if (!(yield* upwardStep(authInvoke(opts.config.vault, "verifyOAuthHandoff", [payload, signature]))))
+                    return null;
+                h = JSON.parse(payload.startsWith("v2:")
+                    ? yield* upwardStep(authInvoke(opts.config.vault, "open", [
+                        connectorId,
+                        "connecta:connect-link:v2",
+                        atob(payload.slice(3)),
+                    ]))
+                    : atob(payload));
+            }
+            const connector = opts.registry.getConnector(connectorId);
+            if (!connector ||
+                h.connector !== connectorId ||
+                typeof h.principal !== "string" ||
+                !h.principal ||
+                h.owner !== (connector.authScope === "personal" ? h.principal : "shared") ||
+                h.origin !== new URL(baseUrl).origin ||
+                !Number.isSafeInteger(h.expiresAt) ||
+                h.expiresAt <= Date.now() ||
+                h.expiresAt > Date.now() + HANDOFF_TTL_MS ||
+                typeof h.nonce !== "string" ||
+                !h.nonce ||
+                typeof h.force !== "boolean")
                 return null;
-            const decoded = decodeSegment(body);
-            h = decodeHandoff(version === "v4" ? await opts.config.vault.open(connectorId, "connecta:connect-link:v4", decoded) : decoded);
-        }
-        else {
-            // Keep pre-upgrade JSON and sealed v2 links until their original expiry.
-            // Authenticate their exact original text; never normalize before verifying.
-            const [payload, signature, ...rest] = parts;
-            if (!payload || !signature || rest.length)
+            if (h.after !== undefined &&
+                (typeof h.after !== "string" || !/^[a-f0-9-]{36}$/.test(h.after) || h.after === h.nonce || h.force))
                 return null;
-            if (!(await opts.config.vault?.verifyOAuthHandoff?.(payload, signature)))
+            if (yield* upwardStep(authStorage(opts.registry.contextFor(connectorId, baseUrl).storage, "get", [
+                oauthConnectKeys.used(h.nonce),
+            ])))
                 return null;
-            h = JSON.parse(payload.startsWith("v2:")
-                ? await opts.config.vault.open(connectorId, "connecta:connect-link:v2", atob(payload.slice(3)))
-                : atob(payload));
+            return h;
         }
-        const connector = opts.registry.getConnector(connectorId);
-        if (!connector ||
-            h.connector !== connectorId ||
-            typeof h.principal !== "string" ||
-            !h.principal ||
-            h.owner !== (connector.authScope === "personal" ? h.principal : "shared") ||
-            h.origin !== new URL(baseUrl).origin ||
-            !Number.isSafeInteger(h.expiresAt) ||
-            h.expiresAt <= Date.now() ||
-            h.expiresAt > Date.now() + HANDOFF_TTL_MS ||
-            typeof h.nonce !== "string" ||
-            !h.nonce ||
-            typeof h.force !== "boolean")
-            return null;
-        if (h.after !== undefined &&
-            (typeof h.after !== "string" || !/^[a-f0-9-]{36}$/.test(h.after) || h.after === h.nonce || h.force))
+        catch {
             return null;
-        if (await opts.registry.contextFor(connectorId, baseUrl).storage.get(oauthConnectKeys.used(h.nonce)))
-            return null;
-        return h;
-    }
-    catch {
-        return null;
-    }
-}
+        }
+    });
+});
 /** Claim only after browser identity and permissions pass, before starting OAuth. */
-export async function consumeOAuthConnectLink(opts, handoff) {
-    if (handoff.expiresAt <= Date.now())
-        return false;
-    const storage = opts.registry.contextFor(handoff.connector, handoff.origin).storage;
-    if (handoff.after && (await storage.get(oauthConnectKeys.used(handoff.after))) !== "started")
-        return false;
-    const expiry = { ttlSeconds: Math.max(1, Math.ceil((handoff.expiresAt - Date.now()) / 1000)) };
-    return storage.compareAndSet(oauthConnectKeys.used(handoff.nonce), null, "used", expiry);
+export function consumeOAuthConnectLink(opts, handoff) {
+    return runEdge(consumeOAuthConnectLinkNative(opts, handoff));
 }
+const consumeOAuthConnectLinkNative = /* @__PURE__ */ registerAuth(consumeOAuthConnectLink, function (opts, handoff) {
+    return authFlow(function* () {
+        if (handoff.expiresAt <= Date.now())
+            return false;
+        const storage = opts.registry.contextFor(handoff.connector, handoff.origin).storage;
+        if (handoff.after &&
+            (yield* upwardStep(authStorage(storage, "get", [oauthConnectKeys.used(handoff.after)]))) !==
+                "started")
+            return false;
+        const expiry = { ttlSeconds: Math.max(1, Math.ceil((handoff.expiresAt - Date.now()) / 1000)) };
+        return yield* upwardStep(authStorage(storage, "compareAndSet", [oauthConnectKeys.used(handoff.nonce), null, "used", expiry]));
+    });
+});
 /** Terminal marker only after the start and every tracked reset have settled. */
-export async function finishOAuthConnectStart(opts, handoff, outcome) {
-    if (handoff.expiresAt <= Date.now())
-        return false;
-    const storage = opts.registry.contextFor(handoff.connector, handoff.origin).storage;
-    const expiry = { ttlSeconds: Math.max(1, Math.ceil((handoff.expiresAt - Date.now()) / 1000)) };
-    return storage.compareAndSet(oauthConnectKeys.used(handoff.nonce), "used", outcome, expiry);
+export function finishOAuthConnectStart(opts, handoff, outcome) {
+    return runEdge(finishOAuthConnectStartNative(opts, handoff, outcome));
 }
+const finishOAuthConnectStartNative = /* @__PURE__ */ registerAuth(finishOAuthConnectStart, function (opts, handoff, outcome) {
+    return authFlow(function* () {
+        if (handoff.expiresAt <= Date.now())
+            return false;
+        const storage = opts.registry.contextFor(handoff.connector, handoff.origin).storage;
+        const expiry = { ttlSeconds: Math.max(1, Math.ceil((handoff.expiresAt - Date.now()) / 1000)) };
+        return yield* upwardStep(authStorage(storage, "compareAndSet", [oauthConnectKeys.used(handoff.nonce), "used", outcome, expiry]));
+    });
+});

package/dist/oauth-partition.js

@@ -1,7 +1,10 @@
+import { Context } from "effect";
+import { serviceFor, setViewService } from "./runtime/call.js";
 // Registry-owned identity for downstream credential coordination. Storage
 // wrappers are rebuilt per context, and epochs can be identical across owners.
 // Keep this beside the context rather than widening the public connector API.
-const partitions = new WeakMap();
+class OAuthPartition extends Context.Service()("connecta/operation/OAuthPartition") {
+}
 const activeWork = new WeakMap();
 export function retainOAuthPartition(partition) {
     if (!partition)
@@ -19,31 +22,14 @@ export function retainOAuthPartition(partition) {
             activeWork.set(partition, remaining);
     };
 }
-/**
- * Wrap one connector operation so its owner partition stays pinned from the
- * first asynchronous storage read to the end, not only once a refresh flight
- * exists: an idle personal registry can otherwise be evicted mid-flow. Status
- * and auth operations take no call admission, so nothing else holds it.
- */
-export function retainingOAuthPartition(operation, contextIndex) {
-    return async (...args) => {
-        const release = retainOAuthPartition(oauthPartitionFor(args[contextIndex]));
-        try {
-            return await operation(...args);
-        }
-        finally {
-            release();
-        }
-    };
-}
 export function oauthPartitionIdle(partition) {
     return !activeWork.has(partition);
 }
 export function attachOAuthPartition(ctx, partition) {
     if (partition)
-        partitions.set(ctx, partition);
+        setViewService(ctx, OAuthPartition, partition);
     return ctx;
 }
 export function oauthPartitionFor(ctx) {
-    return partitions.get(ctx);
+    return serviceFor(ctx, OAuthPartition);
 }

package/dist/oauth-sealing.js

@@ -1,9 +1,12 @@
+import { Context } from "effect";
+import { serviceFor, setViewService } from "./runtime/call.js";
 /**
  * Contexts the registry built with a sealing vault. Internal on purpose: the
  * public ConnectorContext type does not change, and a connector cannot hand
  * itself a sealer another connector's context carries.
  */
-const sealers = new WeakMap();
+class OAuthSealer extends Context.Service()("connecta/operation/OAuthSealer") {
+}
 /** A sealer over the vault, or undefined when the vault cannot seal. */
 export function vaultOAuthSealer(vault, connectorId, owner, logger) {
     const { seal, open } = vault;
@@ -17,15 +20,11 @@ export function vaultOAuthSealer(vault, connectorId, owner, logger) {
 }
 export function attachOAuthSealer(ctx, sealer) {
     if (sealer)
-        sealers.set(ctx, sealer);
+        setViewService(ctx, OAuthSealer, sealer);
     return ctx;
 }
 export function oauthSealerFor(ctx) {
-    return sealers.get(ctx);
-}
-/** Carry the sealer onto a context derived by spreading another. */
-export function inheritOAuthSealer(from, to) {
-    return attachOAuthSealer(to, sealers.get(from));
+    return serviceFor(ctx, OAuthSealer);
 }
 /** A separate HMAC key for browser handoffs, derived from the credential key. */
 export async function deriveOAuthHandoffKey(raw) {

package/dist/operation-vocabulary.js

@@ -0,0 +1,101 @@
+// Private, request-free discovery facts. No provider, schema, handler or I/O dependency.
+import { lexicalSearchContent, lexicalQueryTerms } from "./catalog.js";
+const tools = new WeakMap();
+const connectors = new WeakMap();
+export const OPERATION_VOCABULARY_BOUNDS = {
+    operations: 8192,
+    rowChars: 1024,
+    chars: 2_097_152,
+    terms: 8,
+    queryChars: 200,
+    cache: 128,
+};
+const token = (word) => word.endsWith("ies")
+    ? `${word.slice(0, -3)}y`
+    : word.endsWith("s") && !word.endsWith("ss")
+        ? word.slice(0, -1)
+        : word;
+const aliases = {
+    retrieve: "get",
+    read: "get",
+    fetch: "get",
+    find: "list",
+    search: "list",
+    add: "create",
+    new: "create",
+    edit: "update",
+    change: "update",
+    modify: "update",
+    remove: "delete",
+};
+const terms = (text) => [
+    ...new Set(lexicalQueryTerms(lexicalSearchContent(text)).map((word) => aliases[word] ?? token(word))),
+];
+/** Register only construction-authored compact summaries; never whole request/response schemas. */
+export function registerOperationVocabulary(tool, rows) {
+    let postings;
+    const routes = [];
+    const cache = new Map();
+    tools.set(tool, (query, visible, safety, readOnly) => {
+        if (query.length > OPERATION_VOCABULARY_BOUNDS.queryChars)
+            return false;
+        const wanted = terms(query);
+        if (!wanted.length || wanted.length > OPERATION_VOCABULARY_BOUNDS.terms)
+            return false;
+        if (!postings) {
+            postings = new Map();
+            let chars = 0;
+            for (const row of rows()) {
+                const text = row.text.slice(0, OPERATION_VOCABULARY_BOUNDS.rowChars);
+                if (routes.length >= OPERATION_VOCABULARY_BOUNDS.operations ||
+                    chars + text.length > OPERATION_VOCABULARY_BOUNDS.chars)
+                    break;
+                chars += text.length;
+                const id = routes.length;
+                routes.push({ route: row.route, write: row.write });
+                for (const word of terms(text)) {
+                    const hits = postings.get(word);
+                    if (hits)
+                        hits.push(id);
+                    else
+                        postings.set(word, [id]);
+                }
+            }
+        }
+        const key = wanted.join(" ");
+        let found = cache.get(key);
+        if (!found) {
+            const lists = wanted.map((word) => postings.get(word) ?? []).sort((a, b) => a.length - b.length);
+            const rest = lists.slice(1).map((list) => new Set(list));
+            found = lists[0].filter((id) => rest.every((set) => set.has(id)));
+            if (cache.size >= OPERATION_VOCABULARY_BOUNDS.cache)
+                cache.delete(cache.keys().next().value);
+            cache.set(key, found);
+        }
+        return found.some((id) => {
+            const row = routes[id];
+            if (row.write && readOnly)
+                return false;
+            if ((safety === "readOnly" && row.write) || (safety === "approvalRequired" && !row.write))
+                return false;
+            return row.route !== undefined && visible.has(row.route);
+        });
+    });
+}
+/** Move private facts across the public ApiTool -> Connector construction boundary. */
+export function registerConnectorVocabulary(connector, declarations) {
+    const entries = declarations.flatMap((tool) => {
+        const vocabulary = tools.get(tool);
+        return vocabulary ? [[tool.name, vocabulary]] : [];
+    });
+    if (entries.length)
+        connectors.set(connector, new Map(entries));
+}
+export function operationVocabularyMatches(connector, catalog, query, safety, readOnly) {
+    const registered = connectors.get(connector);
+    if (!registered)
+        return [];
+    const visible = new Set(catalog.map((tool) => tool.name));
+    return catalog.filter((tool) => tool.classification === "read" &&
+        registered.get(tool.name)?.(query, visible, safety, readOnly || connector.readOnly === true));
+}

package/dist/operator-record.d.ts

@@ -8,7 +8,7 @@ type FailureStep = "MCP handshake" | "tools/list" | "tools/call" | "resources/re
  */
 export declare const OAUTH_ERROR_CODES: ReadonlySet<string>;
 /** Inbound denial facts, never identity text or provider diagnostics. */
-export type AuthDenialReason = "authentication_failed" | "authorization_header_invalid" | "token_type_mismatch" | "oauth_verification_failed" | "oauth_client_not_allowed" | "oauth_binding_mismatch" | "session_origin_mismatch" | "user_missing" | "email_lookup_failed" | "verified_email_invalid" | "email_domain_denied" | "gate_denied" | "gate_failed" | "not_maintainer" | "pool_not_declared" | "not_pool_member";
+export type AuthDenialReason = "authentication_abandoned_saturated" | "authentication_busy" | "authentication_failed" | "authentication_unreachable" | "authorization_header_invalid" | "token_type_mismatch" | "oauth_verification_failed" | "oauth_client_not_allowed" | "oauth_binding_mismatch" | "session_origin_mismatch" | "token_identity_mismatch" | "organization_membership_denied" | "organization_lookup_failed" | "organization_lookup_busy" | "user_missing" | "email_lookup_failed" | "verified_email_invalid" | "email_domain_denied" | "gate_denied" | "gate_failed" | "not_maintainer" | "pool_not_declared" | "not_pool_member";
 /**
  * Name `ctor`'s instances `label` in records and fixed text. Call once, at
  * module scope, beside the class. An error whose prototype chain reaches no
@@ -104,7 +104,7 @@ export declare function failureRecord(subject: FailureSubject, failure?: unknown
  * The events an operator log reports failures as. Closed: a new one is a
  * reviewed line here, never a string assembled at the call site.
  */
-export type FailureEvent = "negotiation cache read failed" | "negotiation cache write failed" | "pool tool grant is unreachable" | "call failed" | "input schema unusable; arguments are not validated" | "catalog read failed" | "catalog persistence failed" | "catalog invalidation failed" | "catalog refresh observation failed" | "catalog refresh failed; serving stale catalog" | "deferred catalog refresh failed" | "deferred catalog refresh could not attach to the runtime" | "catalog drift check failed" | "schema digest check failed; serving digested reviews as writes" | "credential shape read failed" | "credential test failed" | "credential test threw" | "session termination refused or failed; the downstream session may remain until its provider timeout" | "activity record failed" | "catalog drift record failed" | "activity read failed" | "OAuth start failed" | "OAuth disconnect failed" | "OAuth callback verifyState threw; no authorization code was exchanged" | "OAuth callback handoff could not be consumed; no authorization code was exchanged" | "MCP default endpoint request denied" | "MCP pool request denied" | "MCP agent endpoint request denied" | "OAuth error callback consent could not be consumed; no authorization code was exchanged" | "MCP handler error" | "operator status" | "operator agent slots read failed" | "result paging unavailable" | "request failed" | "Clerk request denied" | "Clerk authentication failed";
+export type FailureEvent = "Authentication admission refused" | "Authentication released after its pending work became unreachable" | "negotiation cache read failed" | "negotiation cache write failed" | "pool tool grant is unreachable" | "call failed" | "input schema unusable; arguments are not validated" | "catalog read failed" | "catalog persistence failed" | "catalog invalidation failed" | "catalog refresh observation failed" | "catalog refresh failed; serving stale catalog" | "deferred catalog refresh failed" | "deferred catalog refresh could not attach to the runtime" | "catalog drift check failed" | "schema digest check failed; serving digested reviews as writes" | "credential shape read failed" | "credential test failed" | "credential test threw" | "session termination refused or failed; the downstream session may remain until its provider timeout" | "activity record failed" | "catalog drift record failed" | "activity read failed" | "OAuth start failed" | "OAuth disconnect failed" | "OAuth callback verifyState threw; no authorization code was exchanged" | "OAuth callback handoff could not be consumed; no authorization code was exchanged" | "MCP default endpoint request denied" | "MCP pool request denied" | "MCP agent endpoint request denied" | "OAuth error callback consent could not be consumed; no authorization code was exchanged" | "MCP handler error" | "operator status" | "operator agent slots read failed" | "result paging unavailable" | "native catalog unavailable" | "native name collision" | "native tools/list refused a pool over the 1,000-tool native cap" | "request failed" | "Clerk request denied" | "Clerk authentication failed";
 /**
  * Log one failure as `[connecta] <event>` and its record. A record
  * `failureRecord` did not build is replaced, whatever its shape, by a fixed

package/dist/operator-record.js

@@ -47,6 +47,8 @@
 // documentation/architecture.md, "Errors and records"). Core's sent-secrets
 // boundary removes credentials used by the upstream request from those answers, including
 // allowed diagnostics, tool results and nested error causes/data (INV-5).
+import { carryProviderFailure } from "./provider-call-facts.js";
+import { followRedactedCopies, keepErrorName } from "./redaction-identity.js";
 import { classificationCode, ConnectorCallError, NETWORK_ERROR_CODES, WithheldTextError, } from "./errors.js";
 const STEPS = new Set([
     "MCP handshake",
@@ -88,6 +90,7 @@ export const OAUTH_ERROR_CODES = new Set([
     "unapproved_software_statement",
 ]);
 const SOURCES = new Set([
+    "native",
     "call_tool",
     "call_destructive_tool",
     "batch_call",
@@ -99,13 +102,20 @@ const STATUS_STATES = new Set(["ok", "auth_required", "credential_required", "er
 /** A status state, or `failed` for a status that could not be read at all. */
 const STATES = new Set([...STATUS_STATES, "failed"]);
 const AUTH_DENIAL_REASONS = new Set([
+    "authentication_abandoned_saturated",
+    "authentication_busy",
     "authentication_failed",
+    "authentication_unreachable",
     "authorization_header_invalid",
     "token_type_mismatch",
     "oauth_verification_failed",
     "oauth_client_not_allowed",
     "oauth_binding_mismatch",
     "session_origin_mismatch",
+    "token_identity_mismatch",
+    "organization_membership_denied",
+    "organization_lookup_failed",
+    "organization_lookup_busy",
     "user_missing",
     "email_lookup_failed",
     "verified_email_invalid",
@@ -146,6 +156,8 @@ export function labelErrorClass(ctor, label) {
         throw new TypeError(`Invalid error class label "${label}"`);
     labels.set(ctor.prototype, label);
     labelNames.add(label);
+    // A label is a literal and the class's own name, so redaction keeps it as its instances' name.
+    keepErrorName(ctor, label);
 }
 for (const [ctor, label] of [
     [Error, "Error"],
@@ -224,7 +236,7 @@ function defined(key, value) {
  * Facts attached to failures by identity, never as properties: nothing about
  * the failure's own shape changes, and nothing a caller can see grows.
  */
-const attached = new WeakMap();
+const attached = followRedactedCopies(new WeakMap());
 /** Note what connecta knows about `failure` for any record made of it later. */
 export function attachFailureFacts(failure, facts) {
     if (failure !== null && typeof failure === "object") {
@@ -234,6 +246,7 @@ export function attachFailureFacts(failure, facts) {
 }
 /** The facts and class label of `from`, kept for `to` (its classified form, say). */
 export function carryFailureFacts(from, to) {
+    carryProviderFailure(from, to);
     if (to === null || typeof to !== "object")
         return to;
     const facts = from !== null && typeof from === "object" ? attached.get(from) : undefined;
@@ -243,7 +256,7 @@ export function carryFailureFacts(from, to) {
     attached.set(to, { ...carried, ...attached.get(to) });
     return to;
 }
-const built = new WeakSet();
+const built = followRedactedCopies(new WeakSet());
 function count(value, max) {
     return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= max
         ? Math.round(value)
@@ -282,7 +295,7 @@ function checkedSubject(subject) {
  * identity. A plain object is read as one only when registered here: a thrown
  * object shaped like a classification is just a thrown object.
  */
-const classifications = new WeakSet();
+const classifications = followRedactedCopies(new WeakSet());
 /** Vouch for `details` as a classification connecta itself computed. */
 export function classifiedFailure(details) {
     classifications.add(details);
@@ -363,7 +376,7 @@ export function describeFailure(connectorId, failure) {
     const kind = [record.errorClass, record.code, record.errno].filter(Boolean).join(", ");
     return `Connector "${record.connector}"${where} failed${status}${oauth}${kind ? ` (${kind})` : ""}.`;
 }
-const ownStatuses = new WeakMap();
+const ownStatuses = followRedactedCopies(new WeakMap());
 function snapshot(status, failure) {
     return {
         state: member(status.state, STATUS_STATES) ?? "error",

package/dist/operator-ui/agents.d.ts

@@ -1,4 +1,4 @@
-import type { OperatorUiContractV2 } from "./contract.js";
+import type { OperatorAgent, OperatorUiContractV2 } from "./contract.js";
 import { type Notice, type RequestFailureFacts, type Tone } from "./view.js";
 /**
  * The Tokens page's rows, computed from the slot list and contract v2 alone.
@@ -30,7 +30,8 @@ export interface AgentRow {
     name: string;
     /** Pools it belongs to, from `agents[].pools`; empty when the contract does not list it. */
     pools: string[];
-    slot: AgentSlot;
+    credentialTypes: OperatorAgent["credentialTypes"];
+    slot: AgentSlot | null;
     /**
      * Whether `slot` comes from the live slot list. Only a live slot can be
      * acted on: one known only from the contract may be stale, so its controls
@@ -58,12 +59,12 @@ export declare function resolveSlot(contract: OperatorUiContractV2 | null, slots
  * the contract lists. The contract adds pools and last seen.
  */
 export declare function agentRows(contract: OperatorUiContractV2 | null, slots: AgentSlot[], unresolved?: readonly string[]): AgentRow[];
-export declare function slotBadge(slot: Pick<AgentSlot, "state">): {
+export declare function slotBadge(slot: Pick<AgentSlot, "state"> | null): {
     label: string;
     tone: Tone;
 };
 /** When the slot last changed, issued or revoked (its badge says which); a dash when it never has. */
-export declare function slotSince(slot: AgentSlot, format: (value: string) => string): string;
+export declare function slotSince(slot: AgentSlot | null, format: (value: string) => string): string;
 export declare function lastSeenLabel(lastSeenAt: string | null, format: (value: string) => string): string;
 /**
  * Why a token operation did not land, in fixed sentences keyed by status.