@mastra/server 1.38.0-alpha.3 → 1.38.0-alpha.4

package/dist/chunk-DEYP5MF7.cjs

@@ -0,0 +1,605 @@
+'use strict';
+
+var chunkVX3MJR4P_cjs = require('./chunk-VX3MJR4P.cjs');
+var chunk6FHJAHQJ_cjs = require('./chunk-6FHJAHQJ.cjs');
+var chunkSTZTV4FB_cjs = require('./chunk-STZTV4FB.cjs');
+var chunkRZR7PLFW_cjs = require('./chunk-RZR7PLFW.cjs');
+var chunk64ITUOXI_cjs = require('./chunk-64ITUOXI.cjs');
+var chunk65T6KVYX_cjs = require('./chunk-65T6KVYX.cjs');
+var requestContext = require('@mastra/core/request-context');
+
+var TOOL_PROVIDERS_RESOURCE = "tool-providers";
+var SHARED_BUCKET_ID = "shared";
+var _toolProviderModule;
+async function loadToolProviderModule() {
+  if (!_toolProviderModule) {
+    _toolProviderModule = await import('@mastra/core/tool-provider');
+  }
+  return _toolProviderModule;
+}
+function requireEditor(editor) {
+  if (!editor) {
+    throw new chunk64ITUOXI_cjs.HTTPException(500, { message: "Editor is not configured" });
+  }
+  return editor;
+}
+async function resolveProvider(editor, providerId) {
+  try {
+    return editor.getToolProviderOrThrow(providerId);
+  } catch (error) {
+    const { UnknownToolProviderError } = await loadToolProviderModule();
+    if (error instanceof UnknownToolProviderError) {
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: error.message });
+    }
+    throw error;
+  }
+}
+var defaultBucketWarned = false;
+function warnDefaultBucketFallback(logger) {
+  if (defaultBucketWarned) return;
+  defaultBucketWarned = true;
+  logger?.warn(
+    '[tool-providers] caller-supplied scope falling back to shared "default" bucket \u2014 wire mapUserToResourceId or set MASTRA_USER_KEY to avoid cross-tenant OAuth sharing'
+  );
+}
+function resolveOwnerId(requestContext$1, logger) {
+  const resourceId = requestContext$1?.get(requestContext.MASTRA_RESOURCE_ID_KEY);
+  if (typeof resourceId === "string" && resourceId.length > 0) {
+    return resourceId;
+  }
+  const user = requestContext$1?.get(chunk65T6KVYX_cjs.MASTRA_USER_KEY);
+  if (user && typeof user === "object" && "id" in user) {
+    const id = user.id;
+    if (typeof id === "string" && id.length > 0) {
+      return id;
+    }
+  }
+  warnDefaultBucketFallback(logger);
+  return "default";
+}
+var LIST_TOOL_PROVIDERS_ROUTE = chunkRZR7PLFW_cjs.createRoute({
+  method: "GET",
+  path: "/tool-providers",
+  responseType: "json",
+  responseSchema: chunk6FHJAHQJ_cjs.listToolProvidersResponseSchema,
+  summary: "List tool providers",
+  description: "Returns a list of all registered tool providers with their info and capabilities",
+  tags: ["Tool Providers"],
+  requiresAuth: true,
+  handler: async ({ mastra }) => {
+    try {
+      const editor = requireEditor(mastra.getEditor());
+      const providers = editor.getToolProviders();
+      return {
+        providers: Object.values(providers).map((provider) => ({
+          ...provider.info,
+          ...provider.displayName ? { displayName: provider.displayName } : {},
+          ...provider.capabilities ? { capabilities: provider.capabilities } : {}
+        }))
+      };
+    } catch (error) {
+      return chunkSTZTV4FB_cjs.handleError(error, "Error listing tool providers");
+    }
+  }
+});
+var LIST_TOOL_PROVIDER_TOOLKITS_ROUTE = chunkRZR7PLFW_cjs.createRoute({
+  method: "GET",
+  path: "/tool-providers/:providerId/toolkits",
+  responseType: "json",
+  pathParamSchema: chunk6FHJAHQJ_cjs.toolProviderIdPathParams,
+  responseSchema: chunk6FHJAHQJ_cjs.listToolProviderToolkitsResponseSchema,
+  summary: "List tool provider toolkits",
+  description: "Returns the toolkits available from a specific tool provider",
+  tags: ["Tool Providers"],
+  requiresAuth: true,
+  handler: async ({ mastra, providerId }) => {
+    try {
+      const editor = requireEditor(mastra.getEditor());
+      const provider = await resolveProvider(editor, providerId);
+      if (provider.listToolkitsVNext) {
+        return await provider.listToolkitsVNext();
+      }
+      if (provider.listToolkits) {
+        return await provider.listToolkits();
+      }
+      return { data: [] };
+    } catch (error) {
+      return chunkSTZTV4FB_cjs.handleError(error, "Error listing tool provider toolkits");
+    }
+  }
+});
+var LIST_TOOL_PROVIDER_TOOLS_ROUTE = chunkRZR7PLFW_cjs.createRoute({
+  method: "GET",
+  path: "/tool-providers/:providerId/tools",
+  responseType: "json",
+  pathParamSchema: chunk6FHJAHQJ_cjs.toolProviderIdPathParams,
+  queryParamSchema: chunk6FHJAHQJ_cjs.listToolProviderToolsQuerySchema,
+  responseSchema: chunk6FHJAHQJ_cjs.listToolProviderToolsResponseSchema,
+  summary: "List tool provider tools",
+  description: "Returns the tools available from a specific tool provider, with optional filtering",
+  tags: ["Tool Providers"],
+  requiresAuth: true,
+  handler: async ({ mastra, providerId, toolkit, search, page, perPage }) => {
+    try {
+      const editor = requireEditor(mastra.getEditor());
+      const provider = await resolveProvider(editor, providerId);
+      const opts = {};
+      if (toolkit !== void 0) opts.toolkit = toolkit;
+      if (search !== void 0) opts.search = search;
+      if (page !== void 0) opts.page = page;
+      if (perPage !== void 0) opts.perPage = perPage;
+      if (provider.listToolsVNext) {
+        return await provider.listToolsVNext(Object.keys(opts).length > 0 ? opts : void 0);
+      }
+      return await provider.listTools(Object.keys(opts).length > 0 ? opts : void 0);
+    } catch (error) {
+      return chunkSTZTV4FB_cjs.handleError(error, "Error listing tool provider tools");
+    }
+  }
+});
+var GET_TOOL_PROVIDER_TOOL_SCHEMA_ROUTE = chunkRZR7PLFW_cjs.createRoute({
+  method: "GET",
+  path: "/tool-providers/:providerId/tools/:toolSlug/schema",
+  responseType: "json",
+  pathParamSchema: chunk6FHJAHQJ_cjs.toolSlugPathParams,
+  responseSchema: chunk6FHJAHQJ_cjs.getToolProviderToolSchemaResponseSchema,
+  summary: "Get tool provider tool schema",
+  description: "Returns the schema for a specific tool from a tool provider",
+  tags: ["Tool Providers"],
+  requiresAuth: true,
+  handler: async ({ mastra, providerId, toolSlug }) => {
+    try {
+      const editor = requireEditor(mastra.getEditor());
+      const provider = await resolveProvider(editor, providerId);
+      if (!provider.getToolSchema) {
+        throw new chunk64ITUOXI_cjs.HTTPException(404, { message: `Tool provider ${providerId} does not support getToolSchema` });
+      }
+      const schema = await provider.getToolSchema(toolSlug);
+      if (!schema) {
+        throw new chunk64ITUOXI_cjs.HTTPException(404, { message: `Schema for tool ${toolSlug} not found in provider ${providerId}` });
+      }
+      return schema;
+    } catch (error) {
+      return chunkSTZTV4FB_cjs.handleError(error, "Error getting tool provider tool schema");
+    }
+  }
+});
+var AUTHORIZE_TOOL_PROVIDER_ROUTE = chunkRZR7PLFW_cjs.createRoute({
+  method: "POST",
+  path: "/tool-providers/:providerId/authorize",
+  responseType: "json",
+  pathParamSchema: chunk6FHJAHQJ_cjs.toolProviderIdPathParams,
+  bodySchema: chunk6FHJAHQJ_cjs.authorizeToolProviderBodySchema,
+  responseSchema: chunk6FHJAHQJ_cjs.authorizeToolProviderResponseSchema,
+  summary: "Authorize tool provider connection",
+  description: "Starts an OAuth flow and returns a redirect URL + opaque auth handle",
+  tags: ["Tool Providers"],
+  requiresAuth: true,
+  handler: async ({ mastra, providerId, toolkit, connectionId, toolName, config, label, scope, requestContext: requestContext$1 }) => {
+    try {
+      const editor = requireEditor(mastra.getEditor());
+      const provider = await resolveProvider(editor, providerId);
+      if (!provider.authorize) {
+        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: `Tool provider ${providerId} does not support authorize` });
+      }
+      const effectiveScope = scope === "shared" || scope === "caller-supplied" ? scope : "per-author";
+      const callerResourceId = requestContext$1?.get(requestContext.MASTRA_RESOURCE_ID_KEY);
+      if (effectiveScope === "caller-supplied") {
+        if (typeof callerResourceId !== "string" || callerResourceId.length === 0) {
+          throw new chunk64ITUOXI_cjs.HTTPException(400, {
+            message: `Cannot authorize caller-supplied connection: request context has no '${requestContext.MASTRA_RESOURCE_ID_KEY}'. Set requestContext.set('${requestContext.MASTRA_RESOURCE_ID_KEY}', <userId>) before calling /authorize.`
+          });
+        }
+      }
+      const callerAuthorId = resolveOwnerId(requestContext$1, mastra.getLogger());
+      const ownerAuthorId = effectiveScope === "shared" ? SHARED_BUCKET_ID : effectiveScope === "caller-supplied" ? callerResourceId : callerAuthorId;
+      const bucket = connectionId && connectionId.length > 0 ? connectionId : ownerAuthorId;
+      const result = await provider.authorize({ toolkit, connectionId: bucket, toolName, config });
+      const persistedConnectionId = connectionId && connectionId.length > 0 ? connectionId : result.authId;
+      try {
+        const storage = mastra.getStorage();
+        const store = await storage?.getStore("toolProviderConnections");
+        if (store && persistedConnectionId) {
+          await store.upsertConnection({
+            authorId: ownerAuthorId,
+            providerId: provider.info.id,
+            toolkit,
+            connectionId: persistedConnectionId,
+            label: typeof label === "string" && label.length > 0 ? label : null,
+            scope: effectiveScope
+          });
+        }
+      } catch (upsertError) {
+        mastra.getLogger?.()?.warn?.("[tool-providers] failed to upsert tool_provider_connections label", {
+          error: upsertError instanceof Error ? upsertError.message : String(upsertError),
+          providerId,
+          toolkit,
+          connectionId: persistedConnectionId
+        });
+      }
+      return result;
+    } catch (error) {
+      return chunkSTZTV4FB_cjs.handleError(error, "Error authorizing tool provider");
+    }
+  }
+});
+var GET_TOOL_PROVIDER_AUTH_STATUS_ROUTE = chunkRZR7PLFW_cjs.createRoute({
+  method: "GET",
+  path: "/tool-providers/:providerId/auth-status/:authId",
+  responseType: "json",
+  pathParamSchema: chunk6FHJAHQJ_cjs.toolProviderAuthStatusPathParams,
+  responseSchema: chunk6FHJAHQJ_cjs.authStatusToolProviderResponseSchema,
+  summary: "Get tool provider auth status",
+  description: "Polls the OAuth flow status for an outstanding authorize call",
+  tags: ["Tool Providers"],
+  requiresAuth: true,
+  handler: async ({ mastra, providerId, authId }) => {
+    try {
+      const editor = requireEditor(mastra.getEditor());
+      const provider = await resolveProvider(editor, providerId);
+      if (!provider.getAuthStatus) {
+        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: `Tool provider ${providerId} does not support getAuthStatus` });
+      }
+      const status = await provider.getAuthStatus(authId);
+      return { status };
+    } catch (error) {
+      return chunkSTZTV4FB_cjs.handleError(error, "Error getting tool provider auth status");
+    }
+  }
+});
+var TOOL_PROVIDER_CONNECTION_STATUS_ROUTE = chunkRZR7PLFW_cjs.createRoute({
+  method: "POST",
+  path: "/tool-providers/:providerId/connection-status",
+  responseType: "json",
+  pathParamSchema: chunk6FHJAHQJ_cjs.toolProviderIdPathParams,
+  bodySchema: chunk6FHJAHQJ_cjs.connectionStatusToolProviderBodySchema,
+  responseSchema: chunk6FHJAHQJ_cjs.connectionStatusToolProviderResponseSchema,
+  summary: "Get connection status for a provider",
+  description: "Batch-checks whether a set of (connectionId, toolkit) tuples are still connected",
+  tags: ["Tool Providers"],
+  requiresAuth: true,
+  handler: async ({ mastra, providerId, items }) => {
+    try {
+      const editor = requireEditor(mastra.getEditor());
+      const provider = await resolveProvider(editor, providerId);
+      if (!provider.getConnectionStatus) {
+        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: `Tool provider ${providerId} does not support getConnectionStatus` });
+      }
+      const result = await provider.getConnectionStatus({ items });
+      return { items: result };
+    } catch (error) {
+      return chunkSTZTV4FB_cjs.handleError(error, "Error getting connection status");
+    }
+  }
+});
+var LIST_TOOL_PROVIDER_CONNECTIONS_ROUTE = chunkRZR7PLFW_cjs.createRoute({
+  method: "GET",
+  path: "/tool-providers/:providerId/connections",
+  responseType: "json",
+  pathParamSchema: chunk6FHJAHQJ_cjs.toolProviderIdPathParams,
+  queryParamSchema: chunk6FHJAHQJ_cjs.listConnectionsQuerySchema,
+  responseSchema: chunk6FHJAHQJ_cjs.listConnectionsResponseSchema,
+  summary: "List existing connections",
+  description: "Returns existing provider connections on a toolkit, so the picker can offer them for pinning without re-running OAuth",
+  tags: ["Tool Providers"],
+  requiresAuth: true,
+  handler: async ({
+    mastra,
+    providerId,
+    toolkit,
+    authorId: queryAuthorId,
+    scope: queryScope,
+    page,
+    perPage,
+    requestContext
+  }) => {
+    try {
+      const editor = requireEditor(mastra.getEditor());
+      const provider = await resolveProvider(editor, providerId);
+      if (!provider.listConnections) {
+        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: `Tool provider ${providerId} does not support listConnections` });
+      }
+      const callerAuthorId = resolveOwnerId(requestContext, mastra.getLogger());
+      const isAdmin = requestContext ? chunkVX3MJR4P_cjs.hasAdminBypass(requestContext, TOOL_PROVIDERS_RESOURCE) : false;
+      const requestedAuthorId = isAdmin && typeof queryAuthorId === "string" && queryAuthorId.length > 0 ? queryAuthorId : void 0;
+      const effectiveAuthorId = isAdmin ? requestedAuthorId : callerAuthorId;
+      const storage = mastra.getStorage();
+      const store = await storage?.getStore("toolProviderConnections");
+      let labelRows = [];
+      if (store) {
+        try {
+          const rows = await store.listConnectionsByAuthor({
+            providerId: provider.info.id,
+            toolkit
+          });
+          labelRows = rows.map((r) => ({
+            authorId: r.authorId,
+            connectionId: r.connectionId,
+            label: r.label,
+            scope: r.scope ?? "per-author"
+          }));
+        } catch (joinError) {
+          mastra.getLogger?.()?.warn?.("[tool-providers] failed to join tool_provider_connections labels", {
+            error: joinError instanceof Error ? joinError.message : String(joinError),
+            providerId,
+            toolkit
+          });
+        }
+      }
+      const userIdSet = /* @__PURE__ */ new Set();
+      const wantShared = !queryScope || queryScope === "shared";
+      const wantPerAuthor = !queryScope || queryScope === "per-author";
+      const wantCallerSupplied = !queryScope || queryScope === "caller-supplied";
+      const hasSharedRow = labelRows.some((r) => r.scope === "shared");
+      if (isAdmin && effectiveAuthorId === void 0) {
+        for (const r of labelRows) {
+          if (r.scope === "shared" && wantShared) userIdSet.add(r.authorId);
+          if (r.scope === "per-author" && wantPerAuthor) userIdSet.add(r.authorId);
+          if (r.scope === "caller-supplied" && wantCallerSupplied) userIdSet.add(r.authorId);
+        }
+      } else if (isAdmin && effectiveAuthorId) {
+        if (wantPerAuthor || wantCallerSupplied) userIdSet.add(effectiveAuthorId);
+        if (wantShared && hasSharedRow) userIdSet.add(SHARED_BUCKET_ID);
+      } else {
+        if (wantPerAuthor) userIdSet.add(callerAuthorId);
+        if (wantShared && hasSharedRow) userIdSet.add(SHARED_BUCKET_ID);
+      }
+      const userIds = Array.from(userIdSet);
+      if (userIds.length === 0) {
+        return {
+          items: [],
+          pagination: { page: page ?? 1, perPage, hasMore: false }
+        };
+      }
+      const adapterResult = await provider.listConnections({
+        toolkit,
+        userIds,
+        ...typeof page === "number" ? { page } : {},
+        ...typeof perPage === "number" ? { perPage } : {}
+      });
+      const rowByConnId = new Map(labelRows.map((r) => [r.connectionId, r]));
+      const visibleItems = adapterResult.items.filter((item) => {
+        if (!queryScope) return true;
+        const scope = rowByConnId.get(item.connectionId)?.scope ?? "per-author";
+        return scope === queryScope;
+      });
+      return {
+        items: visibleItems.map((item) => {
+          const row = rowByConnId.get(item.connectionId);
+          return {
+            ...item,
+            label: row?.label ?? null,
+            ...row?.scope ? { scope: row.scope } : {}
+          };
+        }),
+        pagination: adapterResult.pagination
+      };
+    } catch (error) {
+      return chunkSTZTV4FB_cjs.handleError(error, "Error listing tool provider connections");
+    }
+  }
+});
+var LIST_TOOL_PROVIDER_CONNECTION_FIELDS_ROUTE = chunkRZR7PLFW_cjs.createRoute({
+  method: "GET",
+  path: "/tool-providers/:providerId/connection-fields",
+  responseType: "json",
+  pathParamSchema: chunk6FHJAHQJ_cjs.toolProviderIdPathParams,
+  queryParamSchema: chunk6FHJAHQJ_cjs.listConnectionFieldsQuerySchema,
+  responseSchema: chunk6FHJAHQJ_cjs.listConnectionFieldsResponseSchema,
+  summary: "List connection field schema",
+  description: "Returns a list of provider-specific fields the UI should collect before initiating an authorize call",
+  tags: ["Tool Providers"],
+  requiresAuth: true,
+  handler: async ({ mastra, providerId, toolkit }) => {
+    try {
+      const editor = requireEditor(mastra.getEditor());
+      const provider = await resolveProvider(editor, providerId);
+      if (!provider.listConnectionFields) {
+        return { fields: [] };
+      }
+      const fields = await provider.listConnectionFields({ toolkit });
+      return { fields };
+    } catch (error) {
+      return chunkSTZTV4FB_cjs.handleError(error, "Error listing tool provider connection fields");
+    }
+  }
+});
+var DISCONNECT_TOOL_PROVIDER_CONNECTION_ROUTE = chunkRZR7PLFW_cjs.createRoute({
+  method: "DELETE",
+  path: "/tool-providers/:providerId/connections/:connectionId",
+  responseType: "json",
+  pathParamSchema: chunk6FHJAHQJ_cjs.toolProviderConnectionPathParams,
+  queryParamSchema: chunk6FHJAHQJ_cjs.disconnectConnectionQuerySchema,
+  responseSchema: chunk6FHJAHQJ_cjs.disconnectConnectionResponseSchema,
+  summary: "Disconnect a connection",
+  description: "Revokes the provider-side connection (if supported) and removes the persisted tool_provider_connections row. Use `?force=true` to bypass usage checks.",
+  tags: ["Tool Providers"],
+  requiresAuth: true,
+  handler: async ({ mastra, providerId, connectionId, force, requestContext }) => {
+    try {
+      const editor = requireEditor(mastra.getEditor());
+      const provider = await resolveProvider(editor, providerId);
+      const callerAuthorId = resolveOwnerId(requestContext, mastra.getLogger());
+      const isAdmin = requestContext ? chunkVX3MJR4P_cjs.hasAdminBypass(requestContext, TOOL_PROVIDERS_RESOURCE) : false;
+      const isForce = force === true || force === "true";
+      const storage = mastra.getStorage();
+      const store = await storage?.getStore("toolProviderConnections");
+      let ownerAuthorId;
+      let ownerScope;
+      let matched = false;
+      if (store) {
+        const rows = await store.listConnectionsByAuthor({ providerId: provider.info.id });
+        const match = rows.find((r) => r.connectionId === connectionId);
+        if (match) {
+          matched = true;
+          ownerAuthorId = match.authorId;
+          ownerScope = match.scope;
+        }
+      }
+      if (store && !matched && !isAdmin) {
+        throw new chunk64ITUOXI_cjs.HTTPException(403, {
+          message: "You do not have permission to disconnect this connection"
+        });
+      }
+      const effectiveOwner = ownerAuthorId ?? callerAuthorId;
+      const isShared = ownerScope === "shared";
+      if (!isShared && effectiveOwner !== callerAuthorId && !isAdmin) {
+        throw new chunk64ITUOXI_cjs.HTTPException(403, {
+          message: "You do not have permission to disconnect this connection"
+        });
+      }
+      if (!isForce) {
+        const usage = await countConnectionUsage(mastra, connectionId);
+        if (usage > 0) {
+          throw new chunk64ITUOXI_cjs.HTTPException(409, {
+            message: `Connection ${connectionId} is still pinned by ${usage} agent(s). Pass ?force=true to disconnect anyway.`
+          });
+        }
+      }
+      let revoked = false;
+      if (provider.capabilities?.supportsRevoke && typeof provider.revokeConnection === "function") {
+        await provider.revokeConnection(connectionId);
+        revoked = true;
+      }
+      if (store) {
+        await store.deleteConnection({
+          authorId: effectiveOwner,
+          providerId: provider.info.id,
+          connectionId
+        });
+      }
+      return { ok: true, revoked };
+    } catch (error) {
+      return chunkSTZTV4FB_cjs.handleError(error, "Error disconnecting tool provider connection");
+    }
+  }
+});
+var GET_TOOL_PROVIDER_CONNECTION_USAGE_ROUTE = chunkRZR7PLFW_cjs.createRoute({
+  method: "GET",
+  path: "/tool-providers/:providerId/connections/:connectionId/usage",
+  responseType: "json",
+  pathParamSchema: chunk6FHJAHQJ_cjs.toolProviderConnectionPathParams,
+  queryParamSchema: chunk6FHJAHQJ_cjs.connectionUsageQuerySchema,
+  responseSchema: chunk6FHJAHQJ_cjs.connectionUsageResponseSchema,
+  summary: "List agents using a connection",
+  description: "Returns the agents that pin this connection in their toolProviders config",
+  tags: ["Tool Providers"],
+  requiresAuth: true,
+  handler: async ({ mastra, providerId, connectionId, toolkit, requestContext }) => {
+    try {
+      const editor = requireEditor(mastra.getEditor());
+      const provider = await resolveProvider(editor, providerId);
+      const callerAuthorId = resolveOwnerId(requestContext, mastra.getLogger());
+      const isAdmin = requestContext ? chunkVX3MJR4P_cjs.hasAdminBypass(requestContext, TOOL_PROVIDERS_RESOURCE) : false;
+      const storage = mastra.getStorage();
+      const store = await storage?.getStore("toolProviderConnections");
+      let ownerAuthorId;
+      let ownerScope;
+      let matched = false;
+      if (store) {
+        const rows = await store.listConnectionsByAuthor({ providerId: provider.info.id });
+        const match = rows.find((r) => r.connectionId === connectionId);
+        if (match) {
+          matched = true;
+          ownerAuthorId = match.authorId;
+          ownerScope = match.scope;
+        }
+      }
+      if (store && !matched && !isAdmin) {
+        throw new chunk64ITUOXI_cjs.HTTPException(403, {
+          message: "You do not have permission to view usage for this connection"
+        });
+      }
+      const effectiveOwner = ownerAuthorId ?? callerAuthorId;
+      const isShared = ownerScope === "shared";
+      if (!isShared && effectiveOwner !== callerAuthorId && !isAdmin) {
+        throw new chunk64ITUOXI_cjs.HTTPException(403, {
+          message: "You do not have permission to view usage for this connection"
+        });
+      }
+      const agents = await scanConnectionUsage(mastra, { providerId: provider.info.id, connectionId, toolkit });
+      return { agents };
+    } catch (error) {
+      return chunkSTZTV4FB_cjs.handleError(error, "Error listing tool provider connection usage");
+    }
+  }
+});
+var GET_TOOL_PROVIDER_HEALTH_ROUTE = chunkRZR7PLFW_cjs.createRoute({
+  method: "GET",
+  path: "/tool-providers/:providerId/health",
+  responseType: "json",
+  pathParamSchema: chunk6FHJAHQJ_cjs.toolProviderIdPathParams,
+  responseSchema: chunk6FHJAHQJ_cjs.toolProviderHealthResponseSchema,
+  summary: "Get tool provider health",
+  description: "Returns provider-level health (config, reachability, etc.)",
+  tags: ["Tool Providers"],
+  requiresAuth: true,
+  handler: async ({ mastra, providerId }) => {
+    try {
+      const editor = requireEditor(mastra.getEditor());
+      const provider = await resolveProvider(editor, providerId);
+      if (!provider.getHealth) {
+        return { ok: true };
+      }
+      return await provider.getHealth();
+    } catch (error) {
+      return chunkSTZTV4FB_cjs.handleError(error, "Error getting tool provider health");
+    }
+  }
+});
+async function scanConnectionUsage(mastra, args) {
+  const storage = mastra.getStorage();
+  const agentsStore = await storage?.getStore("agents");
+  if (!agentsStore) return [];
+  const { agents } = await agentsStore.listResolved({ perPage: false });
+  const out = [];
+  for (const agent of agents) {
+    const config = agent?.toolProviders?.[args.providerId];
+    if (!config?.connections) continue;
+    for (const [toolkit, connections] of Object.entries(config.connections)) {
+      if (args.toolkit && toolkit !== args.toolkit) continue;
+      const match = connections.some((c) => c.connectionId === args.connectionId);
+      if (match) {
+        out.push({ id: agent.id, name: agent.name ?? agent.id });
+        break;
+      }
+    }
+  }
+  return out;
+}
+async function countConnectionUsage(mastra, connectionId) {
+  const storage = mastra.getStorage();
+  const agentsStore = await storage?.getStore("agents");
+  if (!agentsStore) return 0;
+  const { agents } = await agentsStore.listResolved({ perPage: false });
+  let count = 0;
+  for (const agent of agents) {
+    const tp = agent?.toolProviders;
+    if (!tp) continue;
+    for (const config of Object.values(tp)) {
+      const pinned = Object.values(config?.connections ?? {}).some(
+        (arr) => arr.some((c) => c.connectionId === connectionId)
+      );
+      if (pinned) {
+        count += 1;
+        break;
+      }
+    }
+  }
+  return count;
+}
+
+exports.AUTHORIZE_TOOL_PROVIDER_ROUTE = AUTHORIZE_TOOL_PROVIDER_ROUTE;
+exports.DISCONNECT_TOOL_PROVIDER_CONNECTION_ROUTE = DISCONNECT_TOOL_PROVIDER_CONNECTION_ROUTE;
+exports.GET_TOOL_PROVIDER_AUTH_STATUS_ROUTE = GET_TOOL_PROVIDER_AUTH_STATUS_ROUTE;
+exports.GET_TOOL_PROVIDER_CONNECTION_USAGE_ROUTE = GET_TOOL_PROVIDER_CONNECTION_USAGE_ROUTE;
+exports.GET_TOOL_PROVIDER_HEALTH_ROUTE = GET_TOOL_PROVIDER_HEALTH_ROUTE;
+exports.GET_TOOL_PROVIDER_TOOL_SCHEMA_ROUTE = GET_TOOL_PROVIDER_TOOL_SCHEMA_ROUTE;
+exports.LIST_TOOL_PROVIDERS_ROUTE = LIST_TOOL_PROVIDERS_ROUTE;
+exports.LIST_TOOL_PROVIDER_CONNECTIONS_ROUTE = LIST_TOOL_PROVIDER_CONNECTIONS_ROUTE;
+exports.LIST_TOOL_PROVIDER_CONNECTION_FIELDS_ROUTE = LIST_TOOL_PROVIDER_CONNECTION_FIELDS_ROUTE;
+exports.LIST_TOOL_PROVIDER_TOOLKITS_ROUTE = LIST_TOOL_PROVIDER_TOOLKITS_ROUTE;
+exports.LIST_TOOL_PROVIDER_TOOLS_ROUTE = LIST_TOOL_PROVIDER_TOOLS_ROUTE;
+exports.TOOL_PROVIDER_CONNECTION_STATUS_ROUTE = TOOL_PROVIDER_CONNECTION_STATUS_ROUTE;
+//# sourceMappingURL=chunk-DEYP5MF7.cjs.map
+//# sourceMappingURL=chunk-DEYP5MF7.cjs.map