Flutter & Dart

dart pub add openai_dart

import 'dart:convert';
import 'dart:io';

import 'package:openai_dart/openai_dart.dart';

/// Creates an openai_dart client that talks to DEVUP AI.
/// The key comes from the environment and is never written into source code.
OpenAIClient createClient() {
  final apiKey = Platform.environment['DEVUP_API_KEY'];
  if (apiKey == null || apiKey.isEmpty) {
    throw StateError('DEVUP_API_KEY is not set');
  }
  return OpenAIClient(
    config: OpenAIConfig(
      authProvider: ApiKeyProvider(apiKey),
      baseUrl: 'https://api.devupai.com/v1',
    ),
  );
}

/// Sends one message and returns the model's reply.
Future<String> chat(OpenAIClient client) async {
  final response = await client.chat.completions.create(
    ChatCompletionCreateRequest(
      model: 'deepseek-ai/DeepSeek-V4-Pro',
      messages: [ChatMessage.user('Reply with exactly: Salam DEVUP')],
    ),
  );
  return response.text ?? '';
}

/// Reads OPENAI_API_KEY and OPENAI_BASE_URL from the environment.
Future<String> chatFromEnvironment() async {
  final client = OpenAIClient.fromEnvironment();
  try {
    final response = await client.chat.completions.create(
      ChatCompletionCreateRequest(
        model: 'deepseek-ai/DeepSeek-V4-Pro',
        messages: [ChatMessage.user('Reply with exactly: Salam DEVUP')],
      ),
    );
    return response.text ?? '';
  } finally {
    client.close();
  }
}

/// Prints tokens as they arrive and returns the full text.
/// With includeUsage, token usage arrives once, in the final chunk.
Future<String> streamChat(OpenAIClient client) async {
  final stream = client.chat.completions.createStream(
    ChatCompletionCreateRequest(
      model: 'deepseek-ai/DeepSeek-V4-Pro',
      messages: [ChatMessage.user('Count from 1 to 5, separated by spaces.')],
      streamOptions: const StreamOptions(includeUsage: true),
    ),
  );

  final accumulator = ChatStreamAccumulator();
  await for (final event in stream) {
    accumulator.add(event);
    stdout.write(event.textDelta ?? '');
  }
  stdout.writeln();

  final usage = accumulator.usage;
  if (usage != null) {
    final promptTokens = usage.promptTokens;
    final completionTokens = usage.completionTokens;
    print('tokens: $promptTokens in, $completionTokens out');
  }
  return accumulator.content;
}

/// Stands in for a lookup in your own system.
String getOrderStatus(String orderId) => jsonEncode({
      'order_id': orderId,
      'status': 'shipped',
      'tracking_number': 'DZ-4471',
    });

/// Lets the model call get_order_status, runs it locally, sends the result
/// back, and returns the model's final answer.
Future<String> toolRoundTrip(OpenAIClient client) async {
  final tool = Tool.function(
    name: 'get_order_status',
    description: 'Look up the shipping status and tracking number of an order',
    parameters: const {
      'type': 'object',
      'properties': {
        'order_id': {'type': 'string'},
      },
      'required': ['order_id'],
    },
  );
  final messages = <ChatMessage>[
    ChatMessage.user('Where is my order 1042? Include its tracking number.'),
  ];

  final first = await client.chat.completions.create(
    ChatCompletionCreateRequest(
      model: 'deepseek-ai/DeepSeek-V4-Pro',
      messages: messages,
      tools: [tool],
    ),
  );
  if (!first.hasToolCalls) {
    throw StateError('The model answered without calling the tool');
  }

  // Every tool call must get a tool message back, including unknown ones.
  messages.add(ChatMessage.assistant(toolCalls: first.allToolCalls));
  for (final call in first.allToolCalls) {
    var result = '{"error":"unknown tool"}';
    if (call.function.name == 'get_order_status') {
      final args = jsonDecode(call.function.arguments) as Map<String, dynamic>;
      final orderId = args['order_id'] as String;
      print('get_order_status("$orderId")');
      result = getOrderStatus(orderId);
    }
    messages.add(ChatMessage.tool(toolCallId: call.id, content: result));
  }

  final second = await client.chat.completions.create(
    ChatCompletionCreateRequest(
      model: 'deepseek-ai/DeepSeek-V4-Pro',
      messages: messages,
      tools: [tool],
    ),
  );
  return second.text ?? '';
}

