Firebase AI Logic vs Genkit Dart vs LiteRT-LM: Hybrid AI Architecture & Smart Routing in Flutter

# 1. Create the Flutter project
flutter create hybrid_ai_router_codelab
cd hybrid_ai_router_codelab

# 2A. macOS / Linux / Git Bash: create Clean Architecture directories
mkdir -p lib/domain lib/data lib/application test

# 2B. Windows PowerShell: create Clean Architecture directories
New-Item -ItemType Directory -Force -Path lib/domain, lib/data, lib/application, test

name: hybrid_ai_router_codelab
description: Hybrid AI Architecture & Smart Routing in Flutter (Firebase AI Logic + Genkit Dart + LiteRT-LM).
publish_to: 'none'
version: 1.0.0+1

environment:
  sdk: ^3.8.0

dependencies:
  flutter:
    sdk: flutter
  http: ^1.2.2
  # Production SDKs for real device deployment:
  # firebase_core: ^4.0.0
  # firebase_auth: ^6.0.0
  # firebase_app_check: ^0.4.0
  # firebase_ai: ^3.0.0
  # flutter_gemma: ^0.13.5

dev_dependencies:
  flutter_test:
    sdk: flutter
  flutter_lints: ^5.0.0
  test: ^1.25.0

flutter:
  uses-material-design: true

// lib/domain/ai_models.dart

/// The three execution tiers available in a 2026 Hybrid Flutter AI architecture.
enum AiExecutionTier {
  /// Tier 1: Direct client-to-Gemini calls via `firebase_ai` + App Check.
  cloudFirebaseAi(
    label: 'Cloud (Firebase AI Logic)',
    modelId: 'gemini-flash-latest',
    zeroTokenCost: false,
  ),

  /// Tier 2: Server-side agentic flows via Genkit Dart + Shelf / Cloud Run.
  serverGenkitAgent(
    label: 'Server (Genkit Dart Agent)',
    modelId: 'gemini-2.5-flash',
    zeroTokenCost: false,
  ),

  /// Tier 3: 100% offline on-device inference via `flutter_gemma` + LiteRT-LM.
  edgeLiteRt(
    label: 'On-Device (LiteRT-LM INT4)',
    modelId: 'gemma-3n-E2B-it-int4.litertlm',
    zeroTokenCost: true,
  );

  const AiExecutionTier({
    required this.label,
    required this.modelId,
    required this.zeroTokenCost,
  });

  final String label;
  final String modelId;
  final bool zeroTokenCost;
}

/// Data privacy classification for outgoing prompts.
enum TaskSensitivity {
  /// Public or general knowledge queries safe for cloud transit.
  publicGeneral,

  /// Contains unredacted PII, medical records, or strictly private local notes.
  /// Must never leave the physical device.
  strictLocalPii,

  /// Requires privileged server-side authority (billing, quotas, DB mutations).
  privilegedTransactional,
}

/// Runtime context evaluated by the SmartHybridAiRouter before dispatching.
class RoutingContext {
  const RoutingContext({
    required this.prompt,
    required this.isOnline,
    this.sensitivity = TaskSensitivity.publicGeneral,
    this.requiresPrivilegedServerTool = false,
    this.hasMultimodalAttachment = false,
    this.availableRamMb = 4096,
  });

  final String prompt;
  final bool isOnline;
  final TaskSensitivity sensitivity;
  final bool requiresPrivilegedServerTool;
  final bool hasMultimodalAttachment;
  final int availableRamMb;
}

/// Telemetry metadata attached to every completed AI inference.
class RoutingTelemetry {
  const RoutingTelemetry({
    required this.selectedTier,
    required this.routingReason,
    required this.latencyMs,
    this.didFallbackToEdge = false,
  });

  final AiExecutionTier selectedTier;
  final String routingReason;
  final int latencyMs;
  final bool didFallbackToEdge;
}

/// Unified response returned to the presentation layer regardless of tier.
class AiInferenceResponse {
  const AiInferenceResponse({
    required this.text,
    required this.telemetry,
    this.structuredPayload,
  });

