@tooluminati/angular 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 jitterbox
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @experimental Tooluminati Angular bindings — public APIs may change.
+ */
+export * from './web-mcp-context';
+export * from './inject-web-mcp-registry';
+export * from './provide-web-mcp-registry';
+export * from './register-web-mcp-tool';
+export * from './register-web-mcp-tools';
+export * from './stable-tool';
+export * from './web-mcp-security-banner';
+export * from './web-mcp-security-banner.component';
+export * from './web-mcp-scope.component';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,eAAe,CAAC;AAC9B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qCAAqC,CAAC;AACpD,cAAc,2BAA2B,CAAC"}

package/dist/index.js

@@ -0,0 +1,12 @@
+/**
+ * @experimental Tooluminati Angular bindings — public APIs may change.
+ */
+export * from './web-mcp-context';
+export * from './inject-web-mcp-registry';
+export * from './provide-web-mcp-registry';
+export * from './register-web-mcp-tool';
+export * from './register-web-mcp-tools';
+export * from './stable-tool';
+export * from './web-mcp-security-banner';
+export * from './web-mcp-security-banner.component';
+export * from './web-mcp-scope.component';

package/dist/inject-web-mcp-registry.d.ts

@@ -0,0 +1,4 @@
+import type { WebMcpRegistry } from '@tooluminati/core';
+export declare function injectWebMcpContextValue(fallbackRegistry?: WebMcpRegistry): import('./web-mcp-context').WebMcpAngularContextValue;
+export declare function injectWebMcpRegistry(fallbackRegistry?: WebMcpRegistry): WebMcpRegistry;
+//# sourceMappingURL=inject-web-mcp-registry.d.ts.map

package/dist/inject-web-mcp-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-web-mcp-registry.d.ts","sourceRoot":"","sources":["../src/inject-web-mcp-registry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGxD,wBAAgB,wBAAwB,CACtC,gBAAgB,CAAC,EAAE,cAAc,GAChC,OAAO,mBAAmB,EAAE,yBAAyB,CAiBvD;AAED,wBAAgB,oBAAoB,CAClC,gBAAgB,CAAC,EAAE,cAAc,GAChC,cAAc,CAEhB"}

package/dist/inject-web-mcp-registry.js

@@ -0,0 +1,19 @@
+import { inject } from '@angular/core';
+import { WEB_MCP_CONTEXT } from './web-mcp-context';
+export function injectWebMcpContextValue(fallbackRegistry) {
+    if (fallbackRegistry) {
+        return {
+            registry: fallbackRegistry,
+            enabled: true,
+        };
+    }
+    const context = inject(WEB_MCP_CONTEXT, { optional: true });
+    if (!context) {
+        throw new Error('injectWebMcpRegistry() called outside a WebMcp provider. ' +
+            'Add provideWebMcpRegistry() to your application or route providers.');
+    }
+    return context;
+}
+export function injectWebMcpRegistry(fallbackRegistry) {
+    return injectWebMcpContextValue(fallbackRegistry).registry;
+}

package/dist/provide-web-mcp-registry.d.ts

@@ -0,0 +1,19 @@
+import { EnvironmentProviders } from '@angular/core';
+import { type PolicyContext, type WebMcpRegistryOptions, type WebMcpToolDescriptor } from '@tooluminati/core';
+import { type WebMcpPolicySet } from '@tooluminati/policies';
+import { type WebMcpAngularContextValue } from './web-mcp-context';
+export interface WebMcpRegistryConfig {
+    tools?: WebMcpToolDescriptor[];
+    enabled?: boolean;
+    strict?: boolean;
+    namespace?: string;
+    policies?: WebMcpPolicySet;
+    policyContext?: PolicyContext;
+    modelContext?: WebMcpRegistryOptions['modelContext'];
+    getAppContext?: () => unknown;
+    onSecurityWarning?: WebMcpRegistryOptions['onSecurityWarning'];
+    onError?: WebMcpRegistryOptions['onError'];
+}
+export declare function provideWebMcpRegistry(config?: WebMcpRegistryConfig): EnvironmentProviders;
+export declare function createWebMcpRegistryForTesting(config?: WebMcpRegistryConfig): WebMcpAngularContextValue;
+//# sourceMappingURL=provide-web-mcp-registry.d.ts.map

