@zackbart/connecta 0.26.3 → 0.28.0

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

@@ -7,10 +7,10 @@ import type { CatalogAccessObservation, CatalogDriftReport } from "../types.js";
  *
  * - `runs_in_programs` — explicitly read-only, so `execute_code` may call it.
  * - `exempt` — not read-only, but the deployment's `execute.approval` lets a
- *   program call it without pausing (#566). Still approval-required
+ *   program call it without asking (#566). Still approval-required
  *   everywhere else.
- * - `needs_approval` — everything else: a program pauses for
- *   `resume_execution`, and a direct call crosses `call_destructive_tool`.
+ * - `needs_approval` — everything else: a program refuses it, and it crosses
+ *   `call_destructive_tool`, where the host asks.
  *
  * The badge renders from a table keyed by this union, so each value is one
  * entry, not a branch.

package/dist/operator-ui/view.js

@@ -413,12 +413,12 @@ export const TOOL_SAFETY_BADGE = {
     exempt: {
         label: "exempt from approval",
         tone: "neutral",
-        title: "Not read-only, but this deployment's config lets programs call it without pausing. Each call still counts against the write budget and appears in activity; call_tool still refuses it.",
+        title: "Not read-only, but this deployment's config lets programs call it without asking. Each call still counts against the write budget and appears in activity; call_tool still refuses it.",
     },
     needs_approval: {
         label: "asks for approval",
         tone: "warn",
-        title: "Not explicitly read-only: a program pauses for resume_execution, and a direct call crosses call_destructive_tool — either way the host asks first.",
+        title: "Not explicitly read-only: programs refuse it, and it runs through call_destructive_tool, where the host asks first.",
     },
 };
 /**
@@ -608,7 +608,8 @@ export function activitySummary(events) {
     return `${events.length} loaded call${events.length === 1 ? "" : "s"} · ${tools} tool${tools === 1 ? "" : "s"}`;
 }
 // A pause and an approval are neither success nor failure: each gets its own
-// class, and the stylesheet paints neither as an error.
+// class, and the stylesheet paints neither as an error. Nothing has emitted
+// either since issue #672 removed program pauses, but older rows carry them.
 const ACTIVITY_OUTCOMES = [
     "success",
     "error",
@@ -626,7 +627,7 @@ const OUTCOME_BADGE = {
     error: { label: "Failed", tone: "danger" },
     timeout: { label: "Timed out", tone: "danger" },
     cancelled: { label: "Cancelled", tone: "neutral" },
-    paused: { label: "Waiting for approval", tone: "warn" },
+    paused: { label: "Paused for approval", tone: "warn" },
     approved: { label: "Approved", tone: "ok" },
 };
 export function activityOutcomeBadge(outcome) {
@@ -636,6 +637,7 @@ const SOURCE_LABELS = {
     execute_code: "In a program",
     call_tool: "Direct call",
     call_destructive_tool: "Direct call, approved by the host",
+    // History only: resume_execution left with program pauses (#672).
     resume_execution: "Resumed program",
     batch_call: "Batch call",
 };

package/dist/providers/notion.js

@@ -147,7 +147,10 @@ async function notionRequest(ctx, request) {
         if (!response.ok) {
             throw notionFailure(response.status, payload, response.headers);
         }
-        return payload ?? {};
+        if (payload === null || typeof payload !== "object" || Array.isArray(payload)) {
+            throw new ConnectorCallError("connector_call_failed", "Notion returned an unreadable or non-object JSON response for a successful status. The request was sent, but its result could not be read; do not repeat a write to recover its result.", { retryable: false });
+        }
+        return payload;
     });
 }
 // Projections. Notion wraps every property in a discriminated object, every

package/dist/providers/vercel.js

@@ -83,7 +83,7 @@ function vercelFailure(status, headers, payload) {
         retryable: false,
     });
 }
-function parseBody(text, contentType) {
+function parseBody(text, contentType, strict = false) {
     if (!text)
         return undefined;
     try {
@@ -91,6 +91,8 @@ function parseBody(text, contentType) {
     }
     catch {
         if (contentType?.includes("stream+json") || contentType?.includes("ndjson")) {
+            if (strict)
+                return parseStreamRows(text);
             const rows = [];
             for (const line of text.split("\n")) {
                 if (!line.trim())
@@ -104,6 +106,9 @@ function parseBody(text, contentType) {
             }
             return rows;
         }
+        if (strict) {
+            throw new ConnectorCallError("connector_call_failed", "Vercel returned a malformed successful response.", { retryable: false });
+        }
         return text;
     }
 }
@@ -144,14 +149,13 @@ function vercelTransport(baseUrl) {
         },
     });
 }
-async function callVercel(send, request, ctx, parseSuccess) {
+async function callVercel(send, request, ctx, success = {}) {
     return await send(request, ctx, async (response) => {
         const text = await response.text();
-        const payload = parseBody(text, response.headers.get("content-type"));
         if (!response.ok) {
-            throw vercelFailure(response.status, response.headers, payload);
+            throw vercelFailure(response.status, response.headers, parseBody(text, response.headers.get("content-type")));
         }
-        return parseSuccess ? parseSuccess(text) : payload;
+        return success.parse ? success.parse(text) : parseBody(text, response.headers.get("content-type"), !success.raw);
     });
 }
 function teamQuery(args, defaultTeamId) {
@@ -553,7 +557,7 @@ function tools(send, defaultPageSize, defaultTeamId) {
                 required: ["result"],
             },
             handler: async (args, ctx) => ({
-                result: (await callVercel(send, { method: "GET", ...rawRequest(args, defaultTeamId) }, ctx)) ?? null,
+                result: (await callVercel(send, { method: "GET", ...rawRequest(args, defaultTeamId) }, ctx, { raw: true })) ?? null,
             }),
         },
         {
@@ -588,7 +592,7 @@ function tools(send, defaultPageSize, defaultTeamId) {
                     method: args["method"],
                     ...rawRequest(args, defaultTeamId),
                     ...(args["body"] !== undefined ? { body: args["body"] } : {}),
-                }, ctx)) ?? null,
+                }, ctx, { raw: true })) ?? null,
             }),
         },
         {
@@ -641,7 +645,7 @@ function tools(send, defaultPageSize, defaultTeamId) {
                         "Content-Type": args["contentType"],
                     },
                     rawBody: uploadBody(args),
-                }, ctx)) ?? null,
+                }, ctx, { raw: true })) ?? null,
             }),
         },
         {
@@ -839,7 +843,7 @@ function tools(send, defaultPageSize, defaultTeamId) {
                     method: "GET",
                     path: `/v1/projects/${encodeURIComponent(args["projectId"])}/deployments/${encodeURIComponent(args["deploymentId"])}/runtime-logs`,
                     query: team(args), headers: { Accept: "application/stream+json" },
-                }, { ...ctx, signal }, parseStreamRows), {
+                }, { ...ctx, signal }, { parse: parseStreamRows }), {
                     timeoutMs: RUNTIME_LOG_TIMEOUT_MS,
                     ...(ctx.signal ? { signal: ctx.signal } : {}),
                     timeoutError: new ConnectorCallError("unavailable", `Vercel's runtime-log stream stayed open past this connector's ${RUNTIME_LOG_TIMEOUT_MS / 1_000}-second bound. Retry for a fresh snapshot.`),

package/dist/registry.d.ts

@@ -171,6 +171,7 @@ export declare class Registry implements RegistryView {
     private resultStashBytes;
     private readonly configuredConnectors;
     private readonly personalRegistries;
+    private readonly oauthPartition;
     private callAdmissionClosed;
     /** Bounded FIFO of absent grants already warned about. */
     private readonly warnedAbsentGrants;

package/dist/registry.js

@@ -8,6 +8,7 @@ import { MAX_CATALOG_CHUNK_BYTES, MAX_CATALOG_TOOLS, MAX_SERIALIZED_CATALOG_BYTE
 import { ObservedOutputSchemas } from "./result-shapes.js";
 import { GUIDE_SUMMARY_LENGTH, normalizeGuideSummary, } from "./skills.js";
 import { attachOAuthSealer, vaultOAuthSealer } from "./oauth-sealing.js";
+import { attachOAuthPartition, oauthPartitionIdle } from "./oauth-partition.js";
 import { attachCaller } from "./connector-caller.js";
 import { closeScopeOnExit } from "./runtime/connector-scope.js";
 import { detach, runEdge, withDeadlineEffect } from "./runtime/run.js";
@@ -164,6 +165,7 @@ export class Registry {
     resultStashBytes = 0;
     configuredConnectors;
     personalRegistries = new Map();
+    oauthPartition = {};
     callAdmissionClosed = false;
     /** Bounded FIFO of absent grants already warned about. */
     warnedAbsentGrants = new Set();
@@ -226,9 +228,12 @@ export class Registry {
             // principal starts with no generations and no mutation queue, so a
             // refresh the evicted registry finishes later would persist a listing
             // that a credential change on the replacement had just deleted.
+            // OAuth status/start work bypasses both gates, and accepted rotations
+            // may still be saving after their caller leaves. Preserve its partition.
             const idle = [...this.personalRegistries].find(([, candidate]) => [...candidate.callAdmission.values()].every(admission => admission.isIdle()) &&
                 candidate.catalogRefreshes.size === 0 &&
-                candidate.catalogMutations.size === 0);
+                candidate.catalogMutations.size === 0 &&
+                oauthPartitionIdle(candidate.oauthPartition));
             if (!idle) {
                 throw new Error("Personal connector capacity is exhausted; retry after calls, rolling budgets, and catalog refreshes drain.");
             }
@@ -287,11 +292,24 @@ export class Registry {
     }
     async storeOAuthHandoff(connectorId, state, principalKey) {
         const key = this.oauthHandoffKey(connectorId, await sha256Hex(state));
-        const existing = await this.opts.storage.get(key);
-        if (existing && existing !== principalKey) {
-            throw new Error(`Connector "${connectorId}" reused one OAuth state across principals`);
+        for (let attempt = 0; attempt < 32; attempt++) {
+            const existing = await this.opts.storage.get(key);
+            if (existing && existing !== principalKey) {
+                throw new Error(`Connector "${connectorId}" reused one OAuth state across principals`);
+            }
+            const expiry = { ttlSeconds: OAUTH_HANDOFF_TTL_SECONDS };
+            if (this.opts.storage.compareAndSet) {
+                // Bind ownership atomically, including renewal of the same owner's
+                // handoff. Two owners reading a miss must not overwrite each other.
+                if (!await this.opts.storage.compareAndSet(key, existing, principalKey, expiry))
+                    continue;
+            }
+            else {
+                await this.opts.storage.set(key, principalKey, expiry);
+            }
+            return;
         }
-        await this.opts.storage.set(key, principalKey, { ttlSeconds: OAUTH_HANDOFF_TTL_SECONDS });
+        throw new Error(`OAuth handoff for "${connectorId}" is busy; retry authorization`);
     }
     async oauthCallbackView(connectorId, state) {
         const connector = this.connectors.get(connectorId);
@@ -389,7 +407,10 @@ export class Registry {
                 return values;
             };
             credentialAccess = {
-                get: async (field = "value") => (await readValues())?.[field] ?? null,
+                get: async (field = "value") => {
+                    const values = await readValues();
+                    return values && Object.hasOwn(values, field) ? values[field] : null;
+                },
                 getAll: readValues,
             };
         }
@@ -401,6 +422,7 @@ export class Registry {
             requestScope,
             ...callOptions,
         };
+        attachOAuthPartition(context, this.oauthPartition);
         // Downstream OAuth state is sealed under the vault key, bound to this
         // connector and owner. The sealer rides beside the context, not on it.
         return this.opts.credentialVault
@@ -818,8 +840,12 @@ export class Registry {
         const turn = Deferred.makeUnsafe();
         this.catalogMutations.set(id, turn);
         try {
-            if (previous)
-                await runEdge(Deferred.await(previous));
+            if (previous) {
+                // A cross-request Deferred alone looks hung to workerd. Keep a timer
+                // owned by this request until the preceding mutation hands over its
+                // turn; the race interrupts the timer as soon as the wait settles.
+                await runEdge(Effect.raceFirst(Deferred.await(previous), Effect.forever(Effect.sleep(Duration.seconds(1)))));
+            }
             await runOnPartition(operation, this.opts);
         }
         finally {
@@ -841,14 +867,8 @@ export class Registry {
         // observation, but must not overwrite a newer same-generation refresh.
         // Blocking callers do not set this flag and retain their prior publication
         // behavior when an inbound abort races a completed listing.
-        if (skipPublicationWhenAborted && ctx.signal?.aborted)
-            return tools;
-        // The caller that began this refresh may still use its result, but a
-        // credential/OAuth change that landed while listTools was in flight, or a
-        // flight abandoned while it listed, means the listing must not enter
-        // either shared cache layer.
-        if (!this.mayPublish(id, generation, flight))
-            return tools;
+        // Every returned listing must pass the ceilings, even when invalidation
+        // or abandonment means it can no longer enter either shared cache layer.
         if (tools.length > MAX_CATALOG_TOOLS) {
             const message = `Connector "${id}" returned ${tools.length} tools, over the ` +
                 `${MAX_CATALOG_TOOLS}-tool catalog ceiling; refusing the complete catalog.`;
@@ -857,10 +877,6 @@ export class Registry {
         }
         const previous = this.cache.get(id);
         const snapshot = await snapshotCatalog(tools);
-        if (!this.mayPublish(id, generation, flight) ||
-            (skipPublicationWhenAborted && ctx.signal?.aborted)) {
-            return tools;
-        }
         if (snapshot.serializedBytes.byteLength > MAX_SERIALIZED_CATALOG_BYTES) {
             const message = `Connector "${id}" returned a ${snapshot.serializedBytes.byteLength}-byte ` +
                 `serialized catalog, over the ${MAX_SERIALIZED_CATALOG_BYTES}-byte ceiling; ` +
@@ -868,6 +884,13 @@ export class Registry {
             this.opts.logger.warn(`[connecta] ${message}`);
             throw new Error(message);
         }
+        // The caller that began this refresh may still use its bounded result,
+        // but credential changes, abandoned flights, and deferred cancellation
+        // prevent publication. Recheck after snapshotting, which is asynchronous.
+        if (!this.mayPublish(id, generation, flight) ||
+            (skipPublicationWhenAborted && ctx.signal?.aborted)) {
+            return tools;
+        }
         const now = Date.now();
         const catalogChanged = !previous || previous.fingerprint !== snapshot.fingerprint;
         const shouldPersist = catalogChanged ||
@@ -1296,23 +1319,33 @@ class ScopedRegistryView {
     allowed;
     scope;
     maxResultBytes;
-    personal;
+    /** An evicted view's admission controller must remain closed. */
+    admissionPersonal;
+    get personal() {
+        return this.scope.principalKey
+            ? this.root.personalRegistry(this.scope.principalKey)
+            : undefined;
+    }
     constructor(root, allowed, scope) {
         this.root = root;
         this.allowed = allowed;
         this.scope = scope;
         this.maxResultBytes = root.maxResultBytes;
-        this.personal = scope.principalKey
+        // Check capacity at construction, then resolve the current registry on
+        // use. A retained view must not revive one evicted while it was idle.
+        this.admissionPersonal = scope.principalKey
             ? root.personalRegistry(scope.principalKey)
             : undefined;
     }
-    registryFor(id) {
+    registryFor(id, admission = false) {
         if (!this.allowed.has(id))
             return undefined;
         const connector = this.root.getConnector(id);
         if (!connector)
             return undefined;
-        return connector.authScope === "personal" ? this.personal : this.root;
+        if (connector.authScope !== "personal")
+            return this.root;
+        return admission ? this.admissionPersonal : this.personal;
     }
     listConnectors() {
         return this.root.listConnectors().filter((connector) => this.registryFor(connector.id) !== undefined);
@@ -1358,7 +1391,7 @@ class ScopedRegistryView {
         return attachCaller(registry.contextFor(...args), this.scope.caller);
     }
     admitCall(...args) {
-        const registry = this.registryFor(args[0]);
+        const registry = this.registryFor(args[0], true);
         if (!registry) {
             return Promise.reject(new Error(`Unknown connector "${args[0]}"`));
         }

package/dist/routes/credentials.js

@@ -1,4 +1,5 @@
 import { Effect } from "effect";
+import { claimConnectorScopeCleanup, closeConnectorScope } from "../connector-scope.js";
 import { credentialTestRule, describeCredentialTestMismatch, storedCredentialShape, } from "../credential-rules.js";
 import { authorizedPerson, refuse, serveOperator, visibleRegistry, } from "./operator.js";
 import { mayManageConnector, isSameOrigin, msg, privateJson, } from "./shared.js";
@@ -164,14 +165,21 @@ function credentialRequest(context, connectorId, action) {
                     }
                     const storedValues = values;
                     const ctx = registry.contextFor(connectorId, baseUrl);
-                    const result = mode === "multiple"
-                        ? await connector.testCredentials(storedValues, ctx)
-                        : await connector.testCredential(
-                        // The single-value shape check above guarantees this key.
-                        storedValues.value, ctx);
-                    const ok = result?.ok === true;
-                    logged(ok, result?.message);
-                    return privateJson({ ok });
+                    const releaseCleanup = claimConnectorScopeCleanup(ctx, connectorId);
+                    try {
+                        const result = mode === "multiple"
+                            ? await connector.testCredentials(storedValues, ctx)
+                            : await connector.testCredential(
+                            // The single-value shape check above guarantees this key.
+                            storedValues.value, ctx);
+                        const ok = result?.ok === true;
+                        logged(ok, result?.message);
+                        return privateJson({ ok });
+                    }
+                    finally {
+                        releaseCleanup();
+                        await closeConnectorScope(connector, ctx, context.defer);
+                    }
                 },
                 catch: (error) => error,
             }).pipe(Effect.catch((error) => {

package/dist/routes/mcp.js

@@ -4,9 +4,8 @@ import { notFoundResponse } from "../branding.js";
 import { registerExecuteTool } from "../execute.js";
 import { ExecutorAdmissionError, } from "../executor-admission.js";
 import { registerMetaTools } from "../meta-tools.js";
-import { registerResumeTool } from "../resumable.js";
 import { intersectAccess } from "../connector-access.js";
-import { instructionsFor } from "../skills.js";
+import { CONNECTA_INSTRUCTIONS } from "../skills.js";
 import { msg } from "../errors.js";
 import { detach } from "../runtime/run.js";
 import { authorize, loggableValue, mayManageConnector, validateAuthPermissions, } from "./shared.js";
@@ -218,19 +217,14 @@ function toolkitRetired(logger) {
         },
     });
 }
-function serveMcp(request, requestSignal, opts, baseUrl, actor, registry, canManageAuth, poolName, runtimeContext) {
-    // A paused run belongs to the endpoint it started on: resuming it through
-    // another pool's endpoint finds nothing, as another subject would.
-    const resumable = opts.resumable
-        ? { ...opts.resumable, pool: poolName ?? null, approval: opts.approval }
-        : undefined;
+function serveMcp(request, requestSignal, opts, baseUrl, actor, registry, canManageAuth, runtimeContext) {
     // Every McpServer the request builds is fresh and closes with its scope.
     // The modern handler tears its own down after the exchange; the legacy
     // transport never does, and neither may stay wired to an ended request.
     const servers = [];
     const createServer = () => {
         const server = new McpServer(opts.serverInfo, {
-            instructions: instructionsFor(resumable !== undefined),
+            instructions: CONNECTA_INSTRUCTIONS,
             cacheHints: {
                 "tools/list": {
                     ttlMs: 3_600_000,
@@ -274,7 +268,7 @@ function serveMcp(request, requestSignal, opts, baseUrl, actor, registry, canMan
                 : {}),
             approval: opts.approval,
         });
-        const runner = registerExecuteTool(server, registry, {
+        registerExecuteTool(server, registry, {
             baseUrl,
             executor: opts.executor,
             logger: opts.logger,
@@ -304,19 +298,9 @@ function serveMcp(request, requestSignal, opts, baseUrl, actor, registry, canMan
             ...(opts.watchdogMs !== undefined
                 ? { watchdogMs: opts.watchdogMs }
                 : {}),
-            resumable,
             approval: opts.approval,
             maxWrites: opts.maxWrites,
         });
-        // Always registered, so the surface is the same eight tools on every
-        // deployment; without resumable writes it answers that there is nothing
-        // to resume.
-        registerResumeTool(server, registry, {
-            runner,
-            settings: resumable,
-            ...(activity ? { activity } : {}),
-            requestSignal,
-        });
         servers.push(server);
         return server;
     };
@@ -527,7 +511,7 @@ export function createMcpRoute(opts) {
                 if (new URL(request.url).searchParams.has("toolkit")) {
                     return cors(toolkitRetired(opts.logger));
                 }
-                return cors(yield* serveMcp(localRequest, localAbort.signal, opts, baseUrl, authz.actor, scopedRegistry, id => { const connector = scopedRegistry.getConnector(id); return Boolean(connector && mayManageConnector(authz, connector)); }, poolName, runtimeContext));
+                return cors(yield* serveMcp(localRequest, localAbort.signal, opts, baseUrl, authz.actor, scopedRegistry, id => { const connector = scopedRegistry.getConnector(id); return Boolean(connector && mayManageConnector(authz, connector)); }, runtimeContext));
             });
             if (remainingMs === undefined)
                 return yield* handled;

package/dist/routes/oauth.js

@@ -1,4 +1,5 @@
 import { Effect } from "effect";
+import { closeConnectorScope } from "../connector-scope.js";
 import { oauthValueStorageKey } from "../auth/downstream-oauth.js";
 import { escapeHtml, renderPage, resolveBranding, STATUS_ICONS } from "../branding.js";
 import { oauthCallbackOutcome, providerErrorReason, } from "../oauth-callback-outcome.js";
@@ -127,79 +128,84 @@ async function finishOAuthCallback(context) {
         await equalizeRefusalCost(connectorContext);
         return refused();
     }
-    const expectedPrincipalKey = callbackTarget?.principalKey;
-    // A browser returning from consent normally has no MCP Authorization
-    // header. An interactive bearer provider therefore answers 401 here; state
-    // and the saved state-to-principal handoff still prove ownership below.
-    // Rejecting 401 would break that callback. A 403 is an explicit denial.
-    const browserIdentity = await authorizeUiIdentity(context.request, baseUrl, opts.auth, "OAuth callback", context.runtimeContext, opts.identity);
-    if (browserIdentity.ok) {
-        try {
-            validateAuthPermissions(browserIdentity, opts.registry);
+    try {
+        const expectedPrincipalKey = callbackTarget?.principalKey;
+        // A browser returning from consent normally has no MCP Authorization
+        // header. An interactive bearer provider therefore answers 401 here; state
+        // and the saved state-to-principal handoff still prove ownership below.
+        // Rejecting 401 would break that callback. A 403 is an explicit denial.
+        const browserIdentity = await authorizeUiIdentity(context.request, baseUrl, opts.auth, "OAuth callback", context.runtimeContext, opts.identity);
+        if (browserIdentity.ok) {
+            try {
+                validateAuthPermissions(browserIdentity, opts.registry);
+            }
+            catch {
+                return refused();
+            }
+            if (!mayManageConnector(browserIdentity, connector) || (expectedPrincipalKey && browserIdentity.principalKey !== expectedPrincipalKey))
+                return refused();
         }
-        catch {
+        else if (browserIdentity.response.status === 403 && opts.auth.some(provider => provider.interactiveOperator)) {
             return refused();
         }
-        if (!mayManageConnector(browserIdentity, connector) || (expectedPrincipalKey && browserIdentity.principalKey !== expectedPrincipalKey))
+        // CSRF / login-fixation guard: this route is intentionally public, so verify
+        // the `state` matches the flow connecta started BEFORE exchanging the code.
+        if (!connector.verifyState) {
+            await equalizeRefusalCost(connectorContext);
+            opts.logger.warn(`[connecta] refused an OAuth callback for connector ` +
+                `${loggableValue(id)} with 400: it implements finishAuth but no ` +
+                "verifyState, so connecta cannot establish that it started this flow. " +
+                "No authorization code was exchanged. Implement verifyState before " +
+                "trying again.");
             return refused();
-    }
-    else if (browserIdentity.response.status === 403 && opts.auth.some(provider => provider.interactiveOperator)) {
-        return refused();
-    }
-    // CSRF / login-fixation guard: this route is intentionally public, so verify
-    // the `state` matches the flow connecta started BEFORE exchanging the code.
-    if (!connector.verifyState) {
-        await equalizeRefusalCost(connectorContext);
-        opts.logger.warn(`[connecta] refused an OAuth callback for connector ` +
-            `${loggableValue(id)} with 400: it implements finishAuth but no ` +
-            "verifyState, so connecta cannot establish that it started this flow. " +
-            "No authorization code was exchanged. Implement verifyState before " +
-            "trying again.");
-        return refused();
-    }
-    let stateMatches;
-    try {
-        stateMatches = await connector.verifyState(state, connectorContext);
-    }
-    catch (err) {
-        opts.logger.warn(`[connecta] refused an OAuth callback for connector ` +
-            `${loggableValue(id)} with 400: verifyState threw ` +
-            `${loggableValue(msg(err))}. No authorization code was exchanged. ` +
-            "Re-run authorization from connecta and check the verifier if it " +
-            "fails again.");
-        return refused();
-    }
-    if (!stateMatches) {
-        opts.logger.warn(`[connecta] refused an OAuth callback for connector ` +
-            `${loggableValue(id)} with 400: ` +
-            (state === null
-                ? "the state parameter was missing"
-                : "the state did not match the pending authorization flow") +
-            ". No authorization code was exchanged. Re-run authorization from " +
-            "connecta and try again.");
-        return refused();
-    }
-    if (connector.authScope === "personal") {
+        }
+        let stateMatches;
         try {
-            await opts.registry.clearOAuthHandoff(id, state);
+            stateMatches = await connector.verifyState(state, connectorContext);
         }
         catch (err) {
             opts.logger.warn(`[connecta] refused an OAuth callback for connector ` +
-                `${loggableValue(id)} with 500: its principal handoff could not be ` +
-                `consumed (${loggableValue(msg(err))}). No authorization code was exchanged.`);
-            return html("handoff_failed", opts, connector);
+                `${loggableValue(id)} with 400: verifyState threw ` +
+                `${loggableValue(msg(err))}. No authorization code was exchanged. ` +
+                "Re-run authorization from connecta and check the verifier if it " +
+                "fails again.");
+            return refused();
+        }
+        if (!stateMatches) {
+            opts.logger.warn(`[connecta] refused an OAuth callback for connector ` +
+                `${loggableValue(id)} with 400: ` +
+                (state === null
+                    ? "the state parameter was missing"
+                    : "the state did not match the pending authorization flow") +
+                ". No authorization code was exchanged. Re-run authorization from " +
+                "connecta and try again.");
+            return refused();
+        }
+        if (connector.authScope === "personal") {
+            try {
+                await opts.registry.clearOAuthHandoff(id, state);
+            }
+            catch (err) {
+                opts.logger.warn(`[connecta] refused an OAuth callback for connector ` +
+                    `${loggableValue(id)} with 500: its principal handoff could not be ` +
+                    `consumed (${loggableValue(msg(err))}). No authorization code was exchanged.`);
+                return html("handoff_failed", opts, connector);
+            }
+        }
+        try {
+            await connector.finishAuth(code, connectorContext, url.searchParams);
+            await callbackRegistry.invalidateStored(id);
+            return html("connected", opts, connector);
+        }
+        catch (err) {
+            // The page names the reason and nothing else; what the exchange threw can
+            // quote a token endpoint's body, so it goes only to the operator log.
+            opts.logger.warn(`[connecta] OAuth callback for connector ${loggableValue(id)} failed ` +
+                `with 500: the authorization code exchange threw ${loggableValue(msg(err))}.`);
+            return html("exchange_failed", opts, connector);
         }
     }
-    try {
-        await connector.finishAuth(code, connectorContext, url.searchParams);
-        await callbackRegistry.invalidateStored(id);
-        return html("connected", opts, connector);
-    }
-    catch (err) {
-        // The page names the reason and nothing else; what the exchange threw can
-        // quote a token endpoint's body, so it goes only to the operator log.
-        opts.logger.warn(`[connecta] OAuth callback for connector ${loggableValue(id)} failed ` +
-            `with 500: the authorization code exchange threw ${loggableValue(msg(err))}.`);
-        return html("exchange_failed", opts, connector);
+    finally {
+        await closeConnectorScope(connector, connectorContext, context.defer);
     }
 }

package/dist/routes/shared.d.ts

@@ -41,14 +41,9 @@ export interface ServerOptions {
     hostCallTimeoutMs?: number | undefined;
     /** Hard ceiling on one execute_code run, outside the sandbox. Default 120_000. */
     watchdogMs?: number | undefined;
-    /** Resumable writes' settings; absent when they are off. */
-    resumable?: {
-        maxWrites: number;
-        ttlSeconds: number;
-    } | undefined;
     /** Config approval exemptions (`execute.approval`), resolved at construction. */
     approval?: ApprovalPolicy | undefined;
-    /** Writes one program may send (`execute.maxWrites`), exempt ones included. */
+    /** Exempt writes one program may send (`execute.maxWrites`). */
     maxWrites?: number | undefined;
     /** Required sandbox backing the execute_code meta-tool. */
     executor: Executor;

package/dist/runtime/run.js

@@ -34,7 +34,9 @@ function setMicrotask(task) {
 export const microtaskScheduler = new Scheduler.MixedScheduler("async", setMicrotask);
 const runExit = Effect.runPromiseExitWith(Context.make(Scheduler.Scheduler, microtaskScheduler));
 function abortReason(signal) {
-    return signal?.reason ?? new DOMException("aborted", "AbortError");
+    return signal && signal.reason !== undefined
+        ? signal.reason
+        : new DOMException("aborted", "AbortError");
 }
 /**
  * Turn a failed Exit back into the value a Promise caller would have seen.
@@ -136,6 +138,10 @@ export function fromSignal(signal) {
  */
 export function withDeadlineEffect(operation, options) {
     return Effect.suspend(() => {
+        // Do not dispatch work that already lost its caller. The operation is the
+        // first race contender and can finish before the abort contender starts.
+        if (options.signal?.aborted)
+            return Effect.fail(abortReason(options.signal));
         const controller = new AbortController();
         const forwardAbort = () => controller.abort(options.signal?.reason);
         options.signal?.addEventListener("abort", forwardAbort, { once: true });