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

package/dist/cjs/main.cjs

@@ -32,7 +32,6 @@ var proxyTool = require('./tools/proxyTool.cjs');
 var types = require('./providers/types.cjs');
 var capabilityNaming = require('./providers/capabilityNaming.cjs');
 var ToolsServerCapabilityProvider = require('./providers/tools-server/ToolsServerCapabilityProvider.cjs');
-var CompositeCapabilityProvider = require('./providers/composite/CompositeCapabilityProvider.cjs');
 var MCPCapabilityProvider = require('./providers/mcp/MCPCapabilityProvider.cjs');
 var transport = require('./providers/mcp/transport.cjs');
 var config$1 = require('./providers/mcp/config.cjs');
@@ -233,7 +232,6 @@ exports.CAPABILITY_NAME_SEPARATOR = capabilityNaming.CAPABILITY_NAME_SEPARATOR;
 exports.formatCapabilityName = capabilityNaming.formatCapabilityName;
 exports.parseCapabilityName = capabilityNaming.parseCapabilityName;
 exports.ToolsServerCapabilityProvider = ToolsServerCapabilityProvider.ToolsServerCapabilityProvider;
-exports.CompositeCapabilityProvider = CompositeCapabilityProvider.CompositeCapabilityProvider;
 exports.MCPCapabilityProvider = MCPCapabilityProvider.MCPCapabilityProvider;
 exports.flattenToolCallResponse = MCPCapabilityProvider.flattenToolCallResponse;
 exports.createTransport = transport.createTransport;

package/dist/cjs/main.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"main.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"main.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/main.mjs

@@ -30,7 +30,6 @@ export { buildProxyTool } from './tools/proxyTool.mjs';
 export { AuthSource, CapabilityKind } from './providers/types.mjs';
 export { CAPABILITY_NAME_SEPARATOR, formatCapabilityName, parseCapabilityName } from './providers/capabilityNaming.mjs';
 export { ToolsServerCapabilityProvider } from './providers/tools-server/ToolsServerCapabilityProvider.mjs';
-export { CompositeCapabilityProvider } from './providers/composite/CompositeCapabilityProvider.mjs';
 export { MCPCapabilityProvider, flattenToolCallResponse } from './providers/mcp/MCPCapabilityProvider.mjs';
 export { createTransport } from './providers/mcp/transport.mjs';
 export { getMCPEnvDefaults, consoleLogger as mcpConsoleLogger } from './providers/mcp/config.mjs';

package/dist/esm/main.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"main.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"main.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/types/providers/index.d.ts

@@ -6,7 +6,6 @@
 export * from './types';
 export * from './capabilityNaming';
 export * from './tools-server';
-export * from './composite';
 export { MCPCapabilityProvider, flattenToolCallResponse, createTransport, mcpConsoleLogger, getMCPEnvDefaults, } from './mcp';
 export type { MCPLogger, MCPProviderConfig, MCPServerSpec, MCPTransportKind, StdioSpec, SSESpec, StreamableHTTPSpec, WebSocketSpec, MCPToolDescriptor, MCPToolCallResult, MCPStructuredTool, } from './mcp';
 export { A2ACapabilityProvider, A2AClient, extractTaskText, generateRpcId, skillToCapability, coerceInputToA2AMessage, MESSAGE_INPUT_SCHEMA, a2aConsoleLogger, getA2AEnvDefaults, } from './a2a';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@illuma-ai/agents",
-  "version": "1.4.0-alpha.0",
+  "version": "1.4.0-alpha.1",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",
@@ -24,11 +24,6 @@
       "import": "./dist/esm/providers/a2a/A2ACapabilityProvider.mjs",
       "require": "./dist/cjs/providers/a2a/A2ACapabilityProvider.cjs",
       "types": "./dist/types/providers/a2a/A2ACapabilityProvider.d.ts"
-    },
-    "./providers/composite": {
-      "import": "./dist/esm/providers/composite/CompositeCapabilityProvider.mjs",
-      "require": "./dist/cjs/providers/composite/CompositeCapabilityProvider.cjs",
-      "types": "./dist/types/providers/composite/CompositeCapabilityProvider.d.ts"
     }
   },
   "type": "module",

package/src/providers/index.ts

@@ -9,7 +9,10 @@ export * from './types';
 // A2A consumers get the same encoding without re-export duplication.
 export * from './capabilityNaming';
 export * from './tools-server';
-export * from './composite';
+// Hosts compose multiple providers by iterating a plain array and
+// concatenating tools — see docs/capability-providers.md. No wrapper
+// class is provided because the loop is trivial and keeps host code
+// transparent.
 // MCP + A2A barrels intentionally namespaced to avoid re-exporting
 // `CAPABILITY_NAME_SEPARATOR` / `formatCapabilityName` twice (each
 // provider module re-exports them internally; the canonical export

package/dist/cjs/providers/composite/CompositeCapabilityProvider.cjs

@@ -1,80 +0,0 @@
-'use strict';
-
-/**
- * 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.
- */
-class CompositeCapabilityProvider {
-    providerId;
-    providers;
-    constructor(providers) {
-        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) {
-        // 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 = [];
-        const seen = new Set();
-        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, credentials) {
-        // 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 = [];
-        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;
-    }
-}
-
-exports.CompositeCapabilityProvider = CompositeCapabilityProvider;
-//# sourceMappingURL=CompositeCapabilityProvider.cjs.map