  final String text;
  final RoutingTelemetry telemetry;
  final Map<String, Object?>? structuredPayload;
}

/// Unified gateway implemented by Cloud, Server, and Edge engines.
abstract interface class AiEngineGateway {
  AiExecutionTier get tier;

  Future<String> generate({
    required String prompt,
    Map<String, Object?> metadata = const {},
  });
}

# 1. Verify active Firebase project and registered apps
npx -y firebase-tools@latest projects:list
npx -y firebase-tools@latest apps:list

# 2. MANDATORY: Provision Firebase AI Logic (enables Gemini Developer API)
npx -y firebase-tools@latest init ailogic

# 3. Generate Flutter client configuration (lib/firebase_options.dart)
flutterfire configure

// lib/data/firebase_ai_cloud_engine.dart
import 'dart:async';
import '../domain/ai_models.dart';

/// Signature for invoking `FirebaseAI.googleAI().generativeModel(...)`.
typedef CloudPromptInvoker = Future<String> Function(
  String modelName,
  String systemInstruction,
  String userPrompt,
);

/// Tier 1 Engine: Client-Side Cloud Inference via Firebase AI Logic.
///
/// Production wiring with `package:firebase_ai/firebase_ai.dart`:
/// ```dart
/// await FirebaseAppCheck.instance.activate(
///   androidProvider: AndroidProvider.playIntegrity,
///   appleProvider: AppleProvider.appAttest,
/// );
/// final googleAI = FirebaseAI.googleAI(auth: FirebaseAuth.instance);
/// final model = googleAI.generativeModel(
///   model: 'gemini-flash-latest',
///   systemInstruction: Content.system(systemInstruction),
/// );
/// final res = await model.generateContent([Content.text(userPrompt)]);
/// return res.text ?? '';
/// ```
class FirebaseAiCloudEngine implements AiEngineGateway {
  FirebaseAiCloudEngine({
    CloudPromptInvoker? invoker,
    this.modelName = 'gemini-flash-latest',
    this.timeout = const Duration(seconds: 12),
  }) : _invoker = invoker ?? _defaultSimulatedCloudInvoker;

  final CloudPromptInvoker _invoker;
  final String modelName;
  final Duration timeout;

  static const String _systemPrompt =
      'You are a concise engineering assistant accessed via Firebase AI Logic. '
      'Never claim authority to mutate billing quotas or database roles directly.';

  @override
  AiExecutionTier get tier => AiExecutionTier.cloudFirebaseAi;

  @override
  Future<String> generate({
    required String prompt,
    Map<String, Object?> metadata = const {},
  }) async {
    final trimmed = prompt.trim();
    if (trimmed.isEmpty) {
      throw ArgumentError('Prompt cannot be empty for Firebase AI Logic.');
    }

    final responseText = await _invoker(
      modelName,
      _systemPrompt,
      trimmed,
    ).timeout(timeout);

    if (responseText.trim().isEmpty) {
      throw StateError('Firebase AI Logic ($modelName) returned an empty text payload.');
    }
    return responseText.trim();
  }

  static Future<String> _defaultSimulatedCloudInvoker(
    String model,
    String systemInstruction,
    String prompt,
  ) async {
    await Future<void>.delayed(const Duration(milliseconds: 320));
    return '[Firebase AI Logic | $model] Processed multimodal/cloud prompt '
        'with App Check attestation verified: "$prompt"';
  }
}

// Reference Backend File (deployed to Cloud Run / Dart Shelf Server)
import 'package:genkit/genkit.dart';
import 'package:genkit_google_genai/genkit_google_genai.dart';
import 'package:schemantic/schemantic.dart';

