@tangle-network/agent-integrations 0.25.7 → 0.27.0

package/dist/{chunk-A5I3EYU5.js → chunk-ICSBYCE2.js}

@@ -1199,6 +1199,125 @@ function secretKey(ref) {
   return `${ref.provider}:${ref.id}`;
 }
 
+// src/discovery.ts
+async function discoverWorkspaceCapabilities(input) {
+  const connections = await resolveConnections(input);
+  const connectors = await resolveConnectors(input);
+  const activeConnectionsByConnector = /* @__PURE__ */ new Map();
+  for (const conn of connections) {
+    if (conn.status !== "active") continue;
+    if (!activeConnectionsByConnector.has(conn.connectorId)) {
+      activeConnectionsByConnector.set(conn.connectorId, conn);
+    }
+  }
+  const capabilities = [];
+  const triggers = [];
+  const countsByConnector = {};
+  const unreachableConnectors = [];
+  for (const connector of connectors) {
+    const connection = activeConnectionsByConnector.get(connector.id);
+    const connected = Boolean(connection);
+    if (!connected && !input.includeUnconnected) continue;
+    const grantedScopes = new Set(connection?.grantedScopes ?? []);
+    let actionsAdded = 0;
+    for (const action of connector.actions) {
+      const missing2 = action.requiredScopes.filter((scope) => !grantedScopes.has(scope));
+      if (connected && missing2.length > 0 && !input.includeMissingScopes) continue;
+      capabilities.push(toCapability(connector, action, connection));
+      actionsAdded += 1;
+    }
+    for (const trigger2 of connector.triggers ?? []) {
+      const missing2 = trigger2.requiredScopes.filter((scope) => !grantedScopes.has(scope));
+      if (connected && missing2.length > 0 && !input.includeMissingScopes) continue;
+      triggers.push(toTrigger2(connector, trigger2, connection));
+    }
+    countsByConnector[connector.id] = actionsAdded;
+    if (connected && actionsAdded === 0 && connector.actions.length > 0) {
+      unreachableConnectors.push({
+        connectorId: connector.id,
+        reason: "all_actions_missing_scope"
+      });
+    }
+  }
+  return { capabilities, triggers, countsByConnector, unreachableConnectors };
+}
+async function resolveConnections(input) {
+  if (input.connections) return input.connections;
+  if (input.store) return await input.store.listByOwner(input.owner);
+  throw new Error("discoverWorkspaceCapabilities: provide either connections or store");
+}
+async function resolveConnectors(input) {
+  if (input.connectors) return input.connectors;
+  if (input.providers) {
+    const lists = await Promise.all(input.providers.map((p) => Promise.resolve(p.listConnectors())));
+    return lists.flat();
+  }
+  throw new Error("discoverWorkspaceCapabilities: provide either connectors or providers");
+}
+function toCapability(connector, action, connection) {
+  return {
+    id: `${connector.id}.${action.id}`,
+    title: action.title,
+    description: action.description,
+    category: connector.category,
+    connectorId: connector.id,
+    providerId: connector.providerId,
+    actionId: action.id,
+    scopes: action.requiredScopes,
+    risk: action.risk,
+    dataClass: action.dataClass,
+    toolSchema: {
+      name: `${connector.id}.${action.id}`,
+      description: action.description,
+      inputSchema: action.inputSchema,
+      outputSchema: action.outputSchema
+    },
+    connected: Boolean(connection),
+    connectionId: connection?.id,
+    approvalRequired: action.approvalRequired
+  };
+}
+function toTrigger2(connector, trigger2, connection) {
+  return {
+    id: `${connector.id}.${trigger2.id}`,
+    title: trigger2.title,
+    description: trigger2.description,
+    category: connector.category,
+    connectorId: connector.id,
+    providerId: connector.providerId,
+    triggerId: trigger2.id,
+    scopes: trigger2.requiredScopes,
+    dataClass: trigger2.dataClass,
+    connected: Boolean(connection),
+    connectionId: connection?.id
+  };
+}
+function filterDiscoveryByWorkspaceScopes(discovery, workspaceScopes, opts = {}) {
+  if (workspaceScopes.length === 0 && !opts.denyByDefault) return discovery;
+  const granted = new Set(workspaceScopes);
+  const hasWildcard = granted.has("tangle:*");
+  function allowed(connectorId, scopes) {
+    if (hasWildcard) return true;
+    if (granted.has(`${connectorId}:*`)) return true;
+    for (const scope of scopes) {
+      if (!granted.has(scope)) return false;
+    }
+    return true;
+  }
+  const capabilities = discovery.capabilities.filter((cap) => allowed(cap.connectorId, cap.scopes));
+  const triggers = discovery.triggers.filter((t) => allowed(t.connectorId, t.scopes));
+  const countsByConnector = {};
+  for (const cap of capabilities) {
+    countsByConnector[cap.connectorId] = (countsByConnector[cap.connectorId] ?? 0) + 1;
+  }
+  return {
+    capabilities,
+    triggers,
+    countsByConnector,
+    unreachableConnectors: discovery.unreachableConnectors
+  };
+}
+
 // src/events.ts
 var InMemoryIntegrationEventStore = class {
   events = /* @__PURE__ */ new Map();
@@ -4373,6 +4492,8 @@ export {
   resolveConnectionCredentials,
   createCredentialBackedAdapterProvider,
   revokeConnection,
+  discoverWorkspaceCapabilities,
+  filterDiscoveryByWorkspaceScopes,
   InMemoryIntegrationEventStore,
   receiveIntegrationWebhook,
   storedEventToTriggerEvent,
@@ -4431,4 +4552,4 @@ export {
   signCapability,
   verifyCapabilityToken
 };
-//# sourceMappingURL=chunk-A5I3EYU5.js.map
+//# sourceMappingURL=chunk-ICSBYCE2.js.map