/// Asks for JSON that matches a strict schema and decodes it.
Future<Map<String, dynamic>> structuredOutput(OpenAIClient client) async {
  final response = await client.chat.completions.create(
    ChatCompletionCreateRequest(
      model: 'deepseek-ai/DeepSeek-V4-Pro',
      messages: [ChatMessage.user('What is the capital of Algeria?')],
      responseFormat: ResponseFormat.jsonSchema(
        name: 'capital',
        schema: const {
          'type': 'object',
          'properties': {
            'city': {'type': 'string'},
            'country': {'type': 'string'},
          },
          'required': ['city', 'country'],
          'additionalProperties': false,
        },
      ),
    ),
  );
  final text = response.text;
  if (text == null) {
    throw StateError('The response contained no text');
  }
  return jsonDecode(text) as Map<String, dynamic>;
}

/// Returns one vector per input, in input order.
Future<List<List<double>>> embed(OpenAIClient client, List<String> texts) async {
  final response = await client.embeddings.create(
    EmbeddingRequest(
      model: 'BAAI/bge-m3',
      input: EmbeddingInput.textList(texts),
    ),
  );
  final vectors = List<List<double>>.filled(texts.length, const <double>[]);
  for (final item in response.data) {
    if (item.index < 0 || item.index >= vectors.length) {
      throw StateError('Embedding index out of range');
    }
    vectors[item.index] = item.embedding;
  }
  return vectors;
}

/// Turns an error into a message you can act on.
/// By default the client retries 429 responses up to 3 times; chat
/// completions (POST) are not retried on 5xx, so a request is never repeated.
String explainError(Object error) {
  if (error is AuthenticationException) {
    return 'invalid or revoked API key (401)';
  }
  if (error is RateLimitException) {
    return 'rate limit reached, retry later (429)';
  }
  if (error is ApiException) {
    final code = error.statusCode;
    final message = error.message;
    return 'API error $code: $message';
  }
  return error.toString();
}

dart pub add dart_openai

import 'dart:io';

import 'package:dart_openai/dart_openai.dart';

/// Creates a dart_openai client for DEVUP AI.
/// dart_openai adds /v1 to the base URL itself, so the base URL has no /v1.
OpenAIClient createDartOpenAIClient() {
  final apiKey = Platform.environment['DEVUP_API_KEY'];
  if (apiKey == null || apiKey.isEmpty) {
    throw StateError('DEVUP_API_KEY is not set');
  }
  return OpenAIClient(apiKey: apiKey, baseUrl: 'https://api.devupai.com');
}

/// Sends one message and returns the model's reply.
Future<String> chatDartOpenAI(OpenAIClient client) async {
  final completion = await client.chat.create(
    model: 'deepseek-ai/DeepSeek-V4-Pro',
    messages: [
      OpenAIChatCompletionChoiceMessageModel.textContent(
        role: OpenAIChatMessageRole.user,
        text: 'Reply with exactly: Salam DEVUP',
      ),
    ],
  );
  final content = completion.choices.first.message.content ?? const [];
  return content.map((item) => item.text ?? '').join();
}

/// Prints tokens as they arrive and returns the full text.
Future<String> streamDartOpenAI(OpenAIClient client) async {
  final chunks = client.chat.createStream(
    model: 'deepseek-ai/DeepSeek-V4-Pro',
    messages: [
      OpenAIChatCompletionChoiceMessageModel.textContent(
        role: OpenAIChatMessageRole.user,
        text: 'Count from 1 to 5, separated by spaces.',
      ),
    ],
    streamOptions: const {'include_usage': true},
  );

  final text = StringBuffer();
  await for (final chunk in chunks) {
    for (final choice in chunk.choices) {
      for (final item in choice.delta.content ?? const []) {
        final piece = item?.text ?? '';
        stdout.write(piece);
        text.write(piece);
      }
    }
    final usage = chunk.usage;
    if (usage != null) {
      final promptTokens = usage.promptTokens;
      final completionTokens = usage.completionTokens;
      print('\ntokens: $promptTokens in, $completionTokens out');
    }
  }
  return text.toString();
}