void configureServerFlows() {
  final ai = Genkit(plugins: [googleAI()]);

  // Privileged server-only tool: never exposed to direct client manipulation.
  ai.defineTool(
    name: 'verifyAndAllocateOrganizationQuota',
    description: 'Verifies billing ledger state and allocates monthly AI compute quota.',
    inputSchema: SchemanticType.map(.string(), .string()),
    fn: (input, _) async {
      final orgId = input['orgId'] ?? 'unknown';
      // Server-side invariant: read authoritative ledger in Admin SDK / Postgres.
      return 'Ledger verified for $orgId: 50,000 enterprise tokens allocated.';
    },
  );

  ai.defineFlow(
    name: 'privilegedQuotaAgentFlow',
    inputSchema: .string(),
    outputSchema: .string(),
    fn: (prompt, _) async {
      final response = await ai.generate(
        model: googleAI.gemini('gemini-2.5-flash'),
        prompt: prompt,
        toolNames: ['verifyAndAllocateOrganizationQuota'],
      );
      return response.text;
    },
  );
}

// lib/data/genkit_server_engine.dart
import 'dart:async';
import 'dart:convert';
import 'package:http/http.dart' as http;
import '../domain/ai_models.dart';

/// Tier 2 Engine: Server-Side Agentic Workflows via Genkit Dart Remote Actions.
///
/// Enforces the Absolute Server-Side Security Invariant:
/// Any operation touching user quotas, payment ledgers, or privileged tools
/// executes exclusively on the Dart backend after verifying the Firebase ID Token.
class GenkitServerEngine implements AiEngineGateway {
  GenkitServerEngine({
    required this.flowEndpoint,
    required this.idTokenProvider,
    http.Client? httpClient,
    this.timeout = const Duration(seconds: 15),
  }) : _httpClient = httpClient;

  final Uri flowEndpoint;
  final Future<String> Function() idTokenProvider;
  final http.Client? _httpClient;
  final Duration timeout;

  @override
  AiExecutionTier get tier => AiExecutionTier.serverGenkitAgent;

  @override
  Future<String> generate({
    required String prompt,
    Map<String, Object?> metadata = const {},
  }) async {
    final idToken = await idTokenProvider();
    if (idToken.isEmpty) {
      throw StateError('Unauthenticated client: missing Firebase Auth ID token.');
    }

    // If no live HTTP client is injected, run deterministic local verification
    // of the Genkit Flow JSON envelope contract.
    if (_httpClient == null) {
      await Future<void>.delayed(const Duration(milliseconds: 410));
      return '[Genkit Dart Server | gemini-2.5-flash] Server-side security '
          'invariant verified (Bearer token + quota ledger check passed). '
          'Executed privileged workflow for: "${prompt.trim()}"';
    }

    final response = await _httpClient
        .post(
          flowEndpoint,
          headers: <String, String>{
            'Content-Type': 'application/json',
            'Authorization': 'Bearer $idToken',
          },
          body: jsonEncode(<String, Object?>{
            'data': <String, Object?>{
              'prompt': prompt.trim(),
              'metadata': metadata,
            },
          }),
        )
        .timeout(timeout);

    if (response.statusCode != 200) {
      throw StateError(
        'Genkit flow failed with HTTP ${response.statusCode}: ${response.body}',
      );
    }

    final decoded = jsonDecode(response.body) as Map<String, Object?>;
    final result = decoded['result']?.toString() ?? '';
    if (result.isEmpty) {
      throw StateError('Genkit flow returned an empty result field.');
    }
    return result;
  }
}

// lib/data/litert_edge_engine.dart
import 'dart:async';
import '../domain/ai_models.dart';

/// Signature for invoking the native C++ LiteRT-LM session via `flutter_gemma`.
typedef LiteRtNativeInvoker = Future<String> Function(String prompt);

/// Tier 3 Engine: 100% Offline On-Device Inference via LiteRT-LM (`flutter_gemma`).
///
/// Guarantees:
/// 1. Strict mutex serialization so two concurrent UI requests never collide
///    inside the native C++ MediaPipe / LiteRT-LM session.
/// 2. Deadlock recovery timeout so a stalled native session releases the lock.
/// 3. Zero-RAM deterministic fallback on ultra-low-memory devices (<2GB RAM).
class LiteRtEdgeEngine implements AiEngineGateway {
  LiteRtEdgeEngine({
    LiteRtNativeInvoker? nativeInvoker,
    this.lockTimeout = const Duration(seconds: 25),
  }) : _nativeInvoker = nativeInvoker ?? _defaultSimulatedLiteRtInvoker;

