cantrip 1.0.6

Cantrip API Client for Dart

example/cantrip_example.dart

import 'package:cantrip/cantrip.dart';

void mageServerside() async {
  // Create api client for mage
  MageClient client = MageClient("<mage api key>");

  // Get the mage object
  Mage mage = await client.mage;

  // Get the mana value
  int mana = mage.mana.toInt();

  // Create a spark
  Spark joe = await client.createSpark("joe");

  // Get the spark api key (to send to client for said spark)
  String joeApiKey = joe.apiKey;

  // Transfer 1000 mana to the spark "joe"
  await client.transferToSpark("joe", 1000);

  // Get the spark object (or update it in this case)
  joe = await client.getSpark("joe");

  // Get the mana value of the spark "joe"
  int joeMana = joe.mana.toInt();

  // Transfer 500 mana from the spark "joe" to the mage
  await client.transferFromSpark("joe", 500);

  // Create another spark
  Spark jane = await client.createSpark("jane");

  // Transfer 250 mana from joe to jane
  await client.transferSparkToSpark("joe", "jane", 250);

  // Destroy sparks (moves their mana back to owning mage)
  await client.deleteSpark("joe");
  await client.deleteSpark("jane");
}

void sparkClientside() async {
  // Create api client for spark
  SparkClient client = SparkClient("<spark api key>");

  // Get the spark object
  Spark spark = await client.spark;

  // Get the mana value
  int mana = spark.mana.toInt();
}

void clientOrServerSide() async {
  // Either MageClient or SparkClient can be used here
  CantripClient client =
      SparkClient("<spark api key>"); // Or MageClient("<mage api key>");

  // Get the model library from the server
  ModelLibrary lib = await client.modelLibrary;

  // Get the openai provider
  ModelProvider openai = lib.getProvider("openai");

  // Get the gpt-4o model
  Model gpt4o = openai.getModel("gpt-4o");

  // Scribe a simple request (maxTokens and temperature are optional)
  String answer = await client.scribe(
      model: gpt4o,
      provider: openai,
      prompt: "What is a cantrip?",
      maxTokens: 250,
      temperature: 0.75);

  // Get a scribe stream (...["A Can", "A Cantrip", "A Cantrip is a ]...)
  // You can also get the text deltas by setting deltaStream to true
  Stream<String> stream = client.scribeStream(
      model: gpt4o,
      provider: openai,
      prompt: "What is a cantrip?",
      maxTokens: 250,
      temperature: 0.75);

  // Chat with the model
  ChatRequest conversation = ChatRequest(
    messages: [
      ChatMessage(
        text: "You are a wizard! 🧙‍♂️",
        role: ChatRole.system,
      ),
      ChatMessage(
        text: "What is a cantrip?",
        role: ChatRole.user,
      ),
    ],
  );

  // Then add the response to the conversation
  conversation.messages.add(ChatMessage(
    text: await client.scribeChat(
      model: gpt4o,
      provider: openai,
      prompt: conversation,
    ),
    role: ChatRole.assistant,
  ));

  // You can also stream scribeChats as before
  Stream<ChatMessage> chatMessageStream = client
      .scribeChatStream(
        model: gpt4o,
        provider: openai,
        prompt: conversation,
      )
      .map((streamingMessage) => ChatMessage(
            text: streamingMessage,
            role: ChatRole.assistant,
          ));
}

// Actual implementation example test
void main() async {
  MageClient client = MageClient("mage(jxFfqSP8EMU6m62YiSvQfi78VcaPUhFS)");
  Mage mage = await client.mage;
  int itr = 10;
  print("Mage Mana: ${mage.mana}");

  Spark joe = await client.createSpark("joe$itr");
  print("+Joe: ${joe.toProto3Json()}");

  print("Transferring 1000 mana to Joe");
  await client.transferToSpark("joe$itr", 1000);
  joe = await client.getSpark("joe$itr");
  print("Joe Mana: ${joe.mana}");
  print("Mage Mana: ${await client.mana}");

  Spark jane = await client.createSpark("jane$itr");
  print("+Jane: ${jane.toProto3Json()}");
  print("Transferring 500 mana from Joe to Jane");
  await client.transferSparkToSpark("joe$itr", "jane$itr", 500);
  joe = await client.getSpark("joe$itr");
  jane = await client.getSpark("jane$itr");
  mage = await client.mage;
  print("Joe Mana: ${joe.mana}");
  print("Jane Mana: ${jane.mana}");
  print("Mage Mana: ${mage.mana}");

  print("Transferring 250 mana from Jane to Mage");
  await client.transferFromSpark("jane$itr", 250);
  jane = await client.getSpark("jane$itr");
  print("Jane Mana: ${jane.mana}");
  print("Destroying Jane");
  if (await client.deleteSpark("jane$itr")) {
    print("Jane has been destroyed");
  }
  mage = await client.mage;
  print("Mage Mana: ${mage.mana}");

  SparkClient joeClient = SparkClient(joe.apiKey);
  Spark joeSpark = await joeClient.spark;
  print("Joe Mana from spark client: ${joeSpark.mana}");

  // Could use client, or joeClient here
  ModelLibrary lib = await client.modelLibrary;
  print(lib.toProto3Json());

  ModelProvider openai = lib.getProvider("openai");
  print(openai.toProto3Json());

  Model gpt35t = openai.getModel("gpt-3.5-turbo");
  print(gpt35t.toProto3Json());

  String answer = await client.scribe(
      model: gpt35t,
      provider: openai,
      prompt: "What is a cantrip?",
      maxTokens: 250,
      temperature: 0.75);

  print("What is a cantrip?: $answer");

  print("=== Stream Test ===");

  ChatRequest conversation = ChatRequest(
    messages: [
      ChatMessage(
        text: "You are a wizard! 🧙‍♂️",
        role: ChatRole.system,
      ),
      ChatMessage(
        text: "What is a cantrip?",
        role: ChatRole.user,
      ),
    ],
  );

  Stream<ChatMessage> chatMessageStream = client
      .scribeChatStream(
        model: gpt35t,
        provider: openai,
        prompt: conversation,
      )
      .map((streamingMessage) => ChatMessage(
            text: streamingMessage,
            role: ChatRole.assistant,
          ));

  await for (ChatMessage message in chatMessageStream) {
    print(message.text);
  }
  print("===");
  print("Delta Test");
  Stream<String> stream = client.scribeStream(
      model: gpt35t,
      deltaStream: true,
      provider: openai,
      prompt: "What is a cantrip?",
      maxTokens: 250,
      temperature: 0.75);

  await for (String message in stream) {
    print(message);
  }
  print("===");

  await client.deleteSpark("joe$itr");
  print("Joe has been destroyed");
  print("Mage Mana: ${await client.mana}");
  print("Done");
}