@zackbart/connecta 0.26.2 → 0.27.0

package/dist/auth/downstream-oauth.js

@@ -428,6 +428,19 @@ function waitForRefreshFlight(flight, signal) {
  * operation, so a second isolate can still race the same refresh token.
  */
 export class OAuthRefreshCoordinator {
+    retainPartition;
+    constructor(retainPartition = () => () => { }) {
+        this.retainPartition = retainPartition;
+    }
+    /** Keep an accepted credential write alive independently of its caller. */
+    retainWork() {
+        return this.retainPartition();
+    }
+    releaseFlightPartition(flight) {
+        if (flight.settled && !flight.answerPending && !flight.recoveryPending) {
+            flight.releasePartition();
+        }
+    }
     flights = new Map();
     /** Opaque identities only: no request promise, signal, callback, or response. */
     pendingMutations = new Map();
@@ -457,8 +470,10 @@ export class OAuthRefreshCoordinator {
         if (this.flights.get(generation) !== flight)
             return;
         this.flights.delete(generation);
+        flight.settled = true;
         this.advanceStateRevision();
         flight.stopObservingOwnerAbort();
+        this.releaseFlightPartition(flight);
         // Last, because joined fibers resume inside this call.
         Deferred.doneUnsafe(flight.outcome, Effect.succeed(outcome));
     }
@@ -582,7 +597,11 @@ export class OAuthRefreshCoordinator {
                     stopObservingOwnerAbort: () => { },
                     mutationId: {},
                     writing: false,
-                    persist: (tokens) => provider.saveTokens(tokens),
+                    answerPending: true,
+                    recoveryPending: false,
+                    settled: false,
+                    releasePartition: this.retainWork(),
+                    persist: (tokens) => provider.saveAcceptedRefreshTokens(tokens, generation, flight),
                 };
                 this.flights.set(generation, flight);
                 this.advanceStateRevision();
@@ -628,7 +647,11 @@ export class OAuthRefreshCoordinator {
                     if (!this.markMutationPending(generation, flight)) {
                         // Already settled (the owner was cancelled first). Still write the
                         // rotation: losing it would leave a dead credential.
-                        detach(Effect.promise(() => flight.persist(accepted)));
+                        flight.recoveryPending = true;
+                        detach(Effect.promise(() => flight.persist(accepted)).pipe(Effect.ensuring(Effect.sync(() => {
+                            flight.recoveryPending = false;
+                            this.releaseFlightPartition(flight);
+                        }))));
                         return Effect.fail(new Error("OAuth refresh ended before tokens could be saved."));
                     }
                     // The SDK holds the answer from here, after this fiber is gone, so
@@ -639,6 +662,11 @@ export class OAuthRefreshCoordinator {
                     }
                     return Effect.succeed(response);
                 };
+                const finishAnswer = Effect.sync(() => {
+                    flight.answerPending = false;
+                    this.releaseFlightPartition(flight);
+                });
+                const commitAnswer = (value) => commit(value).pipe(Effect.ensuring(finishAnswer));
                 // The owner's redemption. Its abort interrupts the wait for the token
                 // endpoint and nothing after it: an answer, once it exists, is
                 // committed before anyone is released, so no caller is let go to
@@ -647,7 +675,7 @@ export class OAuthRefreshCoordinator {
                 // as the foreground would have.
                 const redemption = Effect.uninterruptibleMask((restore) => restore(Effect.tryPromise({ try: () => answer, catch: (error) => error })).pipe(Effect.onInterrupt(() => Effect.sync(() => {
                     this.fail(generation, flight, aborted(requestSignal));
-                    detach(Effect.promise(() => answer).pipe(Effect.flatMap(commit)));
+                    detach(Effect.promise(() => answer).pipe(Effect.flatMap(commitAnswer), Effect.ensuring(finishAnswer)));
                 })), Effect.catch((error) => {
                     // No answer at all — the network, or a body too large to be
                     // one — is an outage. A refusal connecta itself raised (a
@@ -661,9 +689,13 @@ export class OAuthRefreshCoordinator {
                         : undefined;
                     if (verdict)
                         provider.recordRefreshFailure(verdict);
+                    flight.answerPending = false;
                     this.fail(generation, flight, error, verdict);
+                    // Retirement may already have removed the flight from the map.
+                    // Its rejected answer still finishes the retained partition work.
+                    this.releaseFlightPartition(flight);
                     return Effect.fail(error);
-                }), Effect.flatMap(commit)));
+                }), Effect.flatMap(commitAnswer)));
                 return await runEdge(requestSignal
                     ? Effect.raceAllFirst([
                         redemption,
@@ -712,6 +744,7 @@ export class OAuthRefreshCoordinator {
         if (tokens !== undefined &&
             this.pendingMutations.get(generation) === flight.mutationId) {
             flight.writing = true;
+            flight.recoveryPending = true;
             const written = (outcome) => {
                 if (this.finishMutation(generation, flight)) {
                     this.settle(generation, flight, outcome);
@@ -723,7 +756,10 @@ export class OAuthRefreshCoordinator {
             }).pipe(Effect.match({
                 onSuccess: () => written({ status: "refreshed" }),
                 onFailure: (error) => written({ status: "failed", error }),
-            })));
+            }), Effect.ensuring(Effect.sync(() => {
+                flight.recoveryPending = false;
+                this.releaseFlightPartition(flight);
+            }))));
             return;
         }
         // A response alone is not a write and must never strand the generation.
