@zackbart/connecta 0.38.0 → 0.40.0

package/dist/config.js

@@ -69,8 +69,10 @@ const discovery = {
     /**
      * Deadline (ms) for each downstream probe/catalog call fanned out by
      * `search_tools` and by `connecta.search`/`connecta.describe` inside
-     * `execute_code`. Defaults to 30_000. A timed-out connector degrades
-     * independently; this does not apply to tool calls. Catalog walks receive the
+     * `execute_code`. Defaults to 30_000. An unscoped search caps each probe at
+     * 5_000 and its whole fan-out at 9_000, and skips a connector whose
+     * discovery recently timed out for up to 60 seconds. A timed-out connector
+     * degrades independently; this does not apply to tool calls. Catalog walks receive the
      * same cancellation signal, which aborts an in-flight page where supported and
      * prevents another from starting.
      */
@@ -237,8 +239,9 @@ const pool = {
     /**
      * Who may open `/mcp/<name>`: principal ids in the namespace of the one
      * interactive auth provider, `{ namespace, id }`, or `"agent:<name>"` for a
-     * declared agent. Required and non-empty; the pool serves exactly its
-     * `tools` to these members and the same 404 to everyone else.
+     * declared agent. All members must be people or all must be agents. Required
+     * and non-empty; the pool serves exactly its `tools` to these members and
+     * the same 404 to everyone else.
      */
     members: required(opaque({ check: assertMemberList }), (path) => `${path} is required: list who may open this pool, as principal ids, { namespace, id }, or "agent:<name>".`),
     /**
@@ -246,8 +249,8 @@ const pool = {
      * connector whose `subject` is a mapping function. Humans always act as
      * themselves through that mapping, and a fixed `subject` address applies to
      * everyone. Without an owner, a mapping-subject Workspace connector is
-     * absent for this pool's agents, as a personal connector is; people in the
-     * pool still see it.
+     * absent for this pool's agents, as a personal connector is. People use a
+     * separate pool and always act as themselves.
      */
     owner: opaque({
         check: (value, path) => {

package/dist/connector-caller.d.ts

@@ -9,7 +9,7 @@ export interface ConnectorCaller {
      * with or without a subject, a Connecta-issued access token.
      */
     authenticated: boolean;
-    /** The pool the call arrived on, at `/mcp/<pool>` or `/agent/<pool>`. */
+    /** The admitted pool: routed at `/mcp` or selected at `/mcp/<pool>` or `/agent/<pool>`. */
     pool?: string;
     /**
      * That pool's configured `owner`, the Workspace address an agent acts as

package/dist/connector-health.js

@@ -0,0 +1,59 @@
+// Where one connector's bounded health facts are stored for a registry view:
+// the catalog cache's store and owner partition (principal, subject, caller
+// identity and pool, origin) and the admitted endpoint, with the connector's
+// described configuration and the package version, through the deployment's
+// keyed digest (a described endpoint keeps its path), beside the catalog
+// invalidation generation those facts must match (INV-4, INV-5). Shared by
+// discovery health and the operator page's status observations.
+import { Effect } from "effect";
+import { catalogOwnerPartition } from "./catalog-policy.js";
+import { canonicalJson } from "./canonical-json.js";
+import { secretDigest } from "./storage-digest.js";
+import { responseCacheKeys } from "./storage/keys.js";
+import { CONNECTA_VERSION } from "./version.js";
+// A connector's described configuration, serialized once per connector object.
+// A change `describe()` cannot see, such as a static header rotated in
+// deployment code, takes effect on redeploy and leaves an earlier record to
+// lapse within its TTL.
+const configs = new WeakMap();
+function describedConfig(connector) {
+    let config = configs.get(connector);
+    if (config === undefined) {
+        let described = null;
+        try {
+            described = connector.describe?.() ?? null;
+        }
+        catch {
+            described = null;
+        }
+        config = canonicalJson([CONNECTA_VERSION, connector.kind ?? null, connector.authScope ?? null, described]);
+        configs.set(connector, config);
+    }
+    return config;
+}
+// The endpoint a request was admitted at (plain `/mcp`, a pool, an agent
+// path). The same person and pool can reach one connector through several,
+// and each keeps its own records. The operator page binds none.
+const endpoints = new WeakMap();
+/** Bind the admitted endpoint to a request scope, before any discovery runs in it. */
+export function bindDiscoveryEndpoint(requestScope, endpoint) {
+    endpoints.set(requestScope, endpoint);
+}
+/** Where one connector's records sit in this view's owner partition. */
+export function healthAddress(registry, id, baseUrl, requestScope) {
+    return Effect.suspend(() => {
+        const connector = registry.getConnector(id);
+        if (!connector)
+            return Effect.succeed(undefined);
+        const ctx = registry.contextFor(id, baseUrl, requestScope);
+        const { storage, partition } = catalogOwnerPartition(ctx);
+        if (!storage)
+            return Effect.succeed(undefined);
+        return Effect.promise(async () => ({
+            storage,
+            digest: await secretDigest(ctx, JSON.stringify([partition, endpoints.get(requestScope) ?? null, describedConfig(connector)])),
+            generationKey: responseCacheKeys.generation(id),
+            logger: ctx.logger,
+        }));
+    }).pipe(Effect.catchCause(() => Effect.succeed(undefined)));
+}

package/dist/connector-status.js

@@ -0,0 +1,117 @@
+// The operator page's stored connector status (#1173 item 2.3).
+//
+// A live detail read records what it saw, one observation per connector and
+// viewer partition, beside discovery health in the connector-health family and
+// under the same owner partition and catalog generation (INV-4, INV-5). The
+// detail route can then answer at once from storage, labelled with its age,
+// and the browser asks for a live read separately. An observation holds only
+// a state, a problem code, a tool count and its time (INV-6); the tools stay
+// in the complete catalog cache (INV-8). It is never deferred work: a live
+// read writes it before its response, and nothing refreshes it afterwards.
+import { Effect } from "effect";
+import { healthAddress } from "./connector-health.js";
+import { failureRecord, logFailure } from "./operator-record.js";
+import { causeError } from "./runtime/run.js";
+import { Storage } from "./runtime/services.js";
+import { requestReads } from "./runtime/request-scope.js";
+import { storageGet, storageGetMany, storageSet } from "./runtime/storage.js";
+import { connectorHealthKeys } from "./storage/keys.js";
+/** How long the operator page shows a stored status before only a live read will do. */
+const STATUS_OBSERVATION_TTL_MS = 120_000;
+const STATUS_STATES = new Set([
+    "ok",
+    "per_caller",
+    "auth_required",
+    "credential_required",
+    "error",
+]);
+const STATUS_PROBLEMS = new Set([
+    "connector_unavailable",
+    "connector_timeout",
+    "oauth_required",
+    "credential_required",
+    "auth_required",
+    "caller_refused",
+    "credential_mismatch",
+    "catalog_failed",
+]);
+/**
+ * This viewer's current observation of one connector, and the slot a live
+ * read writes its own to when there is none. A record from another generation, past its TTL or
+ * of an unknown shape is absent. A storage failure is absent too.
+ */
+export function readStatusObservation(registry, id, baseUrl, requestScope) {
+    return Effect.gen(function* () {
+        const address = yield* healthAddress(registry, id, baseUrl, requestScope);
+        if (!address)
+            return {};
+        const key = connectorHealthKeys.status(id, address.digest);
+        const values = yield* storageGetMany([key, address.generationKey]).pipe(Effect.provideService(Storage, address.storage), Effect.catchCause((cause) => Effect.sync(() => {
+            logFailure(address.logger, "discovery health read failed", failureRecord({}, causeError(cause)));
+            return undefined;
+        })));
+        if (!values)
+            return {};
+        const slot = { storage: address.storage, key, logger: address.logger, generation: values[1] ?? null };
+        try {
+            const value = JSON.parse(values[0] ?? "null");
+            if (value?.v === 1 &&
+                value.generation === slot.generation &&
+                typeof value.state === "string" &&
+                STATUS_STATES.has(value.state) &&
+                (value.problem === undefined || STATUS_PROBLEMS.has(value.problem)) &&
+                Number.isSafeInteger(value.toolCount) &&
+                value.toolCount >= 0 &&
+                Number.isFinite(value.observedAt) &&
+                Date.now() - value.observedAt < STATUS_OBSERVATION_TTL_MS)
+                return {
+                    slot,
+                    observation: {
+                        state: value.state,
+                        ...(value.problem ? { problem: value.problem } : {}),
+                        toolCount: value.toolCount,
+                        observedAt: value.observedAt,
+                    },
+                };
+        }
+        catch {
+            /* An unreadable record is absent. */
+        }
+        return { slot };
+    });
+}
+/**
+ * Where a live read will record its observation, without reading the stored
+ * one. The generation is read through the request's read memo: a live read's
+ * catalog listing locates its cache entry by that same key, so the listing
+ * reuses this read instead of paying another round trip. A generation is never
+ * reused once replaced, so a memoized value can only lapse an observation
+ * early, never keep one past an invalidation that preceded this request.
+ */
+export function prepareStatusSlot(registry, id, baseUrl, requestScope) {
+    return Effect.gen(function* () {
+        const address = yield* healthAddress(registry, id, baseUrl, requestScope);
+        if (!address)
+            return undefined;
+        const generation = yield* requestReads(requestScope)
+            .read(address.storage, address.generationKey, storageGet(address.generationKey))
+            .pipe(Effect.provideService(Storage, address.storage), Effect.catchCause((cause) => Effect.sync(() => {
+            logFailure(address.logger, "discovery health read failed", failureRecord({}, causeError(cause)));
+            return undefined;
+        })));
+        if (generation === undefined)
+            return undefined;
+        return {
+            storage: address.storage,
+            key: connectorHealthKeys.status(id, address.digest),
+            logger: address.logger,
+            generation,
+        };
+    });
+}
+/** Record what a live read saw. A failed write is logged; the page already has its answer. */
+export function storeStatusObservation(slot, observation) {
+    return storageSet(slot.key, JSON.stringify({ v: 1, ...observation, generation: slot.generation }), {
+        expiresAtMs: Math.ceil(observation.observedAt + STATUS_OBSERVATION_TTL_MS),
+    }).pipe(Effect.provideService(Storage, slot.storage), Effect.catchCause((cause) => Effect.sync(() => logFailure(slot.logger, "discovery health write failed", failureRecord({}, causeError(cause))))));
+}

package/dist/connectors/api-connector.d.ts

@@ -204,8 +204,8 @@ export declare const API_OPTIONS: import("../config-schema.js").Field<unknown, u
         credential: import("../config-schema.js").Field<unknown, unknown, true> & {
             readonly shape: {
                 fields: import("../config-schema.js").Field<unknown[], readonly unknown[] | undefined, true>;
-                label: import("../config-schema.js").Field<unknown, unknown, true>;
                 description: import("../config-schema.js").Field<unknown, unknown, true>;
+                label: import("../config-schema.js").Field<unknown, unknown, true>;
                 placeholder: import("../config-schema.js").Field<unknown, unknown, true>;
             };
         };
@@ -228,9 +228,9 @@ export declare const API_OPTIONS: import("../config-schema.js").Field<unknown, u
         };
         tools: import("../config-schema.js").Field<unknown[], readonly unknown[] | undefined, true>;
         title: import("../config-schema.js").Field<unknown, unknown, true>;
+        description: import("../config-schema.js").Field<unknown, unknown, true>;
         authScope: import("../config-schema.js").Field<unknown, unknown, true>;
         maxResultBytes: import("../config-schema.js").Field<unknown, unknown, true>;
-        description: import("../config-schema.js").Field<unknown, unknown, true>;
         testCredential: import("../config-schema.js").Field<unknown, unknown, true>;
         testCredentials: import("../config-schema.js").Field<unknown, unknown, true>;
         validateArgs: import("../config-schema.js").Field<unknown, unknown, true>;
@@ -244,6 +244,11 @@ export declare const API_OPTIONS: import("../config-schema.js").Field<unknown, u
  */
 export interface ApiOAuthHooks {
     status(ctx: ConnectorContext): Promise<ConnectorStatus>;
+    /**
+     * `status` for a call about to enter a handler, which also renews a token
+     * within a minute of its stored expiry. A failed renewal rejects.
+     */
+    prepareCall(ctx: ConnectorContext): Promise<ConnectorStatus>;
     startAuth(ctx: ConnectorContext, opts?: {
         force?: boolean;
     }): Promise<ConnectorStatus>;

package/dist/connectors/api-connector.js

@@ -1,3 +1,4 @@
+import { declaresRouteDescriptions, routePhrases } from "../agent-routes.js";
 import { wrapViewCredentials } from "../runtime/call.js";
 import { storedAuthObservation, withStoredAuth } from "../auth/stored-observation.js";
 import { Effect, Exit } from "effect";
@@ -296,13 +297,15 @@ export function apiConnector(id, opts, oauth) {
     // This boundary's identity in a logical call, fixed now: this object with
     // this function, never whatever the property or a copy holds by then.
     providerBoundary(connector);
+    // Its catalog is authored here, so declared route descriptions follow each request's surface.
+    declaresRouteDescriptions(connector);
     registerCallEntry(connector, core);
     if (oauth)
         registerInvocationAuth(connector, async (ctx) => {
-            // The built-in static OAuth status only reads the stored grant. It never
-            // refreshes, invokes a handler, or sends a downstream request.
-            if ((await settleOnClose(ctx, () => oauth.status(ctx))).state === "auth_required") {
-                throw new ConnectorCallError("downstream_oauth_required", `Connector "${id}" requires authorization. Call authorize_connector.`);
+            // The stored grant, as status reads it. Only a token about to expire is
+            // renewed, before any handler runs; nothing is sent to the API.
+            if ((await settleOnClose(ctx, () => oauth.prepareCall(ctx))).state === "auth_required") {
+                throw new ConnectorCallError("downstream_oauth_required", `Connector "${id}" requires authorization. ${routePhrases(ctx).authorizeCall()}`);
             }
         });
     registerConnectorVocabulary(connector, opts.tools);

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 };
+}