package/dist/provide-web-mcp-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provide-web-mcp-registry.d.ts","sourceRoot":"","sources":["../src/provide-web-mcp-registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,oBAAoB,EAMrB,MAAM,eAAe,CAAC;AACvB,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EAC1B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAEL,KAAK,yBAAyB,EAC/B,MAAM,mBAAmB,CAAC;AAE3B,MAAM,WAAW,oBAAoB;IACnC,KAAK,CAAC,EAAE,oBAAoB,EAAE,CAAC;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,YAAY,CAAC,EAAE,qBAAqB,CAAC,cAAc,CAAC,CAAC;IACrD,aAAa,CAAC,EAAE,MAAM,OAAO,CAAC;IAC9B,iBAAiB,CAAC,EAAE,qBAAqB,CAAC,mBAAmB,CAAC,CAAC;IAC/D,OAAO,CAAC,EAAE,qBAAqB,CAAC,SAAS,CAAC,CAAC;CAC5C;AAyBD,wBAAgB,qBAAqB,CACnC,MAAM,GAAE,oBAAyB,GAChC,oBAAoB,CAwDtB;AAED,wBAAgB,8BAA8B,CAC5C,MAAM,GAAE,oBAAyB,GAChC,yBAAyB,CAmB3B"}

package/dist/provide-web-mcp-registry.js

@@ -0,0 +1,79 @@
+import { DestroyRef, isDevMode, makeEnvironmentProviders, Optional, signal, SkipSelf, } from '@angular/core';
+import { WebMcpRegistry, } from '@tooluminati/core';
+import { localDevPolicy, } from '@tooluminati/policies';
+import { WEB_MCP_CONTEXT, } from './web-mcp-context';
+function buildContextValue(registry, config, registryRevision) {
+    const value = {
+        registry,
+        enabled: config.enabled ?? false,
+        policies: config.policies ?? localDevPolicy,
+        registryRevision,
+    };
+    if (config.policyContext !== undefined) {
+        value.policyContext = config.policyContext;
+    }
+    if (config.namespace !== undefined) {
+        value.namespace = config.namespace;
+    }
+    return value;
+}
+export function provideWebMcpRegistry(config = {}) {
+    return makeEnvironmentProviders([
+        {
+            provide: WEB_MCP_CONTEXT,
+            useFactory: (parentContext, destroyRef) => {
+                if (parentContext &&
+                    config.namespace === undefined &&
+                    isDevMode()) {
+                    console.warn('[tooluminati] Nested WebMcp provider detected without a namespace. ' +
+                        'Provide namespace to avoid tool collisions.');
+                }
+                const registryRevision = signal(0, ...(ngDevMode ? [{ debugName: "registryRevision" }] : []));
+                const bumpRegistryRevision = () => {
+                    registryRevision.update((value) => value + 1);
+                };
+                const registry = new WebMcpRegistry({
+                    enabled: config.enabled ?? false,
+                    strict: config.strict ?? false,
+                    namespace: config.namespace,
+                    policies: config.policies ?? localDevPolicy,
+                    policyContext: config.policyContext,
+                    modelContext: config.modelContext,
+                    getAppContext: config.getAppContext,
+                    onSecurityWarning: config.onSecurityWarning,
+                    onError: config.onError,
+                    onRegister: () => bumpRegistryRevision(),
+                });
+                const tools = config.tools ?? [];
+                const registrations = tools.map((tool) => registry.registerTool(tool, { source: 'provider' }));
+                destroyRef.onDestroy(() => {
+                    for (const registration of registrations) {
+                        registration.abort();
+                    }
+                    registry.unregisterAll();
+                    bumpRegistryRevision();
+                });
+                return buildContextValue(registry, config, registryRevision);
+            },
+            deps: [[new Optional(), new SkipSelf(), WEB_MCP_CONTEXT], DestroyRef],
+        },
+    ]);
+}
+export function createWebMcpRegistryForTesting(config = {}) {
+    const registry = new WebMcpRegistry({
+        enabled: config.enabled ?? false,
+        strict: config.strict ?? false,
+        namespace: config.namespace,
+        policies: config.policies ?? localDevPolicy,
+        policyContext: config.policyContext,
+        modelContext: config.modelContext,
+        getAppContext: config.getAppContext,
+        onSecurityWarning: config.onSecurityWarning,
+        onError: config.onError,
+    });
+    const tools = config.tools ?? [];
+    for (const tool of tools) {
+        registry.registerTool(tool, { source: 'provider' });
+    }
+    return buildContextValue(registry, config, signal(0));
+}

