@zackbart/connecta 0.34.1 → 0.36.0

package/dist/auth-elicitation.js

@@ -1,11 +1,17 @@
+import { RequestScope, requestOwner } from "./runtime/request-scope.js";
+import { upwardStep } from "./upward.js";
+import { authAwait, authCall, authInvoke, authFlow, authMethod, registerAuthMethod, authOwnMethod, } from "./auth/native.js";
+import { registryProgram } from "./runtime/registry.js";
 import { enableAuthorizationHandoffs } from "./authorization-handoff.js";
 import { createRequestStateCodec, inputRequired, ProtocolError, INVALID_PARAMS, PROTOCOL_VERSION_META_KEY, CLIENT_CAPABILITIES_META_KEY, } from "@modelcontextprotocol/server";
 import { Effect } from "effect";
 import { runEdge, withDeadlineEffect } from "./runtime/run.js";
 import { closeScope } from "./runtime/connector-scope.js";
 import { storedCredentialShape } from "./credential-rules.js";
+import { isWriteLike } from "./tool-safety.js";
 import { authRecoveryFacts, bindReplayReads, classificationDigest } from "./invocation-auth.js";
 import { CatalogService } from "./catalog-service.js";
+import { sentSecretsForRequest } from "./sent-secrets.js";
 import { DownstreamElicitation, MAX_RELAY_STATE_CHARS, } from "./downstream-input.js";
 import { canonicalState as canonical, requestDigest as digest, stateObject as object, invalidRequestState as invalidState, REQUEST_STATE_TTL_MS as TTL_MS, MAX_INPUT_ROUNDS as MAX_ROUNDS, } from "./request-state.js";
 const INPUT_KEY = "connecta_auth";