  final LiteRtNativeInvoker _nativeInvoker;
  final Duration lockTimeout;
  Completer<void>? _activeLock;

  @override
  AiExecutionTier get tier => AiExecutionTier.edgeLiteRt;

  @override
  Future<String> generate({
    required String prompt,
    Map<String, Object?> metadata = const {},
  }) async {
    final availableRamMb = (metadata['availableRamMb'] as int?) ?? 4096;
    if (availableRamMb < 2048) {
      return _deterministicLowRamFallback(prompt);
    }

    return _runLocked<String>(() async {
      final formattedPrompt =
          '<start_of_turn>user\n${prompt.trim()}<end_of_turn>\n'
          '<start_of_turn>model\n';
      return _nativeInvoker(formattedPrompt);
    });
  }

  Future<T> _runLocked<T>(Future<T> Function() action) async {
    while (_activeLock != null) {
      try {
        await _activeLock!.future.timeout(lockTimeout);
      } on TimeoutException {
        // Recover from a stalled FFI session after Hot Restart or native hang.
        _activeLock = null;
        break;
      }
    }

    final completer = Completer<void>();
    _activeLock = completer;

    try {
      return await action();
    } finally {
      _activeLock = null;
      if (!completer.isCompleted) {
        completer.complete();
      }
    }
  }

  String _deterministicLowRamFallback(String prompt) {
    return '[LiteRT-LM Safe Mode | <2GB RAM Guard] Device memory is critically '
        'low. Returning deterministic local ruleset summary for: "${prompt.trim()}"';
  }

  static Future<String> _defaultSimulatedLiteRtInvoker(
    String formattedPrompt,
  ) async {
    await Future<void>.delayed(const Duration(milliseconds: 190));
    final clean = formattedPrompt
        .replaceAll('<start_of_turn>user\n', '')
        .replaceAll('<end_of_turn>\n<start_of_turn>model\n', '');
    return '[LiteRT-LM On-Device | gemma-3n-E2B-it-int4] 100% offline inference '
        '(0 bytes network egress, \$0.00 token cost): "$clean"';
  }
}

// lib/application/smart_hybrid_ai_router.dart
import '../domain/ai_models.dart';

/// Evaluates runtime constraints (connectivity, PII sensitivity, server authority,
/// and hardware limits) to dispatch requests across Cloud, Server, and Edge AI.
class SmartHybridAiRouter {
  const SmartHybridAiRouter({
    required AiEngineGateway cloudEngine,
    required AiEngineGateway serverEngine,
    required AiEngineGateway edgeEngine,
  })  : _cloudEngine = cloudEngine,
        _serverEngine = serverEngine,
        _edgeEngine = edgeEngine;

  final AiEngineGateway _cloudEngine;
  final AiEngineGateway _serverEngine;
  final AiEngineGateway _edgeEngine;

  /// Selects the target tier and reason before executing inference.
  (AiEngineGateway, String) selectTargetEngine(RoutingContext context) {
    // Rule 1: Strict PII or confidential local notes NEVER leave the device.
    if (context.sensitivity == TaskSensitivity.strictLocalPii) {
      return (
        _edgeEngine,
        'Strict PII policy: zero network egress enforced via on-device LiteRT-LM.',
      );
    }

    // Rule 2: Privileged tools, billing quotas, or state mutations require Server authority.
    if (context.requiresPrivilegedServerTool ||
        context.sensitivity == TaskSensitivity.privilegedTransactional) {
      if (!context.isOnline) {
        return (
          _edgeEngine,
          'Offline during privileged request: queued transaction & serving local LiteRT-LM guidance.',
        );
      }
      return (
        _serverEngine,
        'Server-Side Security Invariant: routed to Genkit Dart backend for privileged tool execution.',
      );
    }

    // Rule 3: Offline mode routes immediately to on-device LiteRT-LM.
    if (!context.isOnline) {
      return (
        _edgeEngine,
        'Device is offline: routed to local LiteRT-LM INT4 engine (\$0.00 token cost).',
      );
    }

    // Rule 4: Online + Multimodal attachment -> Firebase AI Logic.
    if (context.hasMultimodalAttachment) {
      return (
        _cloudEngine,
        'Online multimodal input: routed to Firebase AI Logic (gemini-flash-latest + App Check).',
      );
    }

    // Rule 5: Short, routine prompts on capable devices (>=4GB RAM) run locally to save cloud quota.
    if (context.prompt.length < 160 && context.availableRamMb >= 4096) {
      return (
        _edgeEngine,
        'Cost optimization: short prompt on 4GB+ RAM device offloaded to local LiteRT-LM.',
      );
    }

    return (
      _cloudEngine,
      'Online complex synthesis: routed to Firebase AI Logic (gemini-flash-latest).',
    );
  }

