Flutter

dependencies:
  xybrid_flutter: ^0.1.0-beta5

import 'package:xybrid_flutter/xybrid_flutter.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await Xybrid.init();
  runApp(MyApp());
}

final model = await Xybrid.model('kokoro-82m').load();
final result = await model.run(XybridEnvelope.text('Hello world'));
print(result.text);

final model = await Xybrid.model('kokoro-82m').load();
final envelope = XybridEnvelope.text('Hello, how are you?', voiceId: 'af_heart');
final result = await model.run(envelope);

// Get WAV-wrapped audio bytes for playback
final wavBytes = result.audioAsWav(sampleRate: 24000);

final model = await Xybrid.model('whisper-tiny').load();
final envelope = XybridEnvelope.audio(bytes: audioBytes, sampleRate: 16000);
final result = await model.run(envelope);
print(result.text); // "Hello, how are you?"

final model = await Xybrid.model('gemma-3-1b').load();

final context = ConversationContext();
context.setSystem('You are a helpful assistant.');
context.pushText('Tell me a joke', MessageRole.user);

final envelope = XybridEnvelope.text('Tell me a joke');

await for (final token in model.runStreamingWithContext(envelope, context)) {
  stdout.write(token.token); // Print each token as it arrives
}

final loader = XybridModelLoader.fromRegistry('kokoro-82m');

await for (final event in loader.loadWithProgress()) {
  switch (event) {
    case LoadProgress(:final percentage):
      print('Loading: $percentage%');
    case LoadComplete():
      print('Model ready!');
    case LoadError(:final message):
      print('Error: $message');
  }
}

class Xybrid {
  static Future<void> init();
  static bool get isInitialized;
  static void setApiKey(String apiKey);

  static XybridModelLoader model(String modelId);
  static XybridPipeline pipeline({String? yaml, String? filePath});
}

class XybridModelLoader {
  factory XybridModelLoader.fromRegistry(String modelId);
  factory XybridModelLoader.fromBundle(String path);

  Future<XybridModel> load();
  Stream<LoadEvent> loadWithProgress();
}

class XybridModel {
  Future<XybridResult> run(XybridEnvelope envelope, {GenerationConfig? config});
  Future<XybridResult> runWithContext(XybridEnvelope envelope, ConversationContext context, {GenerationConfig? config});
  Stream<StreamToken> runStreaming(XybridEnvelope envelope, {GenerationConfig? config});
  Stream<StreamToken> runStreamingWithContext(XybridEnvelope envelope, ConversationContext context, {GenerationConfig? config});
}

class XybridEnvelope {
  factory XybridEnvelope.audio({
    required List<int> bytes,
    required int sampleRate,
    int channels = 1,
  });

  factory XybridEnvelope.text(String text, {String? voiceId, double? speed});
  factory XybridEnvelope.embedding(List<double> data);
  factory XybridEnvelope.textWithRole(String text, MessageRole role);

  XybridEnvelope withRole(MessageRole role);
}

class XybridResult {
  bool get success;
  String? get text;                  // ASR / LLM output
  Uint8List? get audioBytes;         // TTS output (raw PCM)
  List<double>? get embedding;       // Embedding output
  int get latencyMs;

  Uint8List? audioAsWav({int sampleRate = 24000, int channels = 1});
}

class StreamToken {
  final String token;            // Generated token text
  final int index;               // Token position
  final String cumulativeText;   // All text so far
  final bool isFinal;            // Last token in sequence
  final String? finishReason;    // "stop", "length", "error"
}

class ConversationContext {
  ConversationContext();
  ConversationContext.withId(String id);

  String get id;
  int get historyLength;
  bool get hasSystem;

  void setSystem(String text);
  void setMaxHistoryLength(int length);
  void push(XybridEnvelope envelope);
  void pushText(String text, MessageRole role);
  void clear();  // Clears history, keeps system prompt
}

enum MessageRole { system, user, assistant }

class XybridPipeline {
  factory XybridPipeline.fromYaml(String yaml);
  factory XybridPipeline.fromFile(String path);

  String? get name;
  int get stageCount;
  List<String> get stageNames;

  Future<XybridResult> run(XybridEnvelope envelope);
}

final yaml = '''
name: voice-assistant
stages:
  - whisper-tiny
  - gemma-3-1b
  - kokoro-82m
''';

final pipeline = XybridPipeline.fromYaml(yaml);
final result = await pipeline.run(
  XybridEnvelope.audio(bytes: audioBytes, sampleRate: 16000),
);
// Result is TTS audio from the final stage
final wav = result.audioAsWav();

class XybridException implements Exception {
  final String message;
}