@zackbart/connecta 0.37.1 → 0.39.0

package/dist/connectors/guarded-fetch.d.ts

@@ -1,5 +1,4 @@
 export { retryAfterMs } from "../http-policy.js";
-import { type ProviderRequest } from "../provider-call.js";
 import type { ConnectorContext } from "../types.js";
 /** The methods a hand-written provider surface actually uses. */
 type GuardedMethod = "GET" | "HEAD" | "POST" | "PUT" | "PATCH" | "DELETE";
@@ -182,11 +181,6 @@ type GuardedFetcher = (url: string, init: RequestInit, ctx: ConnectorContext) =>
 export declare function oauthBearer(provider: string): Pick<GuardedFetchOptions, "authenticate" | "fetch">;
 /** Send one guarded request and map its response with provider knowledge. */
 export type GuardedTransport = <T>(request: GuardedRequest, ctx: ConnectorContext, map: GuardedResponseMapper<T>) => Promise<T>;
-/**
- * Test-only legacy response lookup for renewal-provenance fixtures outside
- * the kit. Production renewal uses the kit ledger. Undefined for other objects.
- */
-export declare function answeredRequest(response: object): ProviderRequest | undefined;
 /**
  * Build the transport a connector sends every request through. `maxResponseBytes`
  * is required rather than defaulted: what counts as an absurd response is a fact

package/dist/connectors/guarded-fetch.js

@@ -3,7 +3,7 @@ export { retryAfterMs } from "../http-policy.js";
 import { callerSignal, duringViewCall, settleOnClose, viewSignal } from "../runtime/call.js";
 /**
  * The safety machinery every hand-written HTTP surface needs, extracted once
- * (#341): path confinement, encoded query and framed bodies, per-request
+ *: path confinement, encoded query and framed bodies, per-request
  * credential headers applied last, a refused redirect, a bounded read, and
  * network-failure normalization. It owns no vendor-specific meaning and never
  * invents an auth scheme, because the same 403 means an ungranted
@@ -280,15 +280,6 @@ async function jsonResult(read) {
         return { parseError: cause };
     }
 }
-// Each response a mapper reads, and the ledger entry of the request it answered.
-const answeredRequests = new WeakMap();
-/**
- * Test-only legacy response lookup for renewal-provenance fixtures outside
- * the kit. Production renewal uses the kit ledger. Undefined for other objects.
- */
-export function answeredRequest(response) {
-    return answeredRequests.get(response);
-}
 /**
  * Build the transport a connector sends every request through. `maxResponseBytes`
  * is required rather than defaulted: what counts as an absurd response is a fact
@@ -463,7 +454,6 @@ export function guardedFetch(options) {
                 throw oversized(provider, limit, `a declared ${declared} bytes`);
             }
             const answer = boundedResponse(provider, response, limit, signal);
-            answeredRequests.set(answer, dispatch);
             const abort = () => {
                 void response?.body?.cancel().catch(() => { });
             };

package/dist/connectors/negotiation-cache.js

@@ -4,7 +4,8 @@ import { isSpecType } from "@modelcontextprotocol/client";
 import { failureRecord, logFailure } from "../operator-record.js";
 import { sentSecretsForRequest } from "../sent-secrets.js";
 import { assertDownstreamOutputSafe } from "../downstream-input-context.js";
-import { negotiationKeys, NEGOTIATION_TTL_SECONDS } from "../storage/keys.js";
+import { LEGACY_NEGOTIATION_TTL_SECONDS, negotiationKeys, NEGOTIATION_TTL_SECONDS } from "../storage/keys.js";
+import { viewReads } from "../runtime/call.js";
 /** Verdicts carry data only. Clients, signals and secrets remain request-local. */
 export function readNegotiation(ctx, digest) {
     return runEdge(authProgram(readNegotiationNative, [ctx, digest]));
@@ -12,7 +13,11 @@ export function readNegotiation(ctx, digest) {
 const readNegotiationNative = /* @__PURE__ */ registerAuth(readNegotiation, (ctx, digest) => authFlow(function* () {
     let prior;
     try {
-        const raw = (yield authStorage(ctx.storage, "get", [negotiationKeys.verdict(digest)]));
+        // Memoized per request: a verdict only orders the versions a handshake
+        // tries, so one read earlier in this request at worst costs a fallback.
+        // This request's own storeNegotiation is a write, which clears the memo.
+        const key = negotiationKeys.verdict(digest);
+        const raw = (yield viewReads(ctx).read(ctx.storage, key, authStorage(ctx.storage, "get", [key])));
         if (!raw)
             return;
         const value = JSON.parse(raw);
@@ -40,17 +45,30 @@ const storeNegotiationNative = /* @__PURE__ */ registerAuth(storeNegotiation, (c
     const clean = sentSecretsForRequest(ctx.requestScope ?? ctx).redactCredentials(prior);
     if (clean.kind === "modern" && !isSpecType.DiscoverResult(clean.discover))
         return;
+    const ttlSeconds = clean.kind === "legacy" ? LEGACY_NEGOTIATION_TTL_SECONDS : NEGOTIATION_TTL_SECONDS;
     try {
         (yield authStorage(ctx.storage, "set", [
             negotiationKeys.verdict(digest),
             JSON.stringify({
                 prior: clean,
-                expiresAt: Date.now() + NEGOTIATION_TTL_SECONDS * 1000,
+                expiresAt: Date.now() + ttlSeconds * 1000,
             }),
-            { ttlSeconds: NEGOTIATION_TTL_SECONDS },
+            { ttlSeconds },
         ]));
     }
     catch (error) {
         logFailure(ctx.logger, "negotiation cache write failed", failureRecord({}, error));
     }
 }));
+/** Drop a verdict the downstream has contradicted, so the next connect negotiates. */
+export function forgetNegotiation(ctx, digest) {
+    return runEdge(authProgram(forgetNegotiationNative, [ctx, digest]));
+}
+const forgetNegotiationNative = /* @__PURE__ */ registerAuth(forgetNegotiation, (ctx, digest) => authFlow(function* () {
+    try {
+        (yield authStorage(ctx.storage, "delete", [negotiationKeys.verdict(digest)]));
+    }
+    catch (error) {
+        logFailure(ctx.logger, "negotiation cache write failed", failureRecord({}, error));
+    }
+}));

package/dist/connectors/remote-mcp/call.js

@@ -0,0 +1,164 @@
+// tools/call: classification, write-once dispatch and the write's outcome
+// when it fails.
+import { authView } from "../../auth/native-call.js";
+import { authFlow, authCall, authInvoke, authMethod, authCatch } from "../../auth/native.js";
+import { ProtocolError, isInputRequiredResult, fromJsonSchema, UnauthorizedError, } from "@modelcontextprotocol/client";
+import { Effect } from "effect";
+import { requestSentSecrets } from "../../sent-secrets.js";
+import { ConnectorCallError } from "../../errors.js";
+import { carryFailureFacts, failureRecord } from "../../operator-record.js";
+import { assertDownstreamOutputSafe } from "../../downstream-input-context.js";
+import { callClassification } from "../../call-classification.js";
+import { sourceClassification } from "../../tool-safety.js";
+import { enterProviderBoundary, knownProviderFailure, providerRequest, vendorRefusal, } from "../../provider-call.js";
+import { providerCallFailure, unsentAfterUnauthorized } from "../../write-outcome.js";
+import { newDispatch, withDispatch } from "./transport.js";
+import { downstreamCallError, hasSdkPayload, ownAbortReason, requiresAuthorization } from "./errors.js";
+/** One connector's callTool operation, before the entry's wrappers. */
+export function remoteMcpCall(rt) {
+    const { isOauth, id } = rt;
+    const callToolOperation = authMethod((name, args, ctx, options) => authFlow(function* () {
+        enterProviderBoundary(ctx, rt.connector);
+        let active;
+        try {
+            return (yield authView(ctx, authMethod(() => authFlow(function* () {
+                const state = rt.stateFor(ctx);
+                const client = (yield authCatch(authCall(rt.ensureConnected, [ctx, state]), (error) => {
+                    throw knownProviderFailure(error);
+                }));
+                if (isOauth)
+                    (yield authCatch(authCall(rt.renewBeforeDispatch, [ctx, state, client]), (error) => {
+                        throw knownProviderFailure(error);
+                    }));
+                const definition = options?.definition;
+                const facts = definition ?? state.toolDefinitions.get(name) ?? { name };
+                const sourceFacts = definition ?? {
+                    name,
+                    ...(facts.annotations
+                        ? { annotations: facts.annotations }
+                        : {}),
+                };
+                const source = sourceClassification(sourceFacts);
+                const serverWrite = source === "write";
+                const write = serverWrite || (callClassification(ctx) ?? definition?.classification ?? source) === "write";
+                const dispatch = newDispatch(write, serverWrite);
+                dispatch.request = {
+                    entry: providerRequest(ctx, !write, `Connector "${id}"'s MCP server`, { method: "POST" }),
+                    ctx,
+                };
+                active = { state, client, dispatch, write };
+                state.dispatches.set(dispatch, name);
+                const toolDefinition = definition
+                    ? {
+                        ...definition,
+                        inputSchema: (definition.inputSchema ?? { type: "object" }),
+                    }
+                    : state.toolDefinitions.get(name);
+                if (toolDefinition?.execution?.taskSupport === "required") {
+                    throw new ConnectorCallError("connector_call_failed", `Tool "${name}" requires task-based execution, which Connecta does not support.`);
+                }
+                let output;
+                const outputError = (code, message) => rt.atMcpBoundary(ctx, new ProtocolError(code, message), "tools/call", client.transport, [ctx.signal]);
+                if (toolDefinition?.outputSchema) {
+                    try {
+                        output = fromJsonSchema(toolDefinition.outputSchema);
+                    }
+                    catch {
+                        throw outputError(-32602, `Tool '${name}' has an invalid outputSchema: schema could not be compiled`);
+                    }
+                }
+                const result = (yield authCatch(authInvoke(client, "callTool", [
+                    withDispatch({
+                        name,
+                        arguments: (args ?? {}),
+                        ...options?.input,
+                    }, dispatch),
+                    {
+                        ...rt.requestOptions(ctx),
+                        allowInputRequired: true,
+                        ...(toolDefinition
+                            ? { toolDefinition: { ...toolDefinition, outputSchema: undefined } }
+                            : write
+                                ? { toolDefinition: { name, inputSchema: { type: "object" } } }
+                                : {}),
+                    },
+                ]), (err) => {
+                    assertDownstreamOutputSafe(ctx.requestScope ?? ctx, err);
+                    throw rt.atMcpBoundary(ctx, err, "tools/call", client.transport, [ctx.signal]);
+                }));
+                if (isInputRequiredResult(result)) {
+                    return result;
+                }
+                assertDownstreamOutputSafe(ctx.requestScope ?? ctx, result);
+                if (output && !result.isError) {
+                    if (result.structuredContent === undefined)
+                        throw outputError(-32600, `Tool ${name} has an output schema but did not return structured content`);
+                    const validation = (yield authInvoke(output["~standard"], "validate", [
+                        result.structuredContent,
+                    ]));
+                    if (validation.issues)
+                        throw outputError(-32602, "Structured content does not match the tool's output schema: validation failed");
+                }
+                return result;
+            }))));
+        }
+        catch (err) {
+            if (!active)
+                throw knownProviderFailure(err);
+            const { state, client, dispatch, write } = active;
+            const direct = write && callClassification(ctx) === undefined;
+            const ownAbort = ownAbortReason(err, [ctx.signal]) && !hasSdkPayload(err);
+            // The SDK can reject its wait synchronously from the abort event,
+            // before the physical response's Promise observer records its facts.
+            // Yield only settlement; no closed caller regains live authority.
+            if (ownAbort)
+                yield Effect.yieldNow;
+            if (ownAbort && !direct)
+                throw err;
+            if (requiresAuthorization(err) && state.client === client)
+                state.authRequired = true;
+            const failure = ownAbort
+                ? err
+                : err instanceof UnauthorizedError
+                    ? carryFailureFacts(err, rt.authRequiredError(ctx))
+                    : downstreamCallError(err, undefined, undefined, undefined, requestSentSecrets(ctx));
+            if (!write)
+                throw failure;
+            const renewal = dispatch.request?.entry.renewed
+                ? undefined
+                : dispatch.resendRefused
+                    ? rt.authRequiredError(ctx)
+                    : failure;
+            const unsent = (entry) => {
+                const verdict = unsentAfterUnauthorized(`Connector "${id}"'s MCP server`, renewal, isOauth ? "downstream_oauth_required" : "auth_required");
+                return entry ? vendorRefusal(verdict, entry) : verdict;
+            };
+            const verdict = dispatch.unauthorized
+                ? unsent(dispatch.request?.entry)
+                : dispatch.redirected || dispatch.resendRefused
+                    ? new ConnectorCallError("connector_call_failed", `Connector "${id}"'s MCP server ` +
+                        (dispatch.redirected
+                            ? "answered this write with a redirect, and the write was not sent again, "
+                            : "was sent this write, and a second send of it was stopped, ") +
+                        "so whether it took effect is unknown: check the target before repeating it.", { retryable: false, writeOutcome: "unknown" })
+                    : dispatch.ambiguous && failure instanceof ConnectorCallError
+                        ? new ConnectorCallError(failure.code, `${failure.message} Connector "${id}"'s MCP server answered this write with an HTTP error ` +
+                            "and no MCP error, so whether it took effect is unknown: check the target before repeating it.", { retryable: false, writeOutcome: "unknown" })
+                        : failure;
+            const vendor = { title: `connector "${id}"` };
+            const status = failureRecord({}, err).httpStatus;
+            const settled = providerCallFailure(ctx, vendor, verdict, {
+                dispatched: dispatch.sent,
+                ...(status === undefined ? {} : { status }),
+                fallback: "write",
+                request: dispatch.request?.entry,
+            });
+            throw settled === failure ? failure : carryFailureFacts(failure, settled);
+        }
+        finally {
+            if (active)
+                active.state.dispatches.delete(active.dispatch);
+        }
+    }));
+    return { callToolOperation };
+}

package/dist/connectors/remote-mcp/catalog.js

@@ -0,0 +1,278 @@
+// Catalog intake: every tools/resources listing page is checked before the
+// SDK can aggregate or cache it (INV-8), and listTools serves the result.
+import { authFlow, authCall, authInvoke, authMethod } from "../../auth/native.js";
+import { SdkHttpError, specTypeSchemas, UnauthorizedError } from "@modelcontextprotocol/client";
+import { redactCatalog } from "../../sent-secrets.js";
+import { MAX_CATALOG_TOOLS, MAX_SERIALIZED_CATALOG_BYTES } from "../../catalog-limits.js";
+import { catalogItems, observeCompletedCatalogRefresh, observeCatalogFetch, observeCatalogExpiry, } from "../../catalog-cache.js";
+import { ConnectorCallError, msg } from "../../errors.js";
+import { carryFailureFacts, failureRecord, logFailure } from "../../operator-record.js";
+import { assertDownstreamOutputSafe } from "../../downstream-input-context.js";
+import { hasSdkPayload, ownAbortReason, requiresAuthorization } from "./errors.js";
+/** SDK aggregation cap; intake also refuses loops and non-progress (INV-8). */
+export const MAX_TOOL_PAGES = 10_000;
+/**
+ * Compatibility concession for hand-rolled servers that serialize
+ * end-of-pagination as `null`. Only the cursor is widened; every tool and every
+ * other result field still passes through the SDK's pinned schema.
+ */
+const CompatibleListToolsResultSchema = {
+    "~standard": {
+        version: 1,
+        vendor: "connecta",
+        validate(value) {
+            const normalized = typeof value === "object" && value !== null && "nextCursor" in value && value.nextCursor === null
+                ? (() => {
+                    const copy = { ...value };
+                    delete copy.nextCursor;
+                    return copy;
+                })()
+                : value;
+            return specTypeSchemas.ListToolsResult["~standard"].validate(normalized);
+        },
+    },
+};
+/**
+ * True for a result-parse failure caused by the page's `nextCursor` itself.
+ * `null` is accepted deliberately; other non-string values remain a named
+ * downstream nonconformance instead of surfacing as a raw validation dump.
+ * Duck-typed rather than `instanceof ZodError`: the SDK may parse with its own
+ * zod instance, and cross-instance `instanceof` is a coin flip.
+ */
+function isCursorShapeError(err) {
+    const issues = err?.issues;
+    if (Array.isArray(issues) &&
+        issues.some((issue) => {
+            const path = issue.path;
+            return Array.isArray(path) && path[0] === "nextCursor";
+        })) {
+        return true;
+    }
+    // SDK v2 wraps Standard Schema failures in a ProtocolError and preserves the
+    // failing path in the message rather than exposing the validator's issues.
+    return msg(err).startsWith("Invalid result for tools/list: nextCursor:");
+}
+/** One connector's catalog intake and listTools operation. */
+export function remoteMcpCatalog(rt) {
+    const { id } = rt;
+    // Listings that must reach the downstream: a credential test proves the
+    // stored value against the server, never against a cached catalog.
+    const liveListings = new WeakSet();
+    /** Wrap the public request seam, before listTools aggregates or auto-caches.
+     * SDK 2.3.1 treats an identical repeated page as completion. Refuse it here:
+     * an advertised successor is never proof of a complete catalog (INV-8). */
+    const listingContexts = new WeakMap();
+    const installCatalogIntake = (client, ctx, cache) => {
+        let toolPages = 0;
+        const listingContext = (options) => {
+            const { signal: _signal, timeoutMs: _timeout, ...base } = ctx;
+            return ((options && listingContexts.get(options)) ?? {
+                ...base,
+                requestScope: ctx.requestScope ?? ctx,
+                ...(options?.signal ? { signal: options.signal } : {}),
+                ...(options?.timeout ? { timeoutMs: options.timeout } : {}),
+            });
+        };
+        const listTools = client.listTools.bind(client);
+        client.listTools = authMethod((params, options) => authInvoke(cache, "withListing", [
+            listingContext(options),
+            authMethod(() => authFlow(function* () {
+                const before = toolPages;
+                let result;
+                try {
+                    result = (yield authCall(listTools, [params, options]));
+                }
+                catch (error) {
+                    const bounded = rt.atMcpBoundary(cache.currentContext(), error, "tools/list", client.transport, [
+                        cache.currentContext().signal,
+                    ]);
+                    const transient = (error instanceof SdkHttpError && [502, 503, 504].includes(error.status)) ||
+                        (bounded instanceof ConnectorCallError && bounded.code === "unavailable");
+                    const fallback = transient && toolPages === before
+                        ? (yield authInvoke(cache, "fallbackTools", []))
+                        : undefined;
+                    if (!fallback)
+                        throw error;
+                    return fallback;
+                }
+                if (toolPages !== before && params?.cursor === undefined) {
+                    const refresh = (yield authInvoke(cache, "completeCatalogRefresh", [result]));
+                    if (refresh) {
+                        try {
+                            (yield authCall(observeCompletedCatalogRefresh, [cache.currentContext(), refresh]));
+                        }
+                        catch (error) {
+                            logFailure(cache.currentContext().logger, "catalog refresh observation failed", failureRecord({ connector: id }, error));
+                        }
+                    }
+                }
+                return result;
+            })),
+        ]));
+        const listResources = client.listResources.bind(client);
+        client.listResources = authMethod((params, options) => authInvoke(cache, "withListing", [
+            listingContext(options),
+            authMethod(() => authCall(listResources, [params, options])),
+        ]));
+        const listResourceTemplates = client.listResourceTemplates.bind(client);
+        client.listResourceTemplates = authMethod((params, options) => authInvoke(cache, "withListing", [
+            listingContext(options),
+            authMethod(() => authCall(listResourceTemplates, [params, options])),
+        ]));
+        const request = client.request.bind(client);
+        const walks = new WeakMap();
+        client.request = authMethod((...args) => authFlow(function* () {
+            const message = args[0];
+            if (message.method !== "tools/list" &&
+                message.method !== "resources/list" &&
+                message.method !== "resources/templates/list")
+                return yield authCall(request, args, client);
+            const method = message.method;
+            const ctx = cache.currentContext();
+            const options = (args.length === 3 ? args[2] : args[1]);
+            if (rt.isClosed(rt.entryFor(ctx)))
+                throw rt.scopeEndedError();
+            if (options?.signal?.aborted)
+                throw options.signal.reason;
+            const key = options ?? message;
+            let walk = walks.get(key);
+            if (message.params?.cursor === undefined || !walk) {
+                walk = { names: new Set(), cursors: new Set(), barren: 0, bytes: 0 };
+                walks.set(key, walk);
+            }
+            let page;
+            try {
+                page = (yield authCall(request, [
+                    message,
+                    method === "tools/list"
+                        ? CompatibleListToolsResultSchema
+                        : method === "resources/list"
+                            ? specTypeSchemas.ListResourcesResult
+                            : specTypeSchemas.ListResourceTemplatesResult,
+                    options,
+                ]));
+            }
+            catch (error) {
+                if (isCursorShapeError(error))
+                    throw new ConnectorCallError("connector_call_failed", "Downstream catalog nextCursor must be a string, null, or absent.", { retryable: false });
+                throw error;
+            }
+            assertDownstreamOutputSafe(ctx.requestScope ?? ctx, page);
+            const clean = cache.intake(ctx, method, page);
+            if (method === "tools/list")
+                toolPages++;
+            if (message.params?.cursor === undefined)
+                observeCatalogFetch(ctx, Date.now(), method);
+            const tools = catalogItems(method, clean).filter((item) => {
+                const name = method === "tools/list"
+                    ? item.name
+                    : method === "resources/list"
+                        ? item.uri
+                        : item.uriTemplate;
+                if (walk.names.has(name))
+                    return false;
+                walk.names.add(name);
+                return true;
+            });
+            walk.bytes += new TextEncoder().encode(JSON.stringify(tools)).byteLength;
+            if (walk.names.size > MAX_CATALOG_TOOLS || walk.bytes > MAX_SERIALIZED_CATALOG_BYTES) {
+                throw new ConnectorCallError("connector_call_failed", "Downstream catalog exceeds the complete-catalog ceiling.", { retryable: false });
+            }
+            if (clean.nextCursor !== undefined) {
+                if (walk.cursors.has(clean.nextCursor))
+                    throw new ConnectorCallError("connector_call_failed", "Downstream catalog pagination chain loops.", {
+                        retryable: false,
+                    });
+                if (tools.length === 0 && ++walk.barren > 1)
+                    throw new ConnectorCallError("connector_call_failed", "Downstream catalog pagination is not advancing.", {
+                        retryable: false,
+                    });
+                if (tools.length > 0)
+                    walk.barren = 0;
+                walk.cursors.add(clean.nextCursor);
+            }
+            const field = method === "tools/list" ? "tools" : method === "resources/list" ? "resources" : "resourceTemplates";
+            const result = { ...clean, [field]: tools };
+            if (!walk.first)
+                walk.first = result;
+            else {
+                walk.first.ttlMs = Math.min(walk.first.ttlMs, clean.ttlMs);
+                if (clean.cacheScope !== "public")
+                    walk.first.cacheScope = "private";
+            }
+            observeCatalogExpiry(ctx, method, walk.first.ttlMs);
+            return result;
+        }));
+    };
+    // The SDK walks the whole chain and writes one complete result. Intake
+    // runs on its public request seam before any page can enter that cache.
+    const listToolsOperation = authMethod((ctx) => authFlow(function* () {
+        const state = rt.stateFor(ctx);
+        // Without a connection in this scope, a complete cached catalog is
+        // served as it stands. A live connection reads the same cache through
+        // the SDK, and a credential test always lists live.
+        const cached = state.client || state.connecting || state.authRequired || liveListings.has(ctx)
+            ? {}
+            : (yield authCall(rt.cachedCatalog, [ctx]));
+        let clean;
+        if (cached.tools)
+            clean = redactCatalog(ctx, cached.tools);
+        else {
+            const client = (yield authCall(rt.ensureConnected, [ctx, state, cached]));
+            // A credential test must observe the downstream answer itself, never
+            // the SDK cache a modern connection reads without any request.
+            const options = {
+                ...rt.requestOptions(ctx),
+                ...(liveListings.has(ctx) ? { cacheMode: "bypass" } : {}),
+            };
+            listingContexts.set(options, ctx);
+            try {
+                const result = (yield authInvoke(client, "listTools", [undefined, options]));
+                clean = redactCatalog(ctx, result.tools);
+            }
+            catch (err) {
+                if (ownAbortReason(err, [ctx.signal]) && !hasSdkPayload(err))
+                    throw err;
+                const bounded = rt.atMcpBoundary(ctx, err, "tools/list", client.transport, [ctx.signal]);
+                if (requiresAuthorization(bounded)) {
+                    if (state.client === client)
+                        state.authRequired = true;
+                    if (bounded instanceof UnauthorizedError)
+                        throw carryFailureFacts(bounded, rt.authRequiredError(ctx));
+                }
+                throw bounded;
+            }
+            finally {
+                listingContexts.delete(options);
+            }
+        }
+        state.toolDefinitions = new Map(clean.map((tool) => [tool.name, tool]));
+        return clean.map((t) => ({
+            name: t.name,
+            ...(t.title !== undefined ? { title: t.title } : {}),
+            ...(t.icons !== undefined
+                ? {
+                    icons: t.icons.filter((icon) => !/^data:/i.test(icon.src)),
+                }
+                : {}),
+            ...(t.execution !== undefined ? { execution: t.execution } : {}),
+            ...(t.description !== undefined ? { description: t.description } : {}),
+            ...(t.inputSchema !== undefined
+                ? {
+                    inputSchema: t.inputSchema,
+                }
+                : {}),
+            ...(t.outputSchema !== undefined
+                ? {
+                    outputSchema: t.outputSchema,
+                }
+                : {}),
+            ...(t.annotations !== undefined
+                ? {
+                    annotations: t.annotations,
+                }
+                : {}),
+        }));
+    }));
+    return { installCatalogIntake, listingContexts, liveListings, listToolsOperation };
+}