@@ -20,269 +26,372 @@ export class AuthElicitation {
     codec;
     downstream;
     stateCodec() {
-        const key = this.options.vault?.requestStateKey;
-        if (!key)
-            return invalidState();
-        return (this.codec ??= key.call(this.options.vault).then((bytes) => createRequestStateCodec({
-            key: bytes,
-            ttlSeconds: TTL_MS / 1000,
-            bind: () => canonical({ principal: this.options.principal, endpoint: this.options.endpoint }),
-        })));
+        return runEdge(authOwnMethod(AuthElicitation.prototype, this, "stateCodec", []));
     }
     constructor(options) {
         this.options = options;
         this.downstream = new DownstreamElicitation({
             ...options,
-            mint: async (state, context) => (await this.stateCodec()).mint(state, context),
+            mint: authMethod((state, context) => Effect.gen({ self: this }, function* () {
+                const codec = yield* authInvoke(this, "stateCodec", []);
+                return yield* authInvoke(codec, "mint", [state, context]);
+            })),
         });
     }
     /** The SDK runs this before any tool handler, including non-auth tools. */
-    async verify(wire, context) {
-        const { vault, endpoint, principal, registry, canManage } = this.options;
-        if (!vault?.requestStateKey || wire.length > MAX_RELAY_STATE_CHARS)
-            return invalidState();
-        const state = await (await this.stateCodec()).verify(wire, context);
-        if (object(state) && state.version === 2 && state.kind === "downstream")
-            return this.downstream.verify(state, context);
-        if (wire.length > 8192)
-            return invalidState();
-        if (!object(state) ||
-            state.version !== 1 ||
-            !principal ||
-            state.principal !== principal ||
-            state.endpoint !== endpoint ||
-            typeof state.connector !== "string" ||
-            !registry.getConnector(state.connector) ||
-            !canManage(state.connector) ||
-            !Number.isSafeInteger(state.expiresAt) ||
-            state.expiresAt <= Date.now() ||
-            state.expiresAt > Date.now() + TTL_MS ||
-            !Number.isInteger(state.round) ||
-            state.round < 1 ||
-            state.round > MAX_ROUNDS ||
-            !["call_tool", "call_destructive_tool", "execute_code", "authorize_connector"].includes(String(state.tool)) ||
-            typeof state.digest !== "string" ||
-            !/^[a-f0-9]{64}$/.test(state.digest) ||
-            !Array.isArray(state.browserNonces) ||
-            state.browserNonces.length !== state.round ||
-            !state.browserNonces.every((nonce) => typeof nonce === "string" && /^[a-f0-9-]{36}$/.test(nonce)) ||
-            !Array.isArray(state.reads) ||
-            !state.reads.every((read) => object(read) &&
-                typeof read.address === "string" &&
-                typeof read.digest === "string" &&
-                /^[a-f0-9]{64}$/.test(read.digest)) ||
-            (state.address !== undefined && typeof state.address !== "string"))
-            return invalidState();
-        if (context.mcpReq.method !== "tools/call" || context.http?.req?.headers.get("Mcp-Name") !== state.tool)
-            return invalidState();
-        return state;
+    verify(wire, context) {
+        return runEdge(authOwnMethod(AuthElicitation.prototype, this, "verify", [
+            wire,
+            context,
+        ]));
     }
-    async browserProgress(state) {
-        let started;
-        let claimed;
-        let completed = false;
-        let pending = false;
-        for (const nonce of state.browserNonces) {
-            const progress = await this.options.linkProgress(state.connector, nonce);
-            if (progress === "started")
-                started = nonce;
-            if (progress === "claimed")
-                claimed = nonce;
-            completed ||= progress === "started";
-            pending ||= progress === "claimed";
-        }
-        const predecessor = started ?? claimed;
-        return { ...(predecessor ? { predecessor } : {}), completed: completed && !pending };
+    browserProgress(state) {
+        return runEdge(authOwnMethod(AuthElicitation.prototype, this, "browserProgress", [
+            state,
+        ]));
     }
-    async connected(id, context) {
-        const { registry, publicUrl, vault, principal, defer } = this.options;
-        const connector = registry.getConnector(id);
-        const scope = {};
-        const signal = AbortSignal.any([context.mcpReq.signal, this.options.requestSignal]);
-        try {
-            return await runEdge(withDeadlineEffect((deadline) => Effect.gen(function* () {
-                const ctx = registry.contextFor(id, publicUrl, scope, { signal: deadline });
-                yield* Effect.addFinalizer(() => closeScope(connector, ctx, defer));
-                if (connector.credential) {
-                    const metadata = yield* Effect.promise(() => vault.metadata(id, connector.authScope === "personal" ? principal : undefined));
-                    if (storedCredentialShape(connector.credential, metadata?.fields ?? null).state !== "valid")
-                        return false;
-                }
-                if (!connector.status)
-                    return Boolean(connector.credential);
-                return ((yield* Effect.promise(() => registry.statusFor(id, publicUrl, scope, { signal: deadline }))).state ===
-                    "ok");
-            }).pipe(Effect.scoped), { signal, timeoutMs: 5000, timeoutError: new Error("Auth status check timed out") }));
-        }
-        catch {
-            return false;
-        }
+    connected(id, context) {
+        return runEdge(authOwnMethod(AuthElicitation.prototype, this, "connected", [id, context]));
     }
-    async run(tool, args, context, operation) {
+    bind(context) {
         this.downstream.bind(context);
-        const prior = context.mcpReq.requestState();
-        if (prior?.version === 2)
-            return this.downstream.resume(prior, tool, args, context, operation);
-        const previous = prior;
-        const requestDigest = previous ? await digest(tool, args) : undefined;
-        if (previous && (previous.tool !== tool || previous.digest !== requestDigest || previous.address !== args.address))
-            return failure("invalid_request_state", "Invalid or expired requestState");
-        const response = context.mcpReq.inputResponses?.[INPUT_KEY];
-        if (previous && object(response) && !["accept", "decline", "cancel"].includes(String(response.action))) {
-            throw new ProtocolError(INVALID_PARAMS, "Invalid auth elicitation response", {
-                reason: "invalid_input_response",
-            });
-        }
-        if (previous && !(await this.options.claimRetry(previous.connector, previous.browserNonces.at(-1)))) {
-            return failure("invalid_request_state", "Invalid or expired requestState");
-        }
-        if (previous && object(response)) {
-            if (response.action === "decline")
-                return failure("auth_declined", "Connection was declined. The request was not retried.");
-            if (response.action === "cancel")
-                return failure("auth_cancelled", "Connection was cancelled. The request was not retried.");
-        }
-        if (previous?.reads.length) {
-            const catalog = new CatalogService(this.options.registry, this.options.publicUrl, {
-                requestScope: this.options.requestScope,
-                requestSignal: AbortSignal.any([context.mcpReq.signal, this.options.requestSignal]),
-            });
-            // Recheck every entered read before restarting any part of a program.
-            // A writable endpoint cannot authorize replay of a newly classified write.
-            for (const read of previous.reads) {
-                const current = await catalog.resolveTool(read.address, { signal: context.mcpReq.signal });
-                if (!current.ok ||
-                    current.resolved.classificationFresh !== true ||
-                    current.resolved.definition.classification !== "read" ||
-                    (await classificationDigest(current.resolved.definition)) !== read.digest) {
+    }
+    run(tool, args, context, operation) {
+        return runEdge(authOwnMethod(AuthElicitation.prototype, this, "run", [
+            tool,
+            args,
+            context,
+            operation,
+        ]));
+    }
+    static {
+        registerAuthMethod(this.prototype, "stateCodec", function () {
+            const self = this;
+            return authAwait(Effect.gen(function* () {
+                const key = self.options.vault?.requestStateKey;
+                if (!key)
+                    return invalidState();
+                self.codec ??= yield* Effect.cached(authCall(key, [], self.options.vault).pipe(Effect.map((bytes) => createRequestStateCodec({
+                    key: bytes,
+                    ttlSeconds: TTL_MS / 1000,
+                    bind: () => canonical({ principal: self.options.principal, endpoint: self.options.endpoint }),
+                }))));
+                return yield* self.codec;
+            }), this.options.requestSignal).pipe(Effect.provideService(RequestScope, requestOwner(this.options.requestScope)));
+        }, this.prototype.stateCodec);
+        registerAuthMethod(AuthElicitation.prototype, "run", function (tool, args, context, operation) {
+            const self = this;
+            return authAwait(authFlow(function* () {
+                self.bind(context);
+                const prior = context.mcpReq.requestState();
+                if (prior?.version === 2)
+                    return yield* upwardStep(authInvoke(self.downstream, "resume", [
+                        prior,
+                        tool,
+                        args,
+                        context,
+                        operation,
+                    ]));
+                const previous = prior;
+                const requestDigest = previous ? yield* upwardStep(authCall(digest, [tool, args])) : undefined;
+                if (previous &&
+                    (previous.wireTool !== context.http?.req?.headers.get("Mcp-Name") ||
+                        previous.tool !== tool ||
+                        previous.digest !== requestDigest ||
+                        previous.address !== args.address))
+                    return failure("invalid_request_state", "Invalid or expired requestState");
+                const response = context.mcpReq.inputResponses?.[INPUT_KEY];
+                if (previous && object(response) && !["accept", "decline", "cancel"].includes(String(response.action))) {
+                    throw new ProtocolError(INVALID_PARAMS, "Invalid auth elicitation response", {
+                        reason: "invalid_input_response",
+                    });
+                }
+                if (previous &&
+                    !(yield* upwardStep(authInvoke(self.options, "claimRetry", [previous.connector, previous.browserNonces.at(-1)])))) {
+                    return failure("invalid_request_state", "Invalid or expired requestState");
+                }
+                if (previous && object(response)) {
+                    if (response.action === "decline")
+                        return failure("auth_declined", "Connection was declined. The request was not retried.");
+                    if (response.action === "cancel")
+                        return failure("auth_cancelled", "Connection was cancelled. The request was not retried.");
+                }
+                if (previous?.reads.length) {
+                    const catalog = new CatalogService(self.options.registry, self.options.publicUrl, {
+                        requestScope: self.options.requestScope,
+                        requestSignal: AbortSignal.any([context.mcpReq.signal, self.options.requestSignal]),
+                    });
+                    // Recheck every entered read before restarting any part of a program.
+                    // A writable endpoint cannot authorize replay of a newly classified write.
+                    for (const read of previous.reads) {
+                        const current = yield* upwardStep(authInvoke(catalog, "resolveTool", [
+                            read.address,
+                            { signal: context.mcpReq.signal },
+                        ]));
+                        if (!current.ok ||
+                            current.resolved.classificationFresh !== true ||
+                            isWriteLike(current.resolved.definition) ||
+                            (yield* upwardStep(authCall(classificationDigest, [current.resolved.definition]))) !==
+                                read.digest) {
+                            const structuredContent = {
+                                ok: false,
+                                error: {
+                                    code: "auth_replay_refused",
+                                    retryable: false,
+                                    reconciliationRequired: true,
+                                    message: "An entered read no longer has the same fresh classification. Reconcile its target before starting a new request.",
+                                    authorizationUrl: (yield* upwardStep(authInvoke(self.options, "connectLink", [previous.connector]))).url,
+                                },
+                            };
+                            return {
+                                isError: true,
+                                structuredContent,
+                                content: [{ type: "text", text: JSON.stringify(structuredContent) }],
+                            };
+                        }
+                    }
+                    bindReplayReads(self.options.requestScope, previous.reads);
+                }
+                const browser = previous && tool === "authorize_connector"
+                    ? yield* upwardStep(authInvoke(self, "browserProgress", [previous]))
+                    : undefined;
+                if (browser?.completed && previous) {
+                    // Retire unspent links before the status read. A browser claim racing
+                    // these CASes either wins and is observed as pending, or is refused.
+                    yield* upwardStep(authInvoke(self.options, "closeLinks", [previous.connector, previous.browserNonces]));
+                    if ((yield* upwardStep(authInvoke(self, "browserProgress", [previous]))).completed &&
+                        (yield* upwardStep(authInvoke(self, "connected", [previous.connector, context])))) {
+                        const structuredContent = { connector: previous.connector, status: "ok" };
+                        return { structuredContent, content: [{ type: "text", text: JSON.stringify(structuredContent) }] };
+                    }
+                }
+                const envelope = context.mcpReq.envelope;
+                const capabilities = envelope?.[CLIENT_CAPABILITIES_META_KEY];
+                const elicitation = object(capabilities) ? capabilities.elicitation : undefined;
+                const capable = envelope?.[PROTOCOL_VERSION_META_KEY] === "2026-07-28" &&
+                    object(elicitation) &&
+                    Object.hasOwn(elicitation, "url") &&
+                    object(elicitation.url);
+                enableAuthorizationHandoffs(self.options.requestScope, !capable);
+                let result = yield* upwardStep(authCall(operation, []));
+                const relayed = yield* upwardStep(authInvoke(self.downstream, "finish", [
+                    tool,
+                    args,
+                    context,
+                    result,
+                    previous,
+                ]));
+                if (relayed !== result)
+                    return relayed;
+                const error = result.structuredContent?.error;
+                const authFailure = result.isError &&
+                    object(error) &&
+                    (error.code === "auth_required" || error.code === "downstream_oauth_required");
+                const explicit = tool === "authorize_connector" &&
+                    ["oauth", "operator_config"].includes(String(result.structuredContent?.recovery));
+                if (!authFailure && !explicit)
+                    return result;
+                const id = authFailure ? error.connector : explicit ? args.connector : undefined;
+                // Every accepted retry owns new request-local facts. Handler-authored
+                // errors and program write summaries cannot establish replay eligibility.
+                const facts = yield* upwardStep(authCall(authRecoveryFacts, [self.options.requestScope, String(id)]));
+                const blocked = !explicit && (!facts.eligible || facts.writeEntered);
+                if (authFailure && (facts.unsafeEntered || (tool !== "call_tool" && !facts.eligible))) {
                     const structuredContent = {
-                        ok: false,
+                        ...result.structuredContent,
                         error: {
-                            code: "auth_replay_refused",
+                            ...error,
                             retryable: false,
                             reconciliationRequired: true,
-                            message: "An entered read no longer has the same fresh classification. Reconcile its target before starting a new request.",
-                            authorizationUrl: (await this.options.connectLink(previous.connector)).url,
+                            retry: "This call may have partially run. Reconcile its target before retrying after the operator completes recovery.",
+                        },
+                    };
+                    result = {
+                        ...result,
+                        structuredContent,
+                        content: [{ type: "text", text: JSON.stringify(structuredContent) }],
+                    };
+                }
+                const { registry, vault, principal, publicUrl, canManage, unavailable } = self.options;
+                const connector = typeof id === "string" ? registry.getConnector(id) : undefined;
+                const recoverable = connector?.startAuth || (connector?.credential && self.options.credentialUi);
+                if (typeof id !== "string" ||
+                    !/^[a-z0-9_-]+$/.test(id) ||
+                    !recoverable ||
+                    !principal ||
+                    !publicUrl ||
+                    unavailable ||
+                    !canManage(id))
+                    return result;
+                // Incapable hosts already received the shared explicit-authorization handoff.
+                if (!capable)
+                    return result;
+                if (blocked || !vault?.requestStateKey || !vault.seal || !vault.open) {
+                    if (!authFailure)
+                        return result;
+                    const structuredContent = {
+                        ...result.structuredContent,
+                        error: {
+                            ...result.structuredContent?.error,
+                            authorizationUrl: error.authorizationUrl ??
+                                (yield* upwardStep(authInvoke(self.options, "connectLink", [id])))
+                                    .url,
                         },
                     };
                     return {
-                        isError: true,
+                        ...result,
                         structuredContent,
                         content: [{ type: "text", text: JSON.stringify(structuredContent) }],
                     };
                 }
-            }
-            bindReplayReads(this.options.requestScope, previous.reads);
-        }
-        const browser = previous && tool === "authorize_connector" ? await this.browserProgress(previous) : undefined;
-        if (browser?.completed && previous) {
-            // Retire unspent links before the status read. A browser claim racing
-            // these CASes either wins and is observed as pending, or is refused.
-            await this.options.closeLinks(previous.connector, previous.browserNonces);
-            if ((await this.browserProgress(previous)).completed && (await this.connected(previous.connector, context))) {
-                const structuredContent = { connector: previous.connector, status: "ok" };
-                return { structuredContent, content: [{ type: "text", text: JSON.stringify(structuredContent) }] };
-            }
-        }
-        const envelope = context.mcpReq.envelope;
-        const capabilities = envelope?.[CLIENT_CAPABILITIES_META_KEY];
-        const elicitation = object(capabilities) ? capabilities.elicitation : undefined;
-        const capable = envelope?.[PROTOCOL_VERSION_META_KEY] === "2026-07-28" &&
-            object(elicitation) &&
-            Object.hasOwn(elicitation, "url") &&
-            object(elicitation.url);
-        enableAuthorizationHandoffs(this.options.requestScope, !capable);
-        let result = await operation();
-        const relayed = await this.downstream.finish(tool, args, context, result, previous);
-        if (relayed !== result)
-            return relayed;
-        const error = result.structuredContent?.error;
-        const authFailure = result.isError && object(error) && (error.code === "auth_required" || error.code === "downstream_oauth_required");
-        const explicit = tool === "authorize_connector" &&
-            ["oauth", "operator_config"].includes(String(result.structuredContent?.recovery));
-        if (!authFailure && !explicit)
-            return result;
-        const id = authFailure ? error.connector : explicit ? args.connector : undefined;
-        // Every accepted retry owns new request-local facts. Handler-authored
-        // errors and program write summaries cannot establish replay eligibility.
-        const facts = await authRecoveryFacts(this.options.requestScope, String(id));
-        const blocked = !explicit && (!facts.eligible || facts.writeEntered);
-        if (authFailure && (facts.unsafeEntered || (tool !== "call_tool" && !facts.eligible))) {
-            const structuredContent = {
-                ...result.structuredContent,
-                error: {
-                    ...error,
-                    retryable: false,
-                    reconciliationRequired: true,
-                    retry: "This call may have partially run. Reconcile its target before retrying after the operator completes recovery.",
-                },
-            };
-            result = { ...result, structuredContent, content: [{ type: "text", text: JSON.stringify(structuredContent) }] };
-        }
-        const { registry, vault, principal, publicUrl, canManage, unavailable } = this.options;
-        const connector = typeof id === "string" ? registry.getConnector(id) : undefined;
-        const recoverable = connector?.startAuth || (connector?.credential && this.options.credentialUi);
-        if (typeof id !== "string" ||
-            !/^[a-z0-9_-]+$/.test(id) ||
-            !recoverable ||
-            !principal ||
-            !publicUrl ||
-            unavailable ||
-            !canManage(id))
-            return result;
-        // Incapable hosts already received the shared explicit-authorization handoff.
-        if (!capable)
-            return result;
-        if (blocked || !vault?.requestStateKey || !vault.seal || !vault.open) {
-            if (!authFailure)
-                return result;
-            const structuredContent = {
-                ...result.structuredContent,
-                error: {
-                    ...result.structuredContent?.error,
-                    authorizationUrl: error.authorizationUrl ?? (await this.options.connectLink(id)).url,
-                },
-            };
-            return { ...result, structuredContent, content: [{ type: "text", text: JSON.stringify(structuredContent) }] };
-        }
-        if (previous && previous.round >= MAX_ROUNDS)
-            return failure("auth_round_limit", "Connection is still required after three prompts. Connect explicitly, then start a new request.");
-        // Once a verified browser has started this attempt, retries continue it.
-        // A pending consent must never be reset by another force=true prompt.
-        const forced = explicit && args.force === true;
-        const link = await this.options.connectLink(id, forced && !browser?.predecessor, forced ? browser?.predecessor : undefined);
-        const state = {
-            version: 1,
-            principal,
-            endpoint: this.options.endpoint,
-            connector: id,
-            tool,
-            ...(typeof args.address === "string" ? { address: args.address } : {}),
-            digest: requestDigest ?? (await digest(tool, args)),
-            round: (previous?.round ?? 0) + 1,
-            expiresAt: previous?.expiresAt ?? Date.now() + TTL_MS,
-            browserNonces: [...(previous?.browserNonces ?? []), link.nonce],
-            reads: [...new Map([...(previous?.reads ?? []), ...facts.reads].map((read) => [read.address, read])).values()],
-        };
-        const wire = await (await this.stateCodec()).mint(state, context);
-        if (wire.length > 8192) {
-            const structuredContent = {
-                ...result.structuredContent,
-                error: {
-                    ...result.structuredContent?.error,
-                    authorizationUrl: link.url,
-                },
-            };
-            return { ...result, structuredContent, content: [{ type: "text", text: JSON.stringify(structuredContent) }] };
-        }
-        return inputRequired({
-            inputRequests: {
-                [INPUT_KEY]: inputRequired.elicitUrl({
-                    message: MESSAGE,
-                    url: link.url,
-                }),
-            },
-            requestState: wire,
-        });
+                if (previous && previous.round >= MAX_ROUNDS)
+                    return failure("auth_round_limit", "Connection is still required after three prompts. Connect explicitly, then start a new request.");
+                // Once a verified browser has started this attempt, retries continue it.
+                // A pending consent must never be reset by another force=true prompt.
+                const forced = explicit && args.force === true;
+                const link = yield* upwardStep(authInvoke(self.options, "connectLink", [
+                    id,
+                    forced && !browser?.predecessor,
+                    forced ? browser?.predecessor : undefined,
+                ]));
+                const state = {
+                    version: 1,
+                    principal,
+                    endpoint: self.options.endpoint,
+                    connector: id,
+                    tool,
+                    ...(typeof args.address === "string" ? { address: args.address } : {}),
+                    wireTool: context.http?.req?.headers.get("Mcp-Name") ?? tool,
+                    digest: requestDigest ?? (yield* upwardStep(authCall(digest, [tool, args]))),
+                    round: (previous?.round ?? 0) + 1,
+                    expiresAt: previous?.expiresAt ?? Date.now() + TTL_MS,
+                    browserNonces: [...(previous?.browserNonces ?? []), link.nonce],
+                    reads: [
+                        ...new Map([...(previous?.reads ?? []), ...facts.reads].map((read) => [read.address, read])).values(),
+                    ],
+                };
+                const wire = yield* upwardStep(authInvoke(yield* upwardStep(authInvoke(self, "stateCodec", [])), "mint", [state, context]));
+                // Signed state and its connect link carry only Connecta's facts: a coincidental match must
+                // not corrupt them.
+                sentSecretsForRequest(self.options.requestScope).mintedState(wire);
+                sentSecretsForRequest(self.options.requestScope).mintedState(link.url);
+                if (wire.length > 8192) {
+                    const structuredContent = {
+                        ...result.structuredContent,
+                        error: {
+                            ...result.structuredContent?.error,
+                            authorizationUrl: link.url,
+                        },
+                    };
+                    return {
+                        ...result,
+                        structuredContent,
+                        content: [{ type: "text", text: JSON.stringify(structuredContent) }],
+                    };
+                }
+                return inputRequired({
+                    inputRequests: {
+                        [INPUT_KEY]: inputRequired.elicitUrl({
+                            message: MESSAGE,
+                            url: link.url,
+                        }),
+                    },
+                    requestState: wire,
+                });
+            }), this.options.requestSignal).pipe(Effect.provideService(RequestScope, requestOwner(this.options.requestScope)));
+        }, AuthElicitation.prototype.run);
+        registerAuthMethod(AuthElicitation.prototype, "connected", function (id, context) {
+            const self = this;
+            return authAwait(authFlow(function* () {
+                const { registry, publicUrl, vault, principal, defer } = self.options;
+                const connector = registry.getConnector(id);
+                const scope = {};
+                const signal = AbortSignal.any([context.mcpReq.signal, self.options.requestSignal]);
+                try {
+                    return yield* upwardStep(withDeadlineEffect((deadline) => Effect.gen(function* () {
+                        const ctx = registry.contextFor(id, publicUrl, scope, { signal: deadline });
+                        yield* upwardStep(Effect.addFinalizer(() => closeScope(connector, ctx, defer)));
+                        if (connector.credential) {
+                            const metadata = yield* upwardStep(Effect.promise(() => vault.metadata(id, connector.authScope === "personal" ? principal : undefined)));
+                            if (storedCredentialShape(connector.credential, metadata?.fields ?? null).state !== "valid")
+                                return false;
+                        }
+                        if (!connector.status)
+                            return Boolean(connector.credential);
+                        return ((yield* upwardStep(registryProgram(registry, "statusFor", id, publicUrl, scope, { signal: deadline }))).state === "ok");
+                    }).pipe(Effect.scoped), { signal, timeoutMs: 5000, timeoutError: new Error("Auth status check timed out") }));
+                }
+                catch {
+                    return false;
+                }
+            }), this.options.requestSignal).pipe(Effect.provideService(RequestScope, requestOwner(this.options.requestScope)));
+        }, AuthElicitation.prototype.connected);
+        registerAuthMethod(AuthElicitation.prototype, "browserProgress", function (state) {
+            const self = this;
+            return authAwait(authFlow(function* () {
+                let started;
+                let claimed;
+                let completed = false;
+                let pending = false;
+                for (const nonce of state.browserNonces) {
+                    const progress = yield* upwardStep(authInvoke(self.options, "linkProgress", [
+                        state.connector,
+                        nonce,
+                    ]));
+                    if (progress === "started")
+                        started = nonce;
+                    if (progress === "claimed")
+                        claimed = nonce;
+                    completed ||= progress === "started";
+                    pending ||= progress === "claimed";
+                }
+                const predecessor = started ?? claimed;
+                return { ...(predecessor ? { predecessor } : {}), completed: completed && !pending };
+            }), this.options.requestSignal).pipe(Effect.provideService(RequestScope, requestOwner(this.options.requestScope)));
+        }, AuthElicitation.prototype.browserProgress);
+        registerAuthMethod(AuthElicitation.prototype, "verify", function (wire, context) {
+            const self = this;
+            return authAwait(authFlow(function* () {
+                const { vault, endpoint, principal, registry, canManage } = self.options;
+                if (!vault?.requestStateKey || wire.length > MAX_RELAY_STATE_CHARS)
+                    return invalidState();
+                const state = yield* upwardStep(authInvoke(yield* upwardStep(authInvoke(self, "stateCodec", [])), "verify", [wire, context]));
+                if (object(state) && state.version === 2 && state.kind === "downstream")
+                    return yield* upwardStep(authInvoke(self.downstream, "verify", [state, context]));
+                if (wire.length > 8192)
+                    return invalidState();
+                if (!object(state) ||
+                    state.version !== 1 ||
+                    !principal ||
+                    state.principal !== principal ||
+                    state.endpoint !== endpoint ||
+                    typeof state.connector !== "string" ||
+                    !registry.getConnector(state.connector) ||
+                    !canManage(state.connector) ||
+                    !Number.isSafeInteger(state.expiresAt) ||
+                    state.expiresAt <= Date.now() ||
+                    state.expiresAt > Date.now() + TTL_MS ||
+                    !Number.isInteger(state.round) ||
+                    state.round < 1 ||
+                    state.round > MAX_ROUNDS ||
+                    !["call_tool", "call_destructive_tool", "execute_code", "authorize_connector"].includes(String(state.tool)) ||
+                    typeof state.wireTool !== "string" ||
+                    typeof state.digest !== "string" ||
+                    !/^[a-f0-9]{64}$/.test(state.digest) ||
+                    !Array.isArray(state.browserNonces) ||
+                    state.browserNonces.length !== state.round ||
+                    !state.browserNonces.every((nonce) => typeof nonce === "string" && /^[a-f0-9-]{36}$/.test(nonce)) ||
+                    !Array.isArray(state.reads) ||
+                    !state.reads.every((read) => object(read) &&
+                        typeof read.address === "string" &&
+                        typeof read.digest === "string" &&
+                        /^[a-f0-9]{64}$/.test(read.digest)) ||
+                    (state.address !== undefined && typeof state.address !== "string"))
+                    return invalidState();
+                if (context.mcpReq.method !== "tools/call" || context.http?.req?.headers.get("Mcp-Name") !== state.wireTool)
+                    return invalidState();
+                return state;
+            }), this.options.requestSignal).pipe(Effect.provideService(RequestScope, requestOwner(this.options.requestScope)));
+        }, AuthElicitation.prototype.verify);
     }
 }