  /// Dispatches the prompt and automatically falls back to LiteRT-LM on network failure.
  Future<AiInferenceResponse> routeAndExecute(RoutingContext context) async {
    final stopwatch = Stopwatch()..start();
    final (primaryEngine, reason) = selectTargetEngine(context);

    try {
      final output = await primaryEngine.generate(
        prompt: context.prompt,
        metadata: <String, Object?>{
          'availableRamMb': context.availableRamMb,
          'hasMultimodalAttachment': context.hasMultimodalAttachment,
        },
      );
      stopwatch.stop();

      return AiInferenceResponse(
        text: output,
        telemetry: RoutingTelemetry(
          selectedTier: primaryEngine.tier,
          routingReason: reason,
          latencyMs: stopwatch.elapsedMilliseconds,
        ),
      );
    } catch (cloudOrServerError) {
      // If the primary engine was Cloud or Server and failed due to flaky network,
      // transparently fall back to on-device LiteRT-LM so UX never breaks.
      if (primaryEngine.tier != AiExecutionTier.edgeLiteRt) {
        final fallbackOutput = await _edgeEngine.generate(
          prompt: context.prompt,
          metadata: <String, Object?>{
            'availableRamMb': context.availableRamMb,
          },
        );
        stopwatch.stop();

        return AiInferenceResponse(
          text: fallbackOutput,
          telemetry: RoutingTelemetry(
            selectedTier: AiExecutionTier.edgeLiteRt,
            routingReason:
                'Automatic Edge Fallback after ${primaryEngine.tier.label} error: $cloudOrServerError',
            latencyMs: stopwatch.elapsedMilliseconds,
            didFallbackToEdge: true,
          ),
        );
      }
      rethrow;
    }
  }
}

// lib/main.dart
import 'package:flutter/material.dart';
import 'application/smart_hybrid_ai_router.dart';
import 'data/firebase_ai_cloud_engine.dart';
import 'data/genkit_server_engine.dart';
import 'data/litert_edge_engine.dart';
import 'domain/ai_models.dart';

void main() {
  runApp(const HybridAiCodelabApp());
}

class HybridAiCodelabApp extends StatelessWidget {
  const HybridAiCodelabApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Hybrid AI Router Codelab',
      debugShowCheckedModeBanner: false,
      theme: ThemeData.dark(useMaterial3: true).copyWith(
        scaffoldBackgroundColor: const Color(0xFF070A13),
        colorScheme: const ColorScheme.dark(
          primary: Color(0xFF00B0FF),
          secondary: Color(0xFF02569B),
          surface: Color(0xFF0F1424),
        ),
      ),
      home: const HybridRouterConsoleScreen(),
    );
  }
}

class HybridRouterConsoleScreen extends StatefulWidget {
  const HybridRouterConsoleScreen({super.key});

  @override
  State<HybridRouterConsoleScreen> createState() =>
      _HybridRouterConsoleScreenState();
}

class _HybridRouterConsoleScreenState extends State<HybridRouterConsoleScreen> {
  late final SmartHybridAiRouter _router;
  final TextEditingController _promptController = TextEditingController(
    text: 'Summarize field inspection metrics and recommend next action.',
  );

