@illuma-ai/agents 1.4.0-alpha.0 → 1.4.0-alpha.2

package/src/providers/composite/CompositeCapabilityProvider.ts

@@ -1,112 +0,0 @@
-/**
- * CompositeCapabilityProvider — fans out to multiple CapabilityProviders
- * and merges their manifests + runnables into one.
- *
- * Use case: an agent that consumes tools from tools-server AND MCP servers
- * AND (future) skills. The composite exposes a single CapabilityProvider
- * interface to the agent runtime so it doesn't know or care how many
- * backing sources exist.
- *
- * Precedence: later providers do NOT override earlier ones on name
- * collision — collisions are logged and the first-registered capability
- * wins. Callers should ensure providers expose disjoint name spaces.
- */
-
-import type { StructuredToolInterface } from '@langchain/core/tools';
-import type {
-  Capability,
-  CapabilityFilter,
-  CapabilityProvider,
-  CredentialMap,
-} from '@/providers/types';
-
-export class CompositeCapabilityProvider implements CapabilityProvider {
-  readonly providerId: string;
-  private readonly providers: CapabilityProvider[];
-
-  constructor(providers: CapabilityProvider[]) {
-    if (!providers.length) {
-      throw new Error(
-        'CompositeCapabilityProvider: at least one provider is required'
-      );
-    }
-    this.providers = providers;
-    this.providerId = `composite:${providers.map((p) => p.providerId).join(',')}`;
-  }
-
-  async fetchManifest(filter?: CapabilityFilter): Promise<Capability[]> {
-    // Fetch all providers in parallel. One provider failing should not
-    // prevent others from contributing — log and continue.
-    const results = await Promise.allSettled(
-      this.providers.map((p) => p.fetchManifest(filter))
-    );
-
-    const merged: Capability[] = [];
-    const seen = new Set<string>();
-
-    for (let i = 0; i < results.length; i++) {
-      const result = results[i];
-      const provider = this.providers[i];
-
-      if (result.status === 'rejected') {
-        // DEBUG
-        // eslint-disable-next-line no-console
-        console.debug(
-          `[composite] provider ${provider.providerId} fetchManifest failed — ${String(result.reason)}`
-        );
-        continue;
-      }
-
-      for (const cap of result.value) {
-        if (seen.has(cap.name)) {
-          // DEBUG
-          // eslint-disable-next-line no-console
-          console.debug(
-            `[composite] name collision on "${cap.name}" from ${provider.providerId} — keeping first`
-          );
-          continue;
-        }
-        seen.add(cap.name);
-        merged.push(cap);
-      }
-    }
-
-    // DEBUG
-    // eslint-disable-next-line no-console
-    console.debug(
-      `[composite] merged manifest: ${merged.length} caps from ${this.providers.length} providers`
-    );
-
-    return merged;
-  }
-
-  async createRunnables(
-    capabilities: Capability[],
-    credentials: CredentialMap
-  ): Promise<StructuredToolInterface[]> {
-    // Determine which capabilities belong to which provider by refetching
-    // each provider's manifest and intersecting with the requested set.
-    // This keeps providers stateless — we don't require Capability to
-    // carry a back-reference to its provider.
-    const capabilityNames = new Set(capabilities.map((c) => c.name));
-    const perProviderCaps = await Promise.all(
-      this.providers.map(async (p) => {
-        const manifest = await p.fetchManifest();
-        return manifest.filter((c) => capabilityNames.has(c.name));
-      })
-    );
-
-    const allRunnables: StructuredToolInterface[] = [];
-    for (let i = 0; i < this.providers.length; i++) {
-      const providerCaps = perProviderCaps[i];
-      if (!providerCaps.length) continue;
-      const runnables = await this.providers[i].createRunnables(
-        providerCaps,
-        credentials
-      );
-      allRunnables.push(...runnables);
-    }
-
-    return allRunnables;
-  }
-}

package/src/providers/composite/index.ts

@@ -1 +0,0 @@
-export * from './CompositeCapabilityProvider';