package/dist/cjs/providers/composite/CompositeCapabilityProvider.cjs.map

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

package/dist/esm/providers/composite/CompositeCapabilityProvider.mjs

@@ -1,78 +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.
- */
-class CompositeCapabilityProvider {
-    providerId;
-    providers;
-    constructor(providers) {
-        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) {
-        // 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 = [];
-        const seen = new Set();
-        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, credentials) {
-        // 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 = [];
-        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;
-    }
-}
-
-export { CompositeCapabilityProvider };
-//# sourceMappingURL=CompositeCapabilityProvider.mjs.map

package/dist/esm/providers/composite/CompositeCapabilityProvider.mjs.map

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

package/dist/types/providers/composite/CompositeCapabilityProvider.d.ts

@@ -1,22 +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 declare class CompositeCapabilityProvider implements CapabilityProvider {
-    readonly providerId: string;
-    private readonly providers;
-    constructor(providers: CapabilityProvider[]);
-    fetchManifest(filter?: CapabilityFilter): Promise<Capability[]>;
-    createRunnables(capabilities: Capability[], credentials: CredentialMap): Promise<StructuredToolInterface[]>;
-}

package/dist/types/providers/composite/index.d.ts

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

package/src/providers/__tests__/CompositeCapabilityProvider.test.ts

@@ -1,93 +0,0 @@
-import { CompositeCapabilityProvider } from '../composite/CompositeCapabilityProvider';
-import {
-  CapabilityKind,
-  type Capability,
-  type CapabilityProvider,
-  type CredentialMap,
-} from '../types';
-
-const makeCap = (
-  name: string,
-  kind: CapabilityKind = CapabilityKind.TOOL
-): Capability => ({
-  kind,
-  name,
-  description: `${name} cap`,
-  authConfig: [],
-  metadata: {},
-});
-
-class FakeProvider implements CapabilityProvider {
-  readonly providerId: string;
-  manifestCallCount = 0;
-  createCallCount = 0;
-
-  constructor(
-    id: string,
-    private readonly manifest: Capability[],
-    private readonly failOnFetch = false
-  ) {
-    this.providerId = id;
-  }
-  async fetchManifest(): Promise<Capability[]> {
-    this.manifestCallCount++;
-    if (this.failOnFetch) throw new Error('simulated failure');
-    return this.manifest;
-  }
-  async createRunnables(capabilities: Capability[], _creds: CredentialMap) {
-    this.createCallCount++;
-    // Return one fake tool per capability name — we can't import StructuredToolInterface here cleanly,
-    // so cast. The test only checks length + name.
-    return capabilities.map((c) => ({ name: c.name }) as unknown as never);
-  }
-}
-
-describe('CompositeCapabilityProvider', () => {
-  it('throws on empty provider list', () => {
-    expect(() => new CompositeCapabilityProvider([])).toThrow(/at least one/);
-  });
-
-  it('providerId reflects composed providers', () => {
-    const composite = new CompositeCapabilityProvider([
-      new FakeProvider('p1', []),
-      new FakeProvider('p2', []),
-    ]);
-    expect(composite.providerId).toBe('composite:p1,p2');
-  });
-
-  it('merges manifests from all providers', async () => {
-    const p1 = new FakeProvider('p1', [makeCap('a'), makeCap('b')]);
-    const p2 = new FakeProvider('p2', [makeCap('c')]);
-    const composite = new CompositeCapabilityProvider([p1, p2]);
-    const caps = await composite.fetchManifest();
-    expect(caps.map((c) => c.name).sort()).toEqual(['a', 'b', 'c']);
-  });
-
-  it('deduplicates on name collision, first provider wins', async () => {
-    const p1 = new FakeProvider('p1', [makeCap('dup'), makeCap('a')]);
-    const p2 = new FakeProvider('p2', [makeCap('dup'), makeCap('b')]);
-    const composite = new CompositeCapabilityProvider([p1, p2]);
-    const caps = await composite.fetchManifest();
-    expect(caps.map((c) => c.name).sort()).toEqual(['a', 'b', 'dup']);
-  });
-
-  it('continues when one provider fails', async () => {
-    const p1 = new FakeProvider('p1', [], true);
-    const p2 = new FakeProvider('p2', [makeCap('x')]);
-    const composite = new CompositeCapabilityProvider([p1, p2]);
-    const caps = await composite.fetchManifest();
-    expect(caps).toHaveLength(1);
-    expect(caps[0].name).toBe('x');
-  });
-
-  it('createRunnables routes each capability to its owning provider', async () => {
-    const p1 = new FakeProvider('p1', [makeCap('a'), makeCap('b')]);
-    const p2 = new FakeProvider('p2', [makeCap('c')]);
-    const composite = new CompositeCapabilityProvider([p1, p2]);
-    const manifest = await composite.fetchManifest();
-    const runnables = await composite.createRunnables(manifest, {});
-    expect(runnables).toHaveLength(3);
-    expect(p1.createCallCount).toBe(1);
-    expect(p2.createCallCount).toBe(1);
-  });
-});

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';