  bool _isOnline = true;
  bool _containsStrictPii = false;
  bool _requiresPrivilegedServerTool = false;
  bool _hasMultimodalAttachment = false;
  int _availableRamMb = 4096;
  bool _isBusy = false;
  AiInferenceResponse? _lastResponse;

  @override
  void initState() {
    super.initState();
    _router = SmartHybridAiRouter(
      cloudEngine: FirebaseAiCloudEngine(),
      serverEngine: GenkitServerEngine(
        flowEndpoint: Uri.parse('https://api.example.com/privilegedQuotaAgentFlow'),
        idTokenProvider: () async => 'demo-firebase-id-token',
      ),
      edgeEngine: LiteRtEdgeEngine(),
    );
  }

  @override
  void dispose() {
    _promptController.dispose();
    super.dispose();
  }

  Future<void> _dispatchPrompt() async {
    setState(() => _isBusy = true);
    try {
      final contextModel = RoutingContext(
        prompt: _promptController.text,
        isOnline: _isOnline,
        sensitivity: _containsStrictPii
            ? TaskSensitivity.strictLocalPii
            : (_requiresPrivilegedServerTool
                ? TaskSensitivity.privilegedTransactional
                : TaskSensitivity.publicGeneral),
        requiresPrivilegedServerTool: _requiresPrivilegedServerTool,
        hasMultimodalAttachment: _hasMultimodalAttachment,
        availableRamMb: _availableRamMb,
      );

      final result = await _router.routeAndExecute(contextModel);
      setState(() => _lastResponse = result);
    } finally {
      setState(() => _isBusy = false);
    }
  }

  @override
  Widget build(BuildContext context) {
    final telemetry = _lastResponse?.telemetry;
    return Scaffold(
      appBar: AppBar(
        title: const Text('Hybrid AI Smart Router Console'),
        backgroundColor: const Color(0xFF0F1424),
      ),
      body: ListView(
        padding: const EdgeInsets.all(16),
        children: [
          SwitchListTile(
            title: const Text('Network Connectivity (Online)'),
            subtitle: const Text('Disable to simulate rural offline / Airplane mode'),
            value: _isOnline,
            onChanged: (v) => setState(() => _isOnline = v),
          ),
          SwitchListTile(
            title: const Text('Strict Local PII / Confidential Notes'),
            subtitle: const Text('Forces zero-egress on-device LiteRT-LM execution'),
            value: _containsStrictPii,
            onChanged: (v) => setState(() => _containsStrictPii = v),
          ),
          SwitchListTile(
            title: const Text('Privileged Server Tool (Billing / Quota / DB)'),
            subtitle: const Text('Enforces Genkit Dart Server-Side Security Invariant'),
            value: _requiresPrivilegedServerTool,
            onChanged: (v) => setState(() => _requiresPrivilegedServerTool = v),
          ),
          SwitchListTile(
            title: const Text('High-Res Multimodal Attachment'),
            subtitle: const Text('Routes online media to Firebase AI Logic (gemini-flash-latest)'),
            value: _hasMultimodalAttachment,
            onChanged: (v) => setState(() => _hasMultimodalAttachment = v),
          ),
          ListTile(
            title: Text('Simulated Device RAM: $_availableRamMb MB'),
            subtitle: Slider(
              min: 1536,
              max: 8192,
              divisions: 13,
              value: _availableRamMb.toDouble(),
              onChanged: (v) => setState(() => _availableRamMb = v.round()),
            ),
          ),
          const SizedBox(height: 8),
          TextField(
            controller: _promptController,
            maxLines: 3,
            decoration: const InputDecoration(
              labelText: 'Prompt Payload',
              border: OutlineInputBorder(),
            ),
          ),
          const SizedBox(height: 12),
          FilledButton(
            onPressed: _isBusy ? null : _dispatchPrompt,
            child: Text(_isBusy ? 'Routing & Executing...' : 'Route & Execute Prompt'),
          ),
          if (telemetry != null) ...[
            const SizedBox(height: 20),
            Container(
              padding: const EdgeInsets.all(16),
              decoration: BoxDecoration(
                color: const Color(0xFF171D32),
                border: Border.all(color: const Color(0xFF00B0FF)),
                borderRadius: BorderRadius.circular(12),
              ),
              child: Column(
                crossAxisAlignment: CrossAxisAlignment.start,
                children: [
                  Text(
                    'Selected Tier: ${telemetry.selectedTier.label}',
                    style: const TextStyle(
                      fontWeight: FontWeight.bold,
                      fontSize: 16,
                      color: Color(0xFF00B0FF),
                    ),
                  ),
                  const SizedBox(height: 6),
                  Text('Model ID: ${telemetry.selectedTier.modelId}'),
                  Text('Latency: ${telemetry.latencyMs} ms'),
                  Text('Reason: ${telemetry.routingReason}'),
                  const Divider(height: 24),
                  SelectableText(_lastResponse!.text),
                ],
              ),
            ),
          ],
        ],
      ),
    );
  }
}