@@ -850,6 +886,8 @@ export class KvOAuthProvider {
     signal;
     clientBinding;
     onReset;
+    scope;
+    clientMetadataUrl;
     /**
      * The reset generation this provider's flow started under. Every OAuth value
      * it writes carries this epoch, so a late write can land after a reset without
@@ -869,7 +907,9 @@ export class KvOAuthProvider {
     /** Stable connector configuration bound to dynamically registered clients. */
     clientBinding, 
     /** Request-local observer so the operator route drains every reset it began. */
-    onReset) {
+    onReset, 
+    /** SDK uses this only when the authorization server advertises support. */
+    clientMetadataUrl, scope) {
         this.connectorId = connectorId;
         this.storage = storage;
         this.redirectUri = redirectUri;
@@ -879,6 +919,9 @@ export class KvOAuthProvider {
         this.signal = signal;
         this.clientBinding = clientBinding;
         this.onReset = onReset;
+        this.scope = scope;
+        if (clientMetadataUrl !== undefined)
+            this.clientMetadataUrl = clientMetadataUrl;
     }
     /**
      * Stamp the force-reauth generation the current connect flow started under.
@@ -994,7 +1037,7 @@ export class KvOAuthProvider {
      * check-then-write race: a late old write cannot overwrite a replacement
      * flow's value because the two writes have different physical keys.
      */
-    async writeValue(key, value, serializeLegacy, issuer, writtenAt, binding) {
+    async writeValue(key, value, serializeLegacy, issuer, writtenAt, binding, commitAcceptedRefresh = false) {
         const generation = await this.writeGeneration();
         await this.storeInGeneration(key, generation, () => {
             const stored = {
@@ -1008,7 +1051,7 @@ export class KvOAuthProvider {
             return isModernGeneration(generation) || issuer !== undefined
                 ? JSON.stringify(stored)
                 : serializeLegacy(value);
-        });
+        }, undefined, commitAcceptedRefresh);
     }
     /**
      * The generation fence every write goes through: refuse unless `generation`
@@ -1018,8 +1061,8 @@ export class KvOAuthProvider {
      * still hold exactly that raw value, so re-encoding cannot resurrect a value
      * another request replaced in the meantime.
      */
-    async storeInGeneration(key, generation, serialize, expected) {
-        if (this.signal?.aborted ||
+    async storeInGeneration(key, generation, serialize, expected, commitAcceptedRefresh = false) {
+        if ((!commitAcceptedRefresh && this.signal?.aborted) ||
             generation.startsWith(RESETTING_GENERATION_PREFIX) ||
             generation.startsWith(DISCONNECTED_GENERATION_PREFIX) ||
             (await this.generation()) !== generation) {
@@ -1033,7 +1076,7 @@ export class KvOAuthProvider {
                 sealed: await this.sealer.seal(physicalKey, plaintext),
             })
             : plaintext;
-        if (this.signal?.aborted)
+        if (!commitAcceptedRefresh && this.signal?.aborted)
             return;
         if (expected === undefined) {
             await this.storage.set(physicalKey, serialized);
@@ -1045,7 +1088,7 @@ export class KvOAuthProvider {
         // before this set, remove the now-unreachable residue ourselves. The epoch
         // key already provides correctness; this second check is physical hygiene.
         const current = await this.generation();
-        if (current !== generation || this.signal?.aborted) {
+        if (current !== generation || (!commitAcceptedRefresh && this.signal?.aborted)) {
             try {
                 // On cancellation the generation may still be active. A newer flow
                 // could have written this key while the old storage set was pending.
@@ -1209,12 +1252,26 @@ export class KvOAuthProvider {
      * returning no credentials, so every isolate drops the old registration and
      * token set and the SDK starts authorization from scratch.
      */
-    async readIssuerBoundValue(key, parseLegacy, serializeLegacy, ctx) {
-        const stored = await this.readValue(key, parseLegacy);
-        if (!stored || !ctx)
-            return stored?.value;
+    async readIssuerBoundValue(key, parseLegacy, ctx) {
+        const read = await this.readStoredValue(key, parseLegacy);
+        if (!read)
+            return undefined;
+        const stored = read.stored;
+        if (!ctx || stored.issuer !== undefined) {
+            if (read.plaintextCredential) {
+                await this.sealInPlace(key, stored.generation, read.raw);
+            }
+            if (!ctx)
+                return stored.value;
+        }
         if (stored.issuer === undefined) {
-            await this.writeValue(key, stored.value, serializeLegacy, ctx.issuer);
+            // Binding is a migration of the value just read, never a new grant.
+            // A rotation or revocation that replaced it must win this race.
+            await this.storeInGeneration(key, stored.generation, () => JSON.stringify({
+                connectaOAuthVersion: STORED_VALUE_VERSION,
+                ...stored,
+                issuer: ctx.issuer,
+            }), read.raw);
             return stored.value;
         }
         if (stored.issuer === ctx.issuer)
@@ -1339,10 +1396,11 @@ export class KvOAuthProvider {
             grant_types: ["authorization_code", "refresh_token"],
             response_types: ["code"],
             token_endpoint_auth_method: "none",
+            ...(this.scope !== undefined ? { scope: this.scope } : {}),
         };
     }
     async clientInformation(ctx) {
-        return this.readIssuerBoundValue("oauth:client", (raw) => JSON.parse(raw), (value) => JSON.stringify(value), ctx);
+        return this.readIssuerBoundValue("oauth:client", (raw) => JSON.parse(raw), ctx);
     }
     async saveClientInformation(info, ctx) {
         await this.writeValue("oauth:client", info, (value) => JSON.stringify(value), ctx?.issuer, undefined, this.clientBinding);
@@ -1358,7 +1416,7 @@ export class KvOAuthProvider {
         const successIdentity = refreshGeneration !== undefined
             ? this.refreshCoordinator?.successfulRefreshIdentity(refreshGeneration)
             : undefined;
-        const tokens = await this.readIssuerBoundValue("oauth:tokens", (raw) => JSON.parse(raw), (value) => JSON.stringify(value), ctx);
+        const tokens = await this.readIssuerBoundValue("oauth:tokens", (raw) => JSON.parse(raw), ctx);
         if (ctx && tokens && refreshGeneration !== undefined) {
             this.refreshBasis = {
                 accessToken: tokens.access_token,
@@ -1372,16 +1430,35 @@ export class KvOAuthProvider {
         return tokens;
     }
     async saveTokens(tokens, ctx) {
+        const owned = this.refreshFlight;
+        if (owned?.flight.acceptedTokens !== undefined) {
+            await this.persistAcceptedTokens(tokens, ctx, owned);
+        }
+        else {
+            await this.persistTokens(tokens, ctx, false, owned);
+        }
+    }
+    /** @internal Commit an already redeemed rotation even after its request leaves. */
+    async saveAcceptedRefreshTokens(tokens, generation, flight) {
+        await this.persistAcceptedTokens(tokens, undefined, { generation, flight });
+    }
+    persistAcceptedTokens(tokens, ctx, owned) {
+        // The SDK can save the same response while cancellation recovery is
+        // writing it. A second write could land after the next rotation, so both
+        // paths await this exact flight's one commit, including its failure.
+        return owned.flight.persistence ??= this.persistTokens(tokens, ctx, true, owned);
+    }
+    async persistTokens(tokens, ctx, commitAcceptedRefresh, owned) {
+        const releasePartition = this.refreshCoordinator?.retainWork();
         // A retired flight (the owner was cancelled or superseded after the
         // token response) still writes: the authorization server has already
         // consumed the old refresh token, so dropping the rotated one would leave a
         // dead credential. writeValue itself refuses when the generation moved.
         // Only the coordinator bookkeeping belongs to the exact live flight.
-        const owned = this.refreshFlight;
         const coordinated = owned !== undefined &&
             this.refreshCoordinator?.beginMutation(owned.generation, owned.flight) === true;
         try {
-            await this.writeValue("oauth:tokens", tokens, (value) => JSON.stringify(value), ctx?.issuer);
+            await this.writeValue("oauth:tokens", tokens, (value) => JSON.stringify(value), ctx?.issuer, undefined, undefined, commitAcceptedRefresh);
             if (coordinated)
                 this.refreshCoordinator?.succeedMutation(owned.generation, owned.flight);
             this.refreshFailure = undefined;
@@ -1396,6 +1473,7 @@ export class KvOAuthProvider {
             // already detached the provider's flight while storage was pending.
             if (this.refreshFlight === owned)
                 this.refreshFlight = undefined;
+            releasePartition?.();
         }
     }
     /**
@@ -1594,22 +1672,11 @@ export class KvOAuthProvider {
         // old physical namespace is unreadable. There is deliberately no second
         // "finalize" write: concurrent resets therefore cannot overwrite a newer
         // reset's epoch after their cleanup finishes out of order.
-        try {
-            await this.storage.set("oauth:generation", active);
-            this.refreshCoordinator?.retire(previous);
-        }
-        catch (error) {
-            try {
-                await this.deleteAll([
-                    cleanupBacklogKey(active),
-                    cleanupTimesKey(active),
-                ]);
-            }
-            catch {
-                // Best-effort removal of a manifest for an epoch never activated.
-            }
-            throw error;
-        }
+        // A rejection may follow a committed fence. Keep its lineage even when
+        // the answer is lost: the next reset must still find the retired grants.
+        // A manifest for an epoch that never activated is harmless residue.
+        await this.storage.set("oauth:generation", active);
+        this.refreshCoordinator?.retire(previous);
         if (reusableClient && !this.signal?.aborted) {
             // readValue opened the old physical key; writeValue seals the plaintext
             // under the new one. Copying ciphertext would fail its AAD check.

package/dist/connector-scope.d.ts

@@ -1,4 +1,6 @@
 import type { Connector, ConnectorContext } from "./types.js";
+export declare function claimConnectorScopeCleanup(ctx: ConnectorContext, connectorId: string): () => void;
+export declare function connectorScopeCleanupClaimed(ctx: ConnectorContext, connectorId: string): boolean;
 /** Runtime hook for work that may safely continue after a response is ready. */
 export type DeferredWork = (promise: Promise<unknown>) => void;
 /**

package/dist/connector-scope.js

@@ -1,5 +1,32 @@
 import { closeScope } from "./runtime/connector-scope.js";
 import { runEdge } from "./runtime/run.js";
+// Internal ownership for credential probes invoked by a route. Context copies
+// keep the requestScope, and each connector retains its own cleanup ownership.
+// Standalone connector tests still close themselves.
+const cleanupOwners = new WeakMap();
+export function claimConnectorScopeCleanup(ctx, connectorId) {
+    const scope = ctx.requestScope ?? ctx;
+    let owners = cleanupOwners.get(scope);
+    if (!owners)
+        cleanupOwners.set(scope, owners = new Map());
+    owners.set(connectorId, (owners.get(connectorId) ?? 0) + 1);
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        released = true;
+        const remaining = owners.get(connectorId) - 1;
+        if (remaining)
+            owners.set(connectorId, remaining);
+        else
+            owners.delete(connectorId);
+        if (!owners.size)
+            cleanupOwners.delete(scope);
+    };
+}
+export function connectorScopeCleanupClaimed(ctx, connectorId) {
+    return cleanupOwners.get(ctx.requestScope ?? ctx)?.has(connectorId) === true;
+}
 /**
  * Tell a connector that a scope owned by the core has ended.
  *

package/dist/connectors/api.js

@@ -30,8 +30,14 @@ function checkToolContract(id, tool) {
 }
 /** A static connector; every tool passes {@link checkToolContract} first. */
 export function api(id, opts) {
-    for (const t of opts.tools)
-        checkToolContract(id, t);
+    const names = new Set();
+    for (const tool of opts.tools) {
+        if (names.has(tool.name)) {
+            throw new Error(`api() tool "${id}.${tool.name}" is declared more than once; discovery and dispatch must use one definition.`);
+        }
+        names.add(tool.name);
+        checkToolContract(id, tool);
+    }
     const defs = opts.tools.map((t) => ({
         name: t.name,
         description: t.description,

package/dist/connectors/remote-mcp.d.ts

@@ -38,6 +38,10 @@ export type RemoteMcpAuth = {
     headers: Record<string, string>;
 } | RemoteMcpCredentialAuth | {
     type: "oauth";
+    /** Public HTTPS client metadata document, for servers supporting URL-based client IDs. */
+    clientMetadataUrl?: string;
+    /** Space-separated default scopes when the resource server does not advertise them. */
+    scope?: string;
 };
 /**
  * Apply a maintained provider's slot copy and header framing to credential

package/dist/connectors/remote-mcp.js

@@ -3,10 +3,12 @@ import { Deferred, Duration, Effect, Exit, Scope } from "effect";
 import { KvOAuthProvider, OAuthRefreshCoordinator, } from "../auth/downstream-oauth.js";
 import { trackOAuthStartReset } from "../auth/oauth-start-reset.js";
 import { MAX_CATALOG_TOOLS } from "../catalog-limits.js";
+import { connectorScopeCleanupClaimed } from "../connector-scope.js";
 import { boundedEchoText, ConnectorCallError, msg, unavailableCallError, } from "../errors.js";
 import { CONNECTA_VERSION } from "../version.js";
 import { learnedUrlRefusal } from "../url-safety.js";
 import { inheritOAuthSealer, oauthSealerFor } from "../oauth-sealing.js";
+import { attachOAuthPartition, oauthPartitionFor, retainOAuthPartition } from "../oauth-partition.js";
 import { detach, runEdge } from "../runtime/run.js";
 /**
  * Apply a maintained provider's slot copy and header framing to credential
@@ -396,6 +398,22 @@ function learnedUrlSafeFetch(connectorId, configured, baseFetch) {
  * server or hide other connectors).
  */
 export function remoteMcp(id, opts) {
+    const clientMetadataUrl = opts.auth?.type === "oauth" ? opts.auth.clientMetadataUrl : undefined;
+    const oauthScope = opts.auth?.type === "oauth" ? opts.auth.scope : undefined;
+    if (oauthScope !== undefined && !/^[\x21\x23-\x5B\x5D-\x7E]+(?: [\x21\x23-\x5B\x5D-\x7E]+)*$/.test(oauthScope)) {
+        throw new Error(`[connecta] connector "${id}" OAuth scope must contain space-separated scope tokens.`);
+    }
+    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 " +
@@ -410,7 +428,18 @@ export function remoteMcp(id, opts) {
     const isOauth = opts.auth?.type === "oauth";
     // Long-lived enough for distinct request scopes in this connector runtime to
     // join one token redemption. It owns no client, transport, or request state.
-    const refreshCoordinator = new OAuthRefreshCoordinator();
+    const refreshCoordinators = new WeakMap();
+    const refreshCoordinatorFor = (ctx) => {
+        // Production contexts carry a stable registry partition. Hand-written
+        // contexts can coordinate by their shared storage object instead.
+        const partition = oauthPartitionFor(ctx) ?? ctx.storage;
+        let coordinator = refreshCoordinators.get(partition);
+        if (!coordinator) {
+            coordinator = new OAuthRefreshCoordinator(() => retainOAuthPartition(partition));
+            refreshCoordinators.set(partition, coordinator);
+        }
+        return coordinator;
+    };
     const logger = opts.logger ?? console;
     const credentialAuth = opts.auth?.type === "credential" ? opts.auth : undefined;
     if (credentialAuth?.credential?.fields?.length) {
@@ -588,7 +617,7 @@ export function remoteMcp(id, opts) {
     const newProvider = (ctx, state) => {
         if (state?.provider)
             return state.provider;
-        const provider = new KvOAuthProvider(id, ctx.storage, `${ctx.baseUrl}/oauth/callback/${id}`, refreshCoordinator, ctx.allowAuthorization === true, oauthSealerFor(ctx), ctx.signal, JSON.stringify({
+        const provider = new KvOAuthProvider(id, ctx.storage, `${ctx.baseUrl}/oauth/callback/${id}`, refreshCoordinatorFor(ctx), ctx.allowAuthorization === true, oauthSealerFor(ctx), ctx.signal, JSON.stringify({
             url: new URL(opts.url).href,
             redirectUri: `${ctx.baseUrl}/oauth/callback/${id}`,
             clientMetadata: {
@@ -597,11 +626,13 @@ export function remoteMcp(id, opts) {
                 grant_types: ["authorization_code", "refresh_token"],
                 response_types: ["code"],
                 token_endpoint_auth_method: "none",
+                ...(oauthScope !== undefined ? { scope: oauthScope } : {}),
             },
             authScope: opts.authScope ?? "shared",
             versionNegotiation: opts.versionNegotiation ?? "auto",
             redirects: opts.redirects ?? "none",
-        }), (reset) => trackOAuthStartReset(ctx.requestScope ?? ctx, reset));
+            clientMetadataUrl,
+        }), (reset) => trackOAuthStartReset(ctx.requestScope ?? ctx, reset), clientMetadataUrl, oauthScope);
         if (state)
             state.provider = provider;
         return provider;
@@ -621,7 +652,7 @@ export function remoteMcp(id, opts) {
             const oauthProvider = provider ?? newProvider(ctx);
             return new StreamableHTTPClientTransport(url, {
                 authProvider: oauthProvider,
-                fetch: refreshCoordinator.coordinatedFetch(oauthProvider, learnedUrlSafeFetch(id, url, guardedFetch), ctx.signal),
+                fetch: refreshCoordinatorFor(ctx).coordinatedFetch(oauthProvider, learnedUrlSafeFetch(id, url, guardedFetch), ctx.signal),
             });
         }
         const headers = opts.auth?.type === "headers"
@@ -957,9 +988,10 @@ export function remoteMcp(id, opts) {
                         return { ok: false, message: msg(err) };
                     }
                     finally {
-                        // A test owns the scope it just opened; leaving the session for
-                        // the downstream to age out is not this button's to spend.
-                        await connector.closeScope?.(ctx);
+                        // Standalone tests own their scope; an operator route owns
+                        // bounded teardown for the context it supplied to this hook.
+                        if (!connectorScopeCleanupClaimed(ctx, id))
+                            await connector.closeScope?.(ctx);
                     }
                 },
             }
@@ -1180,17 +1212,23 @@ export function remoteMcp(id, opts) {
             const leased = state.transport;
             const t = (leased ??
                 buildTransport(ctx, provider));
-            if (callbackParams !== undefined) {
-                await t.finishAuth(callbackParams);
+            try {
+                if (callbackParams !== undefined) {
+                    await t.finishAuth(callbackParams);
+                }
+                else {
+                    await t.finishAuth(code);
+                }
+                await provider.clearPending();
+                // Reset so the next use reconnects with the freshly stored tokens.
+                closeHalf(state);
             }
-            else {
-                await t.finishAuth(code);
+            finally {
+                // This exchange-only transport has no lease in the request scope.
+                // It must close even when redemption or pending-state cleanup fails.
+                if (!leased)
+                    detach(closeConnection(null, t, ctx.logger));
             }
-            await provider.clearPending();
-            // Reset so the next use reconnects with the freshly stored tokens.
-            closeHalf(state);
-            if (!leased)
-                detach(closeConnection(null, t, ctx.logger));
         },
     };
     if (opts.auth?.type === "oauth") {
@@ -1202,11 +1240,11 @@ export function remoteMcp(id, opts) {
             await disconnectAuthorization(ctx, stateFor(ctx), true);
         };
         connector.startAuth = async (ctx, startOpts) => {
-            ctx = inheritOAuthSealer(ctx, {
+            ctx = attachOAuthPartition(inheritOAuthSealer(ctx, {
                 ...ctx,
                 requestScope: ctx.requestScope ?? ctx,
                 allowAuthorization: true,
-            });
+            }), oauthPartitionFor(ctx));
             const state = stateFor(ctx);
             state.provider = null;
             const p = newProvider(ctx, state);
@@ -1256,5 +1294,25 @@ export function remoteMcp(id, opts) {
             }
         };
     }
+    if (isOauth) {
+        // Pin before the first asynchronous storage/discovery read, not only once
+        // a refresh flight exists. These operations do not take call admission.
+        const retain = (operation, contextIndex) => async (...args) => {
+            const release = retainOAuthPartition(oauthPartitionFor(args[contextIndex]));
+            try {
+                return await operation(...args);
+            }
+            finally {
+                release();
+            }
+        };
+        connector.listTools = retain(connector.listTools, 0);
+        connector.callTool = retain(connector.callTool, 2);
+        connector.status = retain(connector.status, 0);
+        connector.startAuth = retain(connector.startAuth, 0);
+        connector.disconnectAuth = retain(connector.disconnectAuth, 0);
+        connector.verifyState = retain(connector.verifyState, 1);
+        connector.finishAuth = retain(connector.finishAuth, 1);
+    }
     return connector;
 }

package/dist/credentials.js

@@ -134,7 +134,8 @@ export class CredentialVault {
         }
     }
     async get(connectorId, field = "value", owner) {
-        return (await this.read(connectorId, owner))?.values[field] ?? null;
+        const values = (await this.read(connectorId, owner))?.values;
+        return values && Object.hasOwn(values, field) ? values[field] : null;
     }
     async getAll(connectorId, owner) {
         const credential = await this.read(connectorId, owner);

package/dist/execute.js

@@ -966,7 +966,22 @@ function failedRun(err, logger, { emitted, diagnostics }) {
 }
 /** The response for an ExecuteResult: the program's error or its value. */
 function finishedRun(outcome, { emitted, diagnostics, invocationFailures }) {
+    if (outcome === null || typeof outcome !== "object" || Array.isArray(outcome)) {
+        return failureResponse("Executor failed: expected an ExecuteResult object.", {
+            emitted,
+            diagnostics,
+            code: "executor_failed",
+        });
+    }
     const logs = executeLogs(outcome.logs);
+    if (outcome.error !== undefined && typeof outcome.error !== "string") {
+        return failureResponse("Executor failed: ExecuteResult.error must be a string.", {
+            logs,
+            emitted,
+            diagnostics,
+            code: "executor_failed",
+        });
+    }
     if (outcome.error !== undefined) {
         // Executor bridges necessarily reduce thrown host errors to strings.
         // Match that terminal string back to the request-local typed failure so

package/dist/index.js

@@ -582,6 +582,7 @@ export function createConnecta(config) {
         };
         const refreshRunner = createProgramRunner(registry.scoped({ connectorIds: [] }), config.publicUrl, executor, logger, undefined, refreshConfig);
         config.artifacts.bindRefresh({
+            ...(config.ui?.branding ? { branding: config.ui.branding } : {}),
             claimMs: refreshRunner.claimMs,
             execute: async (program, owner, signal) => {
                 if (!owner)

package/dist/oauth-partition.js

@@ -0,0 +1,32 @@
+// 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();
+const activeWork = new WeakMap();
+export function retainOAuthPartition(partition) {
+    if (!partition)
+        return () => { };
+    activeWork.set(partition, (activeWork.get(partition) ?? 0) + 1);
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        released = true;
+        const remaining = (activeWork.get(partition) ?? 1) - 1;
+        if (remaining === 0)
+            activeWork.delete(partition);
+        else
+            activeWork.set(partition, remaining);
+    };
+}
+export function oauthPartitionIdle(partition) {
+    return !activeWork.has(partition);
+}
+export function attachOAuthPartition(ctx, partition) {
+    if (partition)
+        partitions.set(ctx, partition);
+    return ctx;
+}
+export function oauthPartitionFor(ctx) {
+    return partitions.get(ctx);
+}