feat(core): add provideWebMcpTools

This is an ergonomic wrapper around `declareWebMcpTool`, allowing a user to define multiple tools directly on an injector's providers, rather than needing to find an injection context.

Example:

```typescript
import {bootstrapApplication, provideWebMcpTools} from '@angular/core';

await bootstrapApplication(RootComp, {
  providers: [
    provideWebMcpTools([
      {
        name: 'hello',
        description: 'Says hello',
        inputSchema: {type: 'object', properties: {}},
        execute: async () => ({content: [{type: 'text', text: 'Hello, World!'}]});
      },
    ]),
  ],
});
```

The `execute` function is invoked in the injection context of the `Injector` it is provided to, meaning you can easily `inject` dependencies and invoke them.

This also works particularly well with route `providers` and `withExperimentalAutoCleanupInjectors`, registering the tools when the router is navigated to and then automatically unregistering them when navigating away. Note that `withExperimentalAutoCleanupInjectors` is required for unregistration to work.

```typescript
import {provideWebMcpTools} from '@angular/core';
import {provideRouter} from '@angular/router';

provideRouter(
  [
    {
      path: '',
      component: Home,
      providers: [
        provideWebMcpTools([
          {
            name: 'hello',
            description: 'Says hello',
            inputSchema: {type: 'object', properties: {}},
            execute: async () => ({content: [{type: 'text', text: 'Hello, World!'}]}),
          },
        ]),
      ],
    },
  ],
  withExperimentalAutoCleanupInjectors(),
);
```

Author: dgp1130

goldens/public-api/core/index.api.md

@@ -1517,6 +1517,9 @@ export type ProviderToken<T> = Type<T> | AbstractType<T> | InjectionToken<T>;
 // @public
 export function provideStabilityDebugging(): EnvironmentProviders;
 
+// @public
+export function provideWebMcpTools<const InputSchema extends JsonSchemaForInference>(tools: WebMcpToolDescriptor<InputSchema>[]): EnvironmentProviders;
+
 // @public
 export function provideZoneChangeDetection(options?: NgZoneOptions): EnvironmentProviders;
 

packages/core/src/webmcp/index.ts

@@ -7,6 +7,7 @@
  */
 
 export {declareWebMcpTool} from './declare_tool';
+export {provideWebMcpTools} from './provide_tools';
 export type {
   Execute as WebMcpToolExecute,
   Client as WebMcpClient,

packages/core/src/webmcp/provide_tools.ts

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+
+import type {JsonSchemaForInference} from '../../third_party/@mcp-b/webmcp-types';
+import {EnvironmentProviders, makeEnvironmentProviders, provideEnvironmentInitializer} from '../di';
+import {declareWebMcpTool} from './declare_tool';
+import type {ToolDescriptor} from './types';
+
+/**
+ * Provides a list of WebMCP tools tied to the lifecycle of the associated `Injector`.
+ *
+ * The tools are automatically registered when the environment is initialized
+ * and unregistered when the associated injector is destroyed.
+ *
+ * The `tools[number].execute` function is invoked in the injection context of the
+ * associated `Injector`.
+ *
+ * @param tools The tools to register and execute when invoked by an AI agent.
+ * @returns An {@link EnvironmentProviders} that can be used in `bootstrapApplication`
+ *     or route providers.
+ * @experimental
+ */
+export function provideWebMcpTools<const InputSchema extends JsonSchemaForInference>(
+  tools: ToolDescriptor<InputSchema>[],
+): EnvironmentProviders {
+  return makeEnvironmentProviders([
+    provideEnvironmentInitializer(() => {
+      for (const tool of tools) declareWebMcpTool(tool);
+    }),
+  ]);
+}

packages/core/test/webmcp/BUILD.bazel

@@ -14,6 +14,8 @@ ts_project(
         "//packages/core:node_modules/@mcp-b/webmcp-polyfill",
         "//packages/core/testing",
         "//packages/core/third_party/@mcp-b/webmcp-types",
+        "//packages/router",
+        "//packages/router/testing",
     ],
 )
 