package/dist/register-web-mcp-tool.d.ts

@@ -0,0 +1,9 @@
+import { type Signal } from '@angular/core';
+import type { RegisterToolOptions, WebMcpRegistry, WebMcpToolDescriptor } from '@tooluminati/core';
+export interface RegisterWebMcpToolOptions extends RegisterToolOptions {
+    fallbackRegistry?: WebMcpRegistry;
+    /** Signal dependencies that trigger tool definition re-registration. */
+    definitionDeps?: Signal<unknown>[];
+}
+export declare function registerWebMcpTool<TArgs, TResult>(getTool: () => WebMcpToolDescriptor<TArgs, TResult>, options?: RegisterWebMcpToolOptions): void;
+//# sourceMappingURL=register-web-mcp-tool.d.ts.map

package/dist/register-web-mcp-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-web-mcp-tool.d.ts","sourceRoot":"","sources":["../src/register-web-mcp-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,MAAM,EACZ,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EACV,mBAAmB,EAGnB,cAAc,EACd,oBAAoB,EACrB,MAAM,mBAAmB,CAAC;AAI3B,MAAM,WAAW,yBAA0B,SAAQ,mBAAmB;IACpE,gBAAgB,CAAC,EAAE,cAAc,CAAC;IAClC,wEAAwE;IACxE,cAAc,CAAC,EAAE,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;CACpC;AAgDD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAC/C,OAAO,EAAE,MAAM,oBAAoB,CAAC,KAAK,EAAE,OAAO,CAAC,EACnD,OAAO,GAAE,yBAA8B,GACtC,IAAI,CA8CN"}

package/dist/register-web-mcp-tool.js

@@ -0,0 +1,64 @@
+import { assertInInjectionContext, DestroyRef, effect, inject, untracked, } from '@angular/core';
+import { injectWebMcpRegistry } from './inject-web-mcp-registry';
+import { WEB_MCP_CONTEXT } from './web-mcp-context';
+function stableSerialize(value) {
+    return JSON.stringify(value, (_key, current) => current && typeof current === 'object' && !Array.isArray(current)
+        ? Object.keys(current)
+            .sort()
+            .reduce((accumulator, key) => {
+            accumulator[key] = current[key];
+            return accumulator;
+        }, {})
+        : current);
+}
+function buildDefinitionKey(tool, options) {
+    return {
+        name: tool.name,
+        title: tool.title,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        annotations: tool.annotations,
+        exposedTo: options.exposedTo,
+        source: options.source,
+    };
+}
+function registerToolInstance(registry, toolRef, options) {
+    return registry.registerTool({
+        ...toolRef.current,
+        execute: (args, executionContext) => toolRef.current.execute(args, executionContext),
+    }, {
+        ...options,
+        source: options.source ?? 'hook',
+    });
+}
+export function registerWebMcpTool(getTool, options = {}) {
+    assertInInjectionContext(registerWebMcpTool);
+    const registry = injectWebMcpRegistry(options.fallbackRegistry);
+    const context = inject(WEB_MCP_CONTEXT, { optional: true });
+    const destroyRef = inject(DestroyRef);
+    const toolRef = { current: getTool() };
+    let registration = registerToolInstance(registry, toolRef, options);
+    if (options.definitionDeps?.length) {
+        let lastDefinitionKey = stableSerialize(buildDefinitionKey(toolRef.current, options));
+        effect(() => {
+            for (const dep of options.definitionDeps) {
+                dep();
+            }
+            untracked(() => {
+                toolRef.current = getTool();
+                const definitionKey = stableSerialize(buildDefinitionKey(toolRef.current, options));
+                if (definitionKey === lastDefinitionKey) {
+                    return;
+                }
+                lastDefinitionKey = definitionKey;
+                registration.abort();
+                context?.registryRevision?.update((value) => value + 1);
+                registration = registerToolInstance(registry, toolRef, options);
+            });
+        });
+    }
+    destroyRef.onDestroy(() => {
+        registration.abort();
+        context?.registryRevision?.update((value) => value + 1);
+    });
+}

