Convert Vertex AI to the AI package

package.json

@@ -57,7 +57,7 @@
     "@angular/router": "^19.0.0",
     "@schematics/angular": "^19.0.0",
     "esbuild": "^0.24.0",
-    "firebase": "^11.2.0",
+    "firebase": "11.8.0-20250512211235",
     "firebase-functions": "^6.1.0",
     "fs-extra": "^8.0.1",
     "fuzzy": "^0.1.3",
@@ -120,5 +120,8 @@
     "typescript": ">=5.5 <5.7",
     "yaml": "^2.7.0"
   },
-  "typings": "index.d.ts"
+  "typings": "index.d.ts",
+  "overrides": {
+    "firebase": "11.8.0-20250512211235"
+  }
 }

src/ai/ai.module.ts

@@ -0,0 +1,79 @@
+import {
+  EnvironmentProviders,
+  InjectionToken,
+  Injector,
+  NgModule,
+  NgZone,
+  Optional,
+  makeEnvironmentProviders,
+} from '@angular/core';
+import { VERSION, ɵAngularFireSchedulers, ɵgetDefaultInstanceOf } from '@angular/fire';
+import { FirebaseApp, FirebaseApps } from '@angular/fire/app';
+import { AppCheckInstances } from '@angular/fire/app-check';
+import { AI as FirebaseAI } from 'firebase/ai';
+import { registerVersion } from 'firebase/app';
+import { AI, AIInstances, AI_PROVIDER_NAME } from './ai';
+
+export const PROVIDED_AI_INSTANCES = new InjectionToken<AI[]>('angularfire2.ai-instances');
+
+export function defaultAIInstanceFactory(provided: FirebaseAI[]|undefined, defaultApp: FirebaseApp) {
+  const defaultAI = ɵgetDefaultInstanceOf<FirebaseAI>(AI_PROVIDER_NAME, provided, defaultApp);
+  return defaultAI && new AI(defaultAI);
+}
+
+export function AIInstanceFactory(fn: (injector: Injector) => FirebaseAI) {
+  return (zone: NgZone, injector: Injector) => {
+    const ai = zone.runOutsideAngular(() => fn(injector));
+    return new AI(ai);
+  };
+}
+
+const AI_INSTANCES_PROVIDER = {
+  provide: AIInstances,
+  deps: [
+    [new Optional(), PROVIDED_AI_INSTANCES ],
+  ]
+};
+
+const DEFAULT_AI_INSTANCE_PROVIDER = {
+  provide: AI,
+  useFactory: defaultAIInstanceFactory,
+  deps: [
+    [new Optional(), PROVIDED_AI_INSTANCES ],
+    FirebaseApp,
+  ]
+};
+
+@NgModule({
+  providers: [
+    DEFAULT_AI_INSTANCE_PROVIDER,
+    AI_INSTANCES_PROVIDER,
+  ]
+})
+export class AIModule {
+  constructor() {
+    registerVersion('angularfire', VERSION.full, 'ai');
+  }
+}
+
+export function provideAI(fn: (injector: Injector) => FirebaseAI, ...deps: any[]): EnvironmentProviders {
+  registerVersion('angularfire', VERSION.full, 'ai');
+
+  return makeEnvironmentProviders([
+    DEFAULT_AI_INSTANCE_PROVIDER,
+    AI_INSTANCES_PROVIDER,
+    {
+      provide: PROVIDED_AI_INSTANCES,
+      useFactory: AIInstanceFactory(fn),
+      multi: true,
+      deps: [
+        NgZone,
+        Injector,
+        ɵAngularFireSchedulers,
+        FirebaseApps,
+        [new Optional(), AppCheckInstances ],
+        ...deps,
+      ]
+    }
+  ]);
+}

src/ai/ai.spec.ts

@@ -0,0 +1,38 @@
+import { TestBed } from '@angular/core/testing';
+import { AI, getAI, provideAI } from '@angular/fire/ai';
+import { FirebaseApp, getApp, initializeApp, provideFirebaseApp } from '@angular/fire/app';
+import { COMMON_CONFIG } from '../test-config';
+import { rando } from '../utils';
+
+describe('AI', () => {
+  let app: FirebaseApp;
+  let ai: AI;
+  let providedAI: AI;
+  let appName: string;
+
+  describe('single injection', () => {
+
+    beforeEach(() => {
+        appName = rando();
+        TestBed.configureTestingModule({
+            providers: [
+                provideFirebaseApp(() => initializeApp(COMMON_CONFIG, appName)),
+                provideAI(() => {
+                    providedAI = getAI(getApp(appName));
+                    return providedAI;
+                }),
+            ],
+        });
+        app = TestBed.inject(FirebaseApp);
+        ai = TestBed.inject(AI);
+    });
+
+    it('should be injectable', () => {
+        expect(providedAI).toBeTruthy();
+        expect(ai).toEqual(providedAI);
+        expect(ai.app).toEqual(app);
+    });
+
+  });
+
+});

src/ai/ai.ts

@@ -0,0 +1,30 @@
+import { ɵgetAllInstancesOf } from '@angular/fire';
+import { AI as FirebaseAI } from 'firebase/ai';
+import { from, timer } from 'rxjs';
+import { concatMap, distinct } from 'rxjs/operators';
+
+// see notes in core/firebase.app.module.ts for why we're building the class like this
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface AI extends FirebaseAI {}
+
+export class AI {
+  constructor(ai: FirebaseAI) {
+    return ai;
+  }
+}
+
+export const AI_PROVIDER_NAME = 'AI';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface AIInstances extends Array<FirebaseAI> {}
+
+export class AIInstances {
+  constructor() {
+    return ɵgetAllInstancesOf<FirebaseAI>(AI_PROVIDER_NAME);
+  }
+}
+
+export const AIInstance$ = timer(0, 300).pipe(
+  concatMap(() => from(ɵgetAllInstancesOf<FirebaseAI>(AI_PROVIDER_NAME))),
+  distinct(),
+);

src/ai/ng-package.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
+  "lib": {
+    "entryFile": "public_api.ts"
+  }
+}

src/ai/package.json

@@ -0,0 +1,3 @@
+{
+  "$schema": "../../node_modules/ng-packagr/package.schema.json"
+}

src/ai/public_api.ts

@@ -0,0 +1,3 @@
+export { AI, AIInstances, AIInstance$ } from './ai';
+export { provideAI, AIModule } from './ai.module';
+export * from './firebase';

src/package.json

@@ -36,7 +36,7 @@
     "@angular/platform-server": { "optional": true }
   },
   "dependencies": {
-    "firebase": "^11.2.0",
+    "firebase": "^11.8.0",
     "rxfire": "^6.1.0",
     "@angular-devkit/schematics": "^19.0.0",
     "@schematics/angular": "^19.0.0",

tools/build.ts

@@ -114,6 +114,7 @@ ${exportedZoneWrappedFns}
     await writeFile(filePath, fileOutput);
   };
   return Promise.all([
+    reexport('ai', 'firebase', 'firebase/ai', tsKeys<typeof import('firebase/ai')>()),
     reexport('analytics', 'firebase', 'firebase/analytics', tsKeys<typeof import('firebase/analytics')>(), {
       isSupported: { blockUntilFirst: false },
       logEvent: { blockUntilFirst: false, logLevel: LogLevel.VERBOSE },