packages/core/test/webmcp/provide_tools_spec.ts

@@ -0,0 +1,128 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+
+import {initializeWebMCPPolyfill, cleanupWebMCPPolyfill} from '@mcp-b/webmcp-polyfill';
+import type {JsonSchemaForInference} from '../../third_party/@mcp-b/webmcp-types';
+import {Component, createEnvironmentInjector, EnvironmentInjector} from '../../src/core';
+import {provideRouter, Router, withExperimentalAutoCleanupInjectors} from '@angular/router';
+import {provideWebMcpTools} from '../../src/webmcp/provide_tools';
+import {Execute} from '../../src/webmcp/types';
+import {TestBed} from '../../testing';
+
+describe('provideWebMcpTools', () => {
+  beforeEach(() => {
+    initializeWebMCPPolyfill({installTestingShim: true});
+  });
+
+  afterEach(() => {
+    cleanupWebMCPPolyfill();
+  });
+
+  it('should register tools when initialized', async () => {
+    const execute = jasmine.createSpy<Execute<JsonSchemaForInference>>('execute').and.returnValue({
+      content: [{type: 'text', text: 'Hello!'}],
+    });
+
+    const envInjector = createEnvironmentInjector(
+      [
+        provideWebMcpTools([
+          {
+            name: 'testTool',
+            description: 'A test tool',
+            inputSchema: {type: 'object', properties: {}},
+            execute,
+          },
+        ]),
+      ],
+      TestBed.inject(EnvironmentInjector),
+    );
+
+    expect(globalThis.navigator.modelContextTesting!.listTools()).toEqual([
+      jasmine.objectContaining({name: 'testTool'}),
+    ]);
+
+    await globalThis.navigator.modelContextTesting!.executeTool('testTool', '{}');
+    expect(execute).toHaveBeenCalledOnceWith({}, jasmine.any(Object));
+
+    envInjector.destroy();
+  });
+
+  it('should unregister tools when the injector is destroyed', () => {
+    const envInjector = createEnvironmentInjector(
+      [
+        provideWebMcpTools([
+          {
+            name: 'testTool',
+            description: 'A test tool',
+            inputSchema: {type: 'object', properties: {}},
+            execute: async () => ({content: []}),
+          },
+        ]),
+      ],
+      TestBed.inject(EnvironmentInjector),
+    );
+
+    expect(globalThis.navigator.modelContextTesting!.listTools()).toEqual([
+      jasmine.objectContaining({name: 'testTool'}),
+    ]);
+
+    envInjector.destroy();
+
+    expect(globalThis.navigator.modelContextTesting!.listTools()).toEqual([]);
+  });
+
+  it('should work with route providers', async () => {
+    @Component({
+      selector: 'test-comp',
+      template: '',
+    })
+    class TestComp {}
+
+    TestBed.configureTestingModule({
+      imports: [TestComp],
+      providers: [
+        provideRouter(
+          [
+            {
+              path: 'test',
+              component: TestComp,
+              providers: [
+                provideWebMcpTools([
+                  {
+                    name: 'routeTool',
+                    description: 'A route tool',
+                    inputSchema: {type: 'object', properties: {}},
+                    execute: async () => ({content: []}),
+                  },
+                ]),
+              ],
+            },
+          ],
+          withExperimentalAutoCleanupInjectors(),
+        ),
+      ],
+    });
+
+    const router = TestBed.inject(Router);
+    const rootFixture = TestBed.createComponent(TestComp);
+    await rootFixture.whenStable();
+
+    // No tools should be registered initially
+    expect(globalThis.navigator.modelContextTesting!.listTools()).toEqual([]);
+
+    // Navigate to the route to register the tools
+    await router.navigateByUrl('/test');
+    expect(globalThis.navigator.modelContextTesting!.listTools()).toEqual([
+      jasmine.objectContaining({name: 'routeTool'}),
+    ]);
+
+    // Navigate away to destroy route environment injector context
+    await router.navigateByUrl('/');
+    expect(globalThis.navigator.modelContextTesting!.listTools()).toEqual([]);
+  });
+});