package/dist/register-web-mcp-tools.d.ts

@@ -0,0 +1,3 @@
+import type { RegisterToolOptions, WebMcpToolDescriptor } from '@tooluminati/core';
+export declare function registerWebMcpTools(tools: WebMcpToolDescriptor[], options?: RegisterToolOptions): void;
+//# sourceMappingURL=register-web-mcp-tools.d.ts.map

package/dist/register-web-mcp-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-web-mcp-tools.d.ts","sourceRoot":"","sources":["../src/register-web-mcp-tools.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,mBAAmB,CAAC;AAI3B,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,oBAAoB,EAAE,EAC7B,OAAO,GAAE,mBAAwB,GAChC,IAAI,CAoBN"}

package/dist/register-web-mcp-tools.js

@@ -0,0 +1,20 @@
+import { assertInInjectionContext, DestroyRef, inject, } from '@angular/core';
+import { injectWebMcpRegistry } from './inject-web-mcp-registry';
+import { WEB_MCP_CONTEXT } from './web-mcp-context';
+export function registerWebMcpTools(tools, options = {}) {
+    assertInInjectionContext(registerWebMcpTools);
+    const registry = injectWebMcpRegistry();
+    const context = inject(WEB_MCP_CONTEXT, { optional: true });
+    const destroyRef = inject(DestroyRef);
+    const source = options.source ?? 'scope';
+    const registrations = tools.map((tool) => registry.registerTool(tool, {
+        ...options,
+        source,
+    }));
+    destroyRef.onDestroy(() => {
+        for (const registration of registrations) {
+            registration.abort();
+        }
+        context?.registryRevision?.update((value) => value + 1);
+    });
+}

package/dist/stable-tool.d.ts

@@ -0,0 +1,4 @@
+import { type Signal } from '@angular/core';
+import type { WebMcpToolDescriptor } from '@tooluminati/core';
+export declare function createStableWebMcpTool<TArgs, TResult>(factory: () => WebMcpToolDescriptor<TArgs, TResult>, deps: Signal<unknown>[]): Signal<WebMcpToolDescriptor<TArgs, TResult>>;
+//# sourceMappingURL=stable-tool.d.ts.map

package/dist/stable-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stable-tool.d.ts","sourceRoot":"","sources":["../src/stable-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAE9D,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,EACnD,OAAO,EAAE,MAAM,oBAAoB,CAAC,KAAK,EAAE,OAAO,CAAC,EACnD,IAAI,EAAE,MAAM,CAAC,OAAO,CAAC,EAAE,GACtB,MAAM,CAAC,oBAAoB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAQ9C"}

package/dist/stable-tool.js

@@ -0,0 +1,9 @@
+import { computed } from '@angular/core';
+export function createStableWebMcpTool(factory, deps) {
+    return computed(() => {
+        for (const dep of deps) {
+            dep();
+        }
+        return factory();
+    });
+}

package/dist/test-setup.d.ts

@@ -0,0 +1,5 @@
+import 'zone.js';
+import 'zone.js/testing';
+import { type TestModuleMetadata } from '@angular/core/testing';
+export declare function configureAngularTestingModule(metadata: TestModuleMetadata): void;
+//# sourceMappingURL=test-setup.d.ts.map

