createEmbeddingModel method

@override Future<EmbeddingModel> createEmbeddingModel({ String? modelPath, String? tokenizerPath, PreferredBackend? preferredBackend, })

Creates and returns a new EmbeddingModel instance.

Modern API: If paths are not provided, uses the active embedding model set via FlutterGemma.installEmbedder() or modelManager.setActiveModel().

Legacy API: Provide explicit paths for backward compatibility.

modelPath — path to the embedding model file (optional if active model set). tokenizerPath — path to the tokenizer file (optional if active model set). preferredBackend — backend preference (e.g., CPU, GPU).

Implementation

@override
Future<EmbeddingModel> createEmbeddingModel({
  String? modelPath,
  String? tokenizerPath,
  PreferredBackend? preferredBackend,
}) async {
  // Check if active embedding model changed
  final currentActiveModel = _modelManager.activeEmbeddingModel;
  if (_initEmbeddingCompleter != null &&
      _initializedEmbeddingModel != null &&
      _lastActiveEmbeddingModelName != null) {
    final modelChanged = currentActiveModel == null ||
        currentActiveModel.name != _lastActiveEmbeddingModelName;
    if (modelChanged) {
      await _initializedEmbeddingModel?.close();
      _initEmbeddingCompleter = null;
      _initializedEmbeddingModel = null;
      _lastActiveEmbeddingModelName = null;
    } else {
      return _initEmbeddingCompleter!.future;
    }
  }

  // Return existing if initialization in progress
  if (_initEmbeddingCompleter case Completer<EmbeddingModel> completer) {
    return completer.future;
  }

  final completer = _initEmbeddingCompleter = Completer<EmbeddingModel>();

  try {
    // Resolve model and tokenizer paths from active embedding model
    if (modelPath == null || tokenizerPath == null) {
      final activeModel = _modelManager.activeEmbeddingModel;
      if (activeModel == null) {
        throw StateError(
          'No active embedding model set. '
          'Use `FlutterGemma.installEmbedder()` first.',
        );
      }

      final filePaths = await _modelManager.getModelFilePaths(activeModel);
      if (filePaths == null || filePaths.isEmpty) {
        throw StateError('Embedding model file paths not found');
      }

      modelPath ??= filePaths[PreferencesKeys.embeddingModelFile];
      tokenizerPath ??= filePaths[PreferencesKeys.embeddingTokenizerFile];
    }

    if (modelPath == null) {
      throw StateError('Embedding model path is required');
    }

    gemmaLog('[FlutterGemmaDesktop] Loading embedding model: $modelPath');

    if (tokenizerPath == null) {
      throw StateError('Tokenizer path is required for desktop embeddings');
    }
    if (preferredBackend == PreferredBackend.npu) {
      throw UnsupportedError(
        'PreferredBackend.npu is only supported on Android with .litertlm '
        'models; not available for desktop embeddings.',
      );
    }

    // The LiteRT embedding runtime moved to flutter_gemma_embeddings; core
    // resolves paths (preamble above) + owns the singleton lifecycle, then
    // dispatches construction through the EmbeddingRegistry. The backend
    // reads ONLY config.modelPath/config.tokenizerPath — it ignores the spec
    // arg for path resolution.
    final activeSpec =
        currentActiveModel is EmbeddingModelSpec ? currentActiveModel : null;
    final EmbeddingBackendProvider? backend = activeSpec != null
        ? EmbeddingRegistry.instance.findFor(activeSpec)
        : (EmbeddingRegistry.instance.registered.isNotEmpty
            ? EmbeddingRegistry.instance.registered.first
            : null);
    if (backend == null) {
      throw StateError(
        'No embedding backend registered. Add flutter_gemma_embeddings to '
        'pubspec.yaml and pass it in embeddingBackends: of '
        'FlutterGemma.initialize(...). Registered backends: '
        '${EmbeddingRegistry.instance.registered.map((b) => b.name).join(", ")}.',
      );
    }
    // modelPath/tokenizerPath are non-null here (resolved in the preamble).
    // maxTokens is unused by embeddings.
    final embConfig = RuntimeConfig(
      maxTokens: 0,
      modelPath: modelPath,
      tokenizerPath: tokenizerPath,
      preferredBackend: preferredBackend,
    );
    // The backend's createModel(spec, config) signature requires a non-null
    // spec, but it resolves paths exclusively from config. On the legacy
    // explicit-paths path there is no active spec, so synthesize one from the
    // resolved file paths (FileSource) purely to satisfy the signature.
    final specForBackend = activeSpec ??
        EmbeddingModelSpec(
          name: 'legacy:${path.basename(modelPath)}',
          modelSource: ModelSource.file(modelPath),
          tokenizerSource: ModelSource.file(tokenizerPath),
        );
    final model = await backend.createModel(specForBackend, embConfig);

    // Core owns the singleton lifecycle: track it + reset on close. The
    // package-built model fires this via CloseNotifier (addCloseListener).
    _initializedEmbeddingModel = model;
    model.addCloseListener(() {
      _initializedEmbeddingModel = null;
      _initEmbeddingCompleter = null;
      _lastActiveEmbeddingModelName = null;
    });

    _lastActiveEmbeddingModelName = currentActiveModel?.name;
    completer.complete(model);
    return model;
  } catch (e, st) {
    completer.completeError(e, st);
    _initEmbeddingCompleter = null;
    _initializedEmbeddingModel = null;
    _lastActiveEmbeddingModelName = null;
    rethrow;
  }
}