// test/smart_hybrid_ai_router_test.dart
import 'package:test/test.dart';
import 'package:hybrid_ai_router_codelab/application/smart_hybrid_ai_router.dart';
import 'package:hybrid_ai_router_codelab/data/firebase_ai_cloud_engine.dart';
import 'package:hybrid_ai_router_codelab/data/genkit_server_engine.dart';
import 'package:hybrid_ai_router_codelab/data/litert_edge_engine.dart';
import 'package:hybrid_ai_router_codelab/domain/ai_models.dart';

void main() {
  late SmartHybridAiRouter router;

  setUp(() {
    router = SmartHybridAiRouter(
      cloudEngine: FirebaseAiCloudEngine(),
      serverEngine: GenkitServerEngine(
        flowEndpoint: Uri.parse('https://api.example.com/verifyQuotaFlow'),
        idTokenProvider: () async => 'mock-firebase-id-token',
      ),
      edgeEngine: LiteRtEdgeEngine(),
    );
  });

  test('Routes strict PII prompts exclusively to on-device LiteRT-LM', () async {
    final res = await router.routeAndExecute(
      const RoutingContext(
        prompt: 'Summarize patient medical record #9482.',
        isOnline: true,
        sensitivity: TaskSensitivity.strictLocalPii,
      ),
    );
    expect(res.telemetry.selectedTier, equals(AiExecutionTier.edgeLiteRt));
    expect(res.telemetry.didFallbackToEdge, isFalse);
  });

  test('Routes privileged tool requests to Genkit Dart Server when online', () async {
    final res = await router.routeAndExecute(
      const RoutingContext(
        prompt: 'Upgrade organization subscription tier and issue invoice.',
        isOnline: true,
        requiresPrivilegedServerTool: true,
      ),
    );
    expect(res.telemetry.selectedTier, equals(AiExecutionTier.serverGenkitAgent));
  });

  test('Falls back to LiteRT-LM automatically when Cloud engine throws', () async {
    final failingRouter = SmartHybridAiRouter(
      cloudEngine: FirebaseAiCloudEngine(
        invoker: (_, _, _) async => throw Exception('Network socket closed'),
      ),
      serverEngine: GenkitServerEngine(
        flowEndpoint: Uri.parse('https://api.example.com/verifyQuotaFlow'),
        idTokenProvider: () async => 'mock-firebase-id-token',
      ),
      edgeEngine: LiteRtEdgeEngine(),
    );

    final res = await failingRouter.routeAndExecute(
      const RoutingContext(
        prompt: 'Analyze this detailed multi-paragraph architectural specification '
            'and compare all latency trade-offs across regions and mobile carriers '
            'with full token budget breakdowns for 10,000 daily active users.',
        isOnline: true,
      ),
    );

    expect(res.telemetry.selectedTier, equals(AiExecutionTier.edgeLiteRt));
    expect(res.telemetry.didFallbackToEdge, isTrue);
  });
}

flutter pub get
dart analyze
flutter test
flutter run