package/dist/test-setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-setup.d.ts","sourceRoot":"","sources":["../src/test-setup.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,CAAC;AACjB,OAAO,iBAAiB,CAAC;AACzB,OAAO,EAGL,KAAK,kBAAkB,EACxB,MAAM,uBAAuB,CAAC;AAW/B,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,kBAAkB,GAC3B,IAAI,CAEN"}

package/dist/test-setup.js

@@ -0,0 +1,8 @@
+import 'zone.js';
+import 'zone.js/testing';
+import { getTestBed, TestBed, } from '@angular/core/testing';
+import { BrowserDynamicTestingModule, platformBrowserDynamicTesting, } from '@angular/platform-browser-dynamic/testing';
+getTestBed().initTestEnvironment(BrowserDynamicTestingModule, platformBrowserDynamicTesting());
+export function configureAngularTestingModule(metadata) {
+    TestBed.configureTestingModule(metadata);
+}

package/dist/web-mcp-context.d.ts

@@ -0,0 +1,14 @@
+import { InjectionToken, type WritableSignal } from '@angular/core';
+import type { PolicyContext, WebMcpRegistry } from '@tooluminati/core';
+import type { WebMcpPolicySet } from '@tooluminati/policies';
+export interface WebMcpAngularContextValue {
+    registry: WebMcpRegistry;
+    enabled: boolean;
+    /** Bumps when tools register or unregister so UI can react. */
+    registryRevision?: WritableSignal<number>;
+    policies?: WebMcpPolicySet;
+    policyContext?: PolicyContext | undefined;
+    namespace?: string | undefined;
+}
+export declare const WEB_MCP_CONTEXT: InjectionToken<WebMcpAngularContextValue>;
+//# sourceMappingURL=web-mcp-context.d.ts.map

package/dist/web-mcp-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-mcp-context.d.ts","sourceRoot":"","sources":["../src/web-mcp-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AACpE,OAAO,KAAK,EACV,aAAa,EACb,cAAc,EACf,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,cAAc,CAAC;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,+DAA+D;IAC/D,gBAAgB,CAAC,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;IAC1C,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,aAAa,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC1C,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC;AAED,eAAO,MAAM,eAAe,2CAE3B,CAAC"}

package/dist/web-mcp-context.js

@@ -0,0 +1,2 @@
+import { InjectionToken } from '@angular/core';
+export const WEB_MCP_CONTEXT = new InjectionToken('WEB_MCP_CONTEXT');

package/dist/web-mcp-scope.component.d.ts

@@ -0,0 +1,11 @@
+import type { WebMcpToolDescriptor, WebMcpToolSource } from '@tooluminati/core';
+import * as i0 from "@angular/core";
+export declare class WebMcpScopeComponent {
+    readonly tools: import("@angular/core").InputSignal<WebMcpToolDescriptor<unknown, unknown>[]>;
+    readonly source: import("@angular/core").InputSignal<WebMcpToolSource>;
+    readonly namespaceSegment: import("@angular/core").InputSignal<string | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebMcpScopeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WebMcpScopeComponent, "web-mcp-scope", never, { "tools": { "alias": "tools"; "required": true; "isSignal": true; }; "source": { "alias": "source"; "required": false; "isSignal": true; }; "namespaceSegment": { "alias": "namespaceSegment"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+//# sourceMappingURL=web-mcp-scope.component.d.ts.map

package/dist/web-mcp-scope.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-mcp-scope.component.d.ts","sourceRoot":"","sources":["../src/web-mcp-scope.component.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,oBAAoB,EACpB,gBAAgB,EACjB,MAAM,mBAAmB,CAAC;;AAI3B,qBAKa,oBAAoB;IAC/B,QAAQ,CAAC,KAAK,gFAA4C;IAC1D,QAAQ,CAAC,MAAM,wDAAoC;IACnD,QAAQ,CAAC,gBAAgB,0DAAwC;;yCAHtD,oBAAoB;2CAApB,oBAAoB;CAmChC"}

package/dist/web-mcp-scope.component.js

@@ -0,0 +1,43 @@
+import { Component, DestroyRef, effect, inject, input, } from '@angular/core';
+import { injectWebMcpRegistry } from './inject-web-mcp-registry';
+import { WEB_MCP_CONTEXT } from './web-mcp-context';
+import * as i0 from "@angular/core";
+export class WebMcpScopeComponent {
+    tools = input.required(...(ngDevMode ? [{ debugName: "tools" }] : []));
+    source = input('scope', ...(ngDevMode ? [{ debugName: "source" }] : []));
+    namespaceSegment = input(undefined, ...(ngDevMode ? [{ debugName: "namespaceSegment" }] : []));
+    constructor() {
+        const registry = injectWebMcpRegistry();
+        const context = inject(WEB_MCP_CONTEXT, { optional: true });
+        const destroyRef = inject(DestroyRef);
+        effect((onCleanup) => {
+            const segment = this.namespaceSegment();
+            const scopedTools = segment
+                ? this.tools().map((tool) => ({
+                    ...tool,
+                    name: `${segment}.${tool.name}`,
+                }))
+                : this.tools();
+            const registrations = scopedTools.map((tool) => registry.registerTool(tool, {
+                source: this.source(),
+            }));
+            onCleanup(() => {
+                for (const registration of registrations) {
+                    registration.abort();
+                }
+                context?.registryRevision?.update((value) => value + 1);
+            });
+        });
+        destroyRef.onDestroy(() => undefined);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: WebMcpScopeComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "20.3.25", type: WebMcpScopeComponent, isStandalone: true, selector: "web-mcp-scope", inputs: { tools: { classPropertyName: "tools", publicName: "tools", isSignal: true, isRequired: true, transformFunction: null }, source: { classPropertyName: "source", publicName: "source", isSignal: true, isRequired: false, transformFunction: null }, namespaceSegment: { classPropertyName: "namespaceSegment", publicName: "namespaceSegment", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: '<ng-content />', isInline: true });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: WebMcpScopeComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'web-mcp-scope',
+                    standalone: true,
+                    template: '<ng-content />',
+                }]
+        }], ctorParameters: () => [], propDecorators: { tools: [{ type: i0.Input, args: [{ isSignal: true, alias: "tools", required: true }] }], source: [{ type: i0.Input, args: [{ isSignal: true, alias: "source", required: false }] }], namespaceSegment: [{ type: i0.Input, args: [{ isSignal: true, alias: "namespaceSegment", required: false }] }] } });

package/dist/web-mcp-security-banner.component.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+export declare class WebMcpSecurityBannerComponent {
+    private readonly context;
+    readonly banner: import("@angular/core").Signal<{
+        enabled: boolean;
+        supported: boolean;
+        registeredTools: string[];
+        message: string;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebMcpSecurityBannerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WebMcpSecurityBannerComponent, "web-mcp-security-banner", never, {}, {}, never, never, true, never>;
+}
+//# sourceMappingURL=web-mcp-security-banner.component.d.ts.map

package/dist/web-mcp-security-banner.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-mcp-security-banner.component.d.ts","sourceRoot":"","sources":["../src/web-mcp-security-banner.component.ts"],"names":[],"mappings":";AAIA,qBAuBa,6BAA6B;IACxC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA8B;IAEtD,QAAQ,CAAC,MAAM;;;;;OAWZ;yCAdQ,6BAA6B;2CAA7B,6BAA6B;CAezC"}

package/dist/web-mcp-security-banner.component.js

@@ -0,0 +1,64 @@
+import { Component, computed } from '@angular/core';
+import { injectWebMcpContextValue } from './inject-web-mcp-registry';
+import { isWebMcpSupported } from '@tooluminati/core';
+import * as i0 from "@angular/core";
+export class WebMcpSecurityBannerComponent {
+    context = injectWebMcpContextValue();
+    banner = computed(() => {
+        this.context.registryRevision?.();
+        return {
+            enabled: this.context.enabled,
+            supported: isWebMcpSupported(),
+            registeredTools: this.context.registry.getRegisteredToolNames(),
+            message: this.context.enabled
+                ? 'Tooluminati diagnostics are enabled for this page.'
+                : 'Tooluminati diagnostics are disabled.',
+        };
+    }, ...(ngDevMode ? [{ debugName: "banner" }] : []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: WebMcpSecurityBannerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.25", type: WebMcpSecurityBannerComponent, isStandalone: true, selector: "web-mcp-security-banner", ngImport: i0, template: `
+    @if (banner().enabled) {
+      <aside
+        aria-live="polite"
+        style="
+          background: #fff3cd;
+          border: 1px solid #ffeeba;
+          color: #856404;
+          padding: 0.75rem 1rem;
+          margin-bottom: 1rem;
+        "
+      >
+        <strong>Tooluminati diagnostics enabled.</strong>
+        {{ banner().message }}
+        Registered tools:
+        {{ banner().registeredTools.join(', ') || 'none' }}.
+      </aside>
+    }
+  `, isInline: true });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: WebMcpSecurityBannerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'web-mcp-security-banner',
+                    standalone: true,
+                    template: `
+    @if (banner().enabled) {
+      <aside
+        aria-live="polite"
+        style="
+          background: #fff3cd;
+          border: 1px solid #ffeeba;
+          color: #856404;
+          padding: 0.75rem 1rem;
+          margin-bottom: 1rem;
+        "
+      >
+        <strong>Tooluminati diagnostics enabled.</strong>
+        {{ banner().message }}
+        Registered tools:
+        {{ banner().registeredTools.join(', ') || 'none' }}.
+      </aside>
+    }
+  `,
+                }]
+        }] });

package/dist/web-mcp-security-banner.d.ts

@@ -0,0 +1,7 @@
+export declare function webMcpSecurityBanner(): import("@angular/core").Signal<{
+    enabled: boolean;
+    supported: boolean;
+    registeredTools: string[];
+    message: string;
+}>;
+//# sourceMappingURL=web-mcp-security-banner.d.ts.map

package/dist/web-mcp-security-banner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-mcp-security-banner.d.ts","sourceRoot":"","sources":["../src/web-mcp-security-banner.ts"],"names":[],"mappings":"AAIA,wBAAgB,oBAAoB;;;;;GAenC"}

package/dist/web-mcp-security-banner.js

@@ -0,0 +1,17 @@
+import { computed } from '@angular/core';
+import { isWebMcpSupported } from '@tooluminati/core';
+import { injectWebMcpContextValue } from './inject-web-mcp-registry';
+export function webMcpSecurityBanner() {
+    const { enabled, registry, registryRevision } = injectWebMcpContextValue();
+    return computed(() => {
+        registryRevision?.();
+        return {
+            enabled,
+            supported: isWebMcpSupported(),
+            registeredTools: registry.getRegisteredToolNames(),
+            message: enabled
+                ? 'Tooluminati diagnostics are enabled for this page.'
+                : 'Tooluminati diagnostics are disabled.',
+        };
+    });
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@tooluminati/angular",
+  "version": "0.1.0",
+  "description": "Angular provider, directives, and scopes for Tooluminati.",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "tslib": "^2.8.0",
+    "@tooluminati/policies": "0.1.0",
+    "@tooluminati/core": "0.1.0"
+  },
+  "peerDependencies": {
+    "@angular/core": "^20.0.0",
+    "@angular/common": "^20.0.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jitterbox/Tooluminati.git",
+    "directory": "packages/angular"
+  },
+  "bugs": {
+    "url": "https://github.com/jitterbox/Tooluminati/issues"
+  },
+  "homepage": "https://github.com/jitterbox/Tooluminati#readme",
+  "keywords": [
+    "tooluminati",
+    "webmcp",
+    "angular",
+    "signals",
+    "agents"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "ngc -p tsconfig.build.json",
+    "typecheck": "ngc -p tsconfig.json --noEmit"
+  }
+}