ChatGPT & OpenAI SDK for Flutter

May 20, 2026 · View on GitHub

A powerful, production-ready Dart and Flutter SDK for OpenAI's advanced APIs, supporting the latest generative models like GPT-5, GPT-5-mini, GPT-4o, GPT-4o-mini, DALL-E 3, and advanced reasoning models such as o1 and o3-mini.

Unofficial

"community-maintained” library.

OpenAI Powerful Library Supporting GPT-5, GPT-4o, GPT-4o-mini & o1/o3-mini Reasoning Models


GitHub commit activity GitHub contributors GitHub Repo stars GitHub Workflow Status GitHub Pub Points Pub Popularity Pub Likes Pub Version Code Coverage


Features

Install Package

chat_gpt_sdk: 3.1.6

Create OpenAI Instance

  • Parameter
    • Token
      • Your secret API keys are listed below. Please note that we do not display your secret API keys again after you generate them.
      • Do not share your API key with others, or expose it in the browser or other client-side code. In order to protect the security of your account, OpenAI may also automatically rotate any API key that we've found has leaked publicly.
      • https://beta.openai.com/account/api-keys
  • OrgId 
final openAI = OpenAI.instance.build(token: token,baseOption: HttpSetup(receiveTimeout: const Duration(seconds: 5)),enableLog: true);

Change Access Token

openAI.setToken('new-access-token');
///get token
openAI.token;

Complete Text

  • Text Complete API

    • Translate Method
      • translateEngToThai
      • translateThaiToEng
      • translateToJapanese
    • Model
      • kTranslateModelV3
      • kTranslateModelV2
      • kCodeTranslateModelV2
        • Translate natural language to SQL queries.
        • Create code to call the Stripe API using natural language.
        • Find the time complexity of a function.
    • https://beta.openai.com/examples

  • Complete with Feature

  void _translateEngToThai() async{
  final request = CompleteText(
          prompt: translateEngToThai(word: _txtWord.text.toString()),
          maxToken: 200,
          model: TextDavinci3Model());

  final response = await openAI.onCompletion(request: request);
  
  ///cancel request
  openAI.cancelAIGenerate();
  print(response);
}
  • Complete with FutureBuilder
Future<CTResponse?>? _translateFuture;

_translateFuture = openAI.onCompletion(request: request);

///ui code
FutureBuilder<CTResponse?>(
 future: _translateFuture,
 builder: (context, snapshot) {
   final data = snapshot.data;
   if(snapshot.connectionState == ConnectionState.done) return something 
   if(snapshot.connectionState == ConnectionState.waiting) return something
   return something
})

 void completeWithSSE() {
  final request = CompleteText(
          prompt: "Hello world", maxTokens: 200, model: TextDavinci3Model());
  openAI.onCompletionSSE(request: request).listen((it) {
    debugPrint(it.choices.last.text);
  });
}

Chat Complete (GPT-5, GPT-4o, GPT-4o-mini, and Reasoning Models)

  void chatComplete() async {
    final request = ChatCompleteText(
      messages: [
        Map.of({"role": "user", "content": 'Hello!'})
      ], 
      maxToken: 200, 
      model: Gpt4oMiniChatModel(),
    );

    final response = await openAI.onChatCompletion(request: request);
    for (var element in response!.choices) {
      print("data -> ${element.message?.content}");
    }
  }

 void chatCompleteWithSSE() {
  final request = ChatCompleteText(
    messages: [
      Map.of({"role": "user", "content": 'Explain photosynthesis in one sentence.'})
    ], 
    maxToken: 200, 
    model: Gpt4OChatModel(),
  );

  openAI.onChatCompletionSSE(request: request).listen((it) {
    debugPrint(it.choices.last.message?.content);
  });
}

  void gptFunctionCalling() async {
    final request = ChatCompleteText(
      messages: [
        Messages(
                role: Role.user,
                content: "What is the weather like in Boston?",
                name: "get_current_weather"),
      ],
      maxToken: 200,
      model: Gpt4oMiniChatModel(),
      tools: [
        {
          "type": "function",
          "function": {
            "name": "get_current_weather",
            "description": "Get the current weather in a given location",
            "strict": true, // Enable Structured Outputs for tool
            "parameters": {
              "type": "object",
              "properties": {
                "location": {
                  "type": "string",
                  "description": "The city and state, e.g. San Francisco, CA"
                },
                "unit": {
                  "type": "string",
                  "enum": ["celsius", "fahrenheit"]
                }
              },
              "required": ["location", "unit"], // Must require all properties when strict is true
              "additionalProperties": false    // Must be false for Structured Outputs
            }
          }
        }
      ],
      toolChoice: 'auto',
    );

    ChatCTResponse? response = await openAI.onChatCompletion(request: request);
}

Support for OpenAI's latest reasoning models (o1, o1-preview, o1-mini, o3-mini) and their specialized API parameters:

  • reasoningEffort: Controls how much thinking time the model uses ("low", "medium", "high").
  • maxCompletionTokens: The preferred token limit parameter for reasoning and generation in newer models. Set maxToken to null to let maxCompletionTokens govern.
  void reasoningModelChat() async {
    final request = ChatCompleteText(
      model: O3MiniChatModel(), // or O1ChatModel(), O1MiniChatModel()
      messages: [
        Map.of({"role": "user", "content": 'Write a quicksort algorithm in Dart'})
      ],
      temperature: 1.0, // Reasoning models support temperature 1.0
      maxToken: null, // Set maxToken to null to let maxCompletionTokens govern
      reasoningEffort: 'medium', // 'low' | 'medium' | 'high'
      maxCompletionTokens: 2000,
    );

    final response = await openAI.onChatCompletion(request: request);
    for (var element in response!.choices) {
      print("data -> ${element.message?.content}");
    }
    
    // Check total tokens used and reasoning details
    print("Total Tokens: ${response.usage?.totalTokens}");
    print("Prompt Tokens: ${response.usage?.promptTokens}");
    print("Completion Tokens: ${response.usage?.completionTokens}");
    print("Reasoning Tokens: ${response.usage?.completionTokensDetails?.reasoningTokens}");
  }

The SDK fully supports modern OpenAI API capabilities:

  • Role.developer / Role.tool: Direct support for the new developer-guided messages and tool execution responses.
  • store: Enable or disable storing chat completion outputs for training/evaluations (store: true).
  • metadata: Add key-value tags to keep track of requests (metadata: {"env": "production"}).
  • parallelToolCalls: Control if the model can trigger multiple functions in one turn (parallelToolCalls: false).
  • streamOptions: Request token usage statistics in the streaming chunks (streamOptions: {"include_usage": true}).
  void chatWithModernFeatures() async {
    final request = ChatCompleteText(
      model: Gpt4OChatModel(),
      messages: [
        Messages(
          role: Role.developer,
          content: 'You are an advanced software engineer.',
        ).toJson(),
        Messages(
          role: Role.user,
          content: 'What is the current system status?',
        ).toJson(),
      ],
      parallelToolCalls: false,
      store: true,
      metadata: {
        'customer_id': '12345',
        'env': 'production',
      },
      stream: true,
      streamOptions: {
        'include_usage': true,
      },
      maxToken: null,
    );

    openAI.onChatCompletionSSE(request: request).listen((it) {
      debugPrint(it.choices.last.message?.content);
      
      // When streamOptions is included, the last chunk will contain the usage stats
      if (it.usage != null) {
        print("Stream Total Tokens: ${it.usage?.totalTokens}");
        print("Stream Reasoning Tokens: ${it.usage?.completionTokensDetails?.reasoningTokens}");
      }
    });
  }

  void imageInput() async {
  final request = ChatCompleteText(
    messages: [
      {
        "role": "user",
        "content": [
          {"type": "text", "text": "What’s in this image?"},
          {
            "type": "image_url",
            "image_url": {"url": "image-url"}
          }
        ]
      }
    ],
    maxToken: 200,
    model: Gpt4OChatModel(),
  );

  ChatCTResponse? response = await openAI.onChatCompletion(request: request);
  debugPrint("$response");
}

Ensure the model's responses adhere strictly to your provided JSON schema. Use the type-safe ResponseFormat.jsonSchema(...) API:

  void structuredOutputExample() async {
    final request = ChatCompleteText(
      model: Gpt4OChatModel(),
      messages: [
        Map.of({"role": "user", "content": "Solve 2x + 5 = 15. Provide step-by-step reasoning."})
      ],
      // Supply a type-safe ResponseFormat configuration
      responseFormat: ResponseFormat.jsonSchema(
        jsonSchema: JsonSchema(
          name: "math_response",
          schema: {
            "type": "object",
            "properties": {
              "steps": {
                "type": "array",
                "items": {
                  "type": "object",
                  "properties": {
                    "explanation": {"type": "string"},
                    "output": {"type": "string"}
                  },
                  "required": ["explanation", "output"],
                  "additionalProperties": false
                }
              },
              "final_answer": {"type": "string"}
            },
            "required": ["steps", "final_answer"],
            "additionalProperties": false
          },
        ),
      ),
    );

    final response = await openAI.onChatCompletion(request: request);
    // The response content is guaranteed to match the exact schema structural layout
    print("Structured JSON: ${response?.choices.first.message?.content}");
  }


## Assistants
- ### Create Assistant
```dart
  void createAssistant() async {
  final assistant = Assistant(
    model: Gpt4oMiniModel(),
    name: 'Math Tutor',
    instructions:
    'You are a personal math tutor. When asked a question, write and run Python code to answer the question.',
    tools: [
      {
        "type": "code_interpreter",
      }
    ],
  );
  await openAI.assistant.create(assistant: assistant);
}


void createAssistantFile() async {
  await openAI.assistant.createFile(assistantId: '',fileId: '',);
}

  void listAssistant() async {
  final assistants = await openAI.assistant.list();
  assistants.map((e) => e.toJson()).forEach(print);
}

  void listAssistantFile() async {
  final assistants = await openAI.assistant.listFile(assistantId: '');
  assistants.data.map((e) => e.toJson()).forEach(print);
}

  void retrieveAssistant() async {
  final assistants = await openAI.assistant.retrieves(assistantId: '');
}

  void retrieveAssistantFiles() async {
  final assistants = await openAI.assistant.retrievesFile(assistantId: '',fileId: '');
}

  void modifyAssistant() async {
  final assistant = Assistant(
    model: Gpt4OModel(),
    instructions:
    'You are an HR bot, and you have access to files to answer employee questions about company policies. Always response with info from either of the files.',
    tools: [
      {
        "type": "retrieval",
      }
    ],
    fileIds: [
      "file-abc123",
      "file-abc456",
    ],
  );
  await openAI.assistant.modifies(assistantId: '', assistant: assistant);
}

  void deleteAssistant() async {
  await openAI.assistant.delete(assistantId: '');
}

  void deleteAssistantFile() async {
  await openAI.assistant.deleteFile(assistantId: '',fileId: '');
}

Threads

///empty body
  void createThreads()async {
  await openAI.threads.createThread(request: ThreadRequest());
}

///with message
void createThreads() async {
  final request = ThreadRequest(messages: [
    {
      "role": "user",
      "content": "Hello, what is AI?",
      "file_ids": ["file-abc123"]
    },
    {
      "role": "user",
      "content": "How does AI work? Explain it in simple terms."
    },
  ]);

  await openAI.threads.createThread(request: request);
}

 void retrieveThread()async {
  final mThread = await openAI.threads.retrieveThread(threadId: 'threadId');
}

  void modifyThread() async {
  await openAI.threads.modifyThread(threadId: 'threadId', metadata: {
    "metadata": {
      "modified": "true",
      "user": "abc123",
    },
  });
}

  void deleteThread() async {
  await openAI.threads.deleteThread(threadId: 'threadId');
}

Messages

void createMessage() async {
  final request = CreateMessage(
    role: 'user',
    content: 'How does AI work? Explain it in simple terms.',
  );
  await openAI.threads.messages.createMessage(
    threadId: 'threadId',
    request: request,
  );
}

  void listMessage()async {
  final mMessages = await openAI.threads.messages.listMessage(threadId: 'threadId');
}

  void listMessageFile() async {
  final mMessagesFile = await openAI.threads.messages.listMessageFile(
    threadId: 'threadId',
    messageId: '',
  );
}

  void retrieveMessage() async {
  final mMessage = await openAI.threads.messages.retrieveMessage(
    threadId: 'threadId',
    messageId: '',
  );
}

void retrieveMessageFile() async {
  final mMessageFile = await openAI.threads.messages.retrieveMessageFile(
    threadId: 'threadId',
    messageId: '',
    fileId: '',
  );
}

  void modifyMessage() async {
  await openAI.threads.messages.modifyMessage(
    threadId: 'threadId',
    messageId: 'messageId',
    metadata: {
      "metadata": {"modified": "true", "user": "abc123"},
    },
  );
}

Runs

void createRun() async {
    final request = CreateRun(assistantId: 'assistantId');
    await openAI.threads.runs.createRun(threadId: 'threadId', request: request);
  }

  void createThreadAndRun() async {
    final request = CreateThreadAndRun(assistantId: 'assistantId', thread: {
      "messages": [
        {"role": "user", "content": "Explain deep learning to a 5 year old."}
      ],
    });
    await openAI.threads.runs.createThreadAndRun(request: request);
  }

 void listRuns() async {
   final mRuns = await openAI.threads.runs.listRuns(threadId: 'threadId');
  }

void listRunSteps() async {
   final mRunSteps = await openAI.threads.runs.listRunSteps(threadId: 'threadId',runId: '',);
  }

void retrieveRun() async {
   final mRun = await openAI.threads.runs.retrieveRun(threadId: 'threadId',runId: '',);
  }

 void retrieveRunStep() async {
   final mRun = await openAI.threads.runs.retrieveRunStep(threadId: 'threadId',runId: '',stepId: '');
  }

void modifyRun() async {
    await openAI.threads.runs.modifyRun(
      threadId: 'threadId',
      runId: '',
      metadata: {
        "metadata": {"user_id": "user_abc123"},
      },
    );
  }

  void submitToolOutputsToRun() async {
    await openAI.threads.runs.submitToolOutputsToRun(
      threadId: 'threadId',
      runId: '',
      toolOutputs: [
        {
          "tool_call_id": "call_abc123",
          "output": "28C",
        },
      ],
    );
  }

  void cancelRun() async {
    await openAI.threads.runs.cancelRun(
      threadId: 'threadId',
      runId: '',
    );
  }

Error Handle

///using catchError
 openAI.onCompletion(request: request)
    .catchError((err){
      if(err is OpenAIAuthError){
        print('OpenAIAuthError error ${err.data?.error?.toMap()}');
      }
      if(err is OpenAIRateLimitError){
        print('OpenAIRateLimitError error ${err.data?.error?.toMap()}');
      }
      if(err is OpenAIServerError){
        print('OpenAIServerError error ${err.data?.error?.toMap()}');
      }
      });

///using try catch
 try {
   await openAI.onCompletion(request: request);
 } on OpenAIRateLimitError catch (err) {
   print('catch error ->${err.data?.error?.toMap()}');
 }

///with stream
 openAI
        .onCompletionSSE(request: request)
        .transform(StreamTransformer.fromHandlers(
          handleError: (error, stackTrace, sink) {
              if (error is OpenAIRateLimitError) {
              print('OpenAIRateLimitError error ->${error.data?.message}');
              }}))
        .listen((event) {
          print("success");
        });

Q&A

  • Example Q&A
    • Answer questions based on existing knowledge.
final request = CompleteText(prompt:'What is human life expectancy in the United States?'),
                model: TextDavinci3Model(), maxTokens: 200);

 final response = await openAI.onCompletion(request:request);
  • Request
Q: What is human life expectancy in the United States?
  • Response
A: Human life expectancy in the United States is 78 years.

Generate Image With Prompt

  • Generate Image

    • prompt
      • A text description of the desired image(s). The maximum length is 1000 characters.
    • n
      • The number of images to generate. Must be between 1 and 10.
    • size
      • The size of the generated images. Must be one of 256x256, 512x512, or 1024x1024.
    • response_format
      • The format in which the generated images are returned. Must be one of url or b64_json.
    • user
      • A unique identifier representing your end-user, which can help OpenAI to monitor and detect abuse.

  • Generate with feature

  void _generateImage() {
  const prompt = "cat eating snake blue red.";

  final request = GenerateImage( model: DallE2(),prompt, 1,size: ImageSize.size256,
          responseFormat: Format.url);
  final response = openAI.generateImage(request);
  print("img url :${response.data?.last?.url}");
}

Edit

void editPrompt() async {
    final response = await openAI.editor.prompt(EditRequest(
        model: CodeEditModel(),
        input: 'What day of the wek is it?',
        instruction: 'Fix the spelling mistakes'));

    print(response.choices.last.text);
  }

 void editImage() async {
  final response = await openAI.editor.editImage(EditImageRequest(
          image: FileInfo("${image?.path}", '${image?.name}'),
          mask: FileInfo('file path', 'file name'),
          size: ImageSize.size1024,
          prompt: 'King Snake'),
          model: DallE3(),);

  print(response.data?.last?.url);
}

  void variation() async {
  final request =
  Variation(model: DallE2(),image: FileInfo('${image?.path}', '${image?.name}'));
  final response = await openAI.editor.variation(request);

  print(response.data?.last?.url);
}

Cancel Generate

 _openAI
        .onChatCompletionSSE(request: request, onCancel: onCancel);

///CancelData
CancelData? mCancel;
void onCancel(CancelData cancelData) {
  mCancel = cancelData;
}

mCancel?.cancelToken.cancel("canceled ");

openAI.edit.editImage(request,onCancel: onCancel);

///CancelData
CancelData? mCancel;
void onCancel(CancelData cancelData) {
  mCancel = cancelData;
}

mCancel?.cancelToken.cancel("canceled edit image");

openAI.embed.embedding(request,onCancel: onCancel);

///CancelData
CancelData? mCancel;
void onCancel(CancelData cancelData) {
  mCancel = cancelData;
}

mCancel?.cancelToken.cancel("canceled embedding");
  • Stop Audio
    • translate
    • transcript
openAI.audio.transcribes(request,onCancel: onCancel);

///CancelData
CancelData? mCancel;
void onCancel(CancelData cancelData) {
  mCancel = cancelData;
}

mCancel?.cancelToken.cancel("canceled audio transcribes");
  • Stop File
    • upload file
    • get file
    • delete file
openAI.file.uploadFile(request,onCancel: onCancel);

///CancelData
CancelData? mCancel;
void onCancel(CancelData cancelData) {
  mCancel = cancelData;
}

mCancel?.cancelToken.cancel("canceled uploadFile");

File

void getFile() async {
  final response = await openAI.file.get();
  print(response.data);
}

void uploadFile() async {
  final request = UploadFile(file: FileInfo('file-path', 'file-name'),purpose: 'fine-tune');
  final response = await openAI.file.uploadFile(request);
  print(response);
}

  void delete() async {
  final response = await openAI.file.delete("file-Id");
  print(response);
}

  void retrieve() async {
  final response = await openAI.file.retrieve("file-Id");
  print(response);
}

  void retrieveContent() async {
  final response = await openAI.file.retrieveContent("file-Id");
  print(response);
}

Audio

void audioTranslate() async {
  final mAudio = File('mp3-path');
  final request =
  AudioRequest(file: FileInfo(mAudio.path, 'name'), prompt: '...');

  final response = await openAI.audio.translate(request);
}

void audioTranscribe() async {
  final mAudio = File('mp3-path');
  final request =
  AudioRequest(file: FileInfo(mAudio.path, 'name'), prompt: '...');

  final response = await openAI.audio.transcribes(request);
}

  void createSpeech() async {
  final request = SpeechRequest(
          model: 'tts-1', input: 'The quick brown fox jumped over the lazy dog.');

  final List<int> response = await openAI.audio
          .createSpeech(request: request);
}

Embedding

  • Embedding
void embedding() async {
  final request = EmbedRequest(
          model: TextSearchAdaDoc001EmbedModel(),
          input: 'The food was delicious and the waiter');

  final response = await openAI.embed.embedding(request);

  print(response.data.last.embedding);
}

Fine Tune

void createTineTune() async {
  final request = CreateFineTuneJob(trainingFile: 'The ID of an uploaded file');
  final response = await openAI.fineTune.createFineTuneJob(request);
}

 void tineTuneList() async {
    final response = await openAI.fineTune.listFineTuneJob();
  }

 void tineTuneListStream() {
    openAI.fineTune.listFineTuneJobStream('fineTuneId').listen((it) {
      ///handled data
    });
  }

void tineTuneById() async {
    final response = await openAI.fineTune.retrieveFineTuneJob('fineTuneId');
  }

  void tineTuneCancel() async {
    final response = await openAI.fineTune.cancelFineTuneJob('fineTuneId');
  }

Moderations

  void createModeration() async {
  final response = await openAI.moderation
          .create(input: 'input', model: TextLastModerationModel());
}

Prompt Caching

OpenAI automatically applies prompt caching for supported models. You can retrieve caching statistics from the usage data of chat completions:

  void checkPromptCaching() async {
    final request = ChatCompleteText(
      messages: [
        Map.of({"role": "user", "content": "Explain quantum computing in detail."})
      ],
      maxToken: 1000,
      model: Gpt4OChatModel(),
    );

    final response = await openAI.onChatCompletion(request: request);
    
    // Read total/cached tokens
    print("Total Prompt Tokens: ${response?.usage?.promptTokens}");
    print("Cached Tokens: ${response?.usage?.promptTokensDetails?.cachedTokens}");
  }

Audio Completions

You can now use Chat Completions with native support for audio input and output. Specify the desired audio output configurations and receive base64 encoded audio responses.

  void chatAudioCompletion() async {
    final request = ChatCompleteText(
      model: Gpt4OChatModel(),
      messages: [
        Map.of({"role": "user", "content": "Tell me a joke out loud."})
      ],
      // request both text and audio outputs
      modalities: ['text', 'audio'],
      audio: ChatAudioConfig(
        voice: 'alloy',
        format: 'wav',
      ),
    );

    final response = await openAI.onChatCompletion(request: request);
    for (var choice in response!.choices) {
      final message = choice.message;
      if (message != null) {
        print("Text response: ${message.content}");
        
        // Handle audio data output
        final audioData = message.audio;
        if (audioData != null) {
          print("Audio ID: ${audioData.id}");
          print("Audio Expires At: ${audioData.expiresAt}");
          print("Audio Data (Base64 WAV): ${audioData.data}");
          print("Audio Transcript: ${audioData.transcript}");
        }
      }
    }
  }

Project and Organization Management

Manage your projects, organizations, API limits, and user access programmatically.

Project Management

  void projectManagementExample() async {
    // 1. List Projects
    final listRes = await openAI.projectAndOrg.listProjects(limit: 10);
    print("Projects: ${listRes.data.map((p) => p.name).toList()}");

    // 2. Create a new project
    final newProject = await openAI.projectAndOrg.createProject(name: "New Flutter Dev Project");
    print("Created project ID: ${newProject.id}");

    // 3. Retrieve a specific project
    final proj = await openAI.projectAndOrg.retrieveProject(projectId: newProject.id);
    print("Retrieved project: ${proj.name}");

    // 4. Modify a project name
    final modifiedProj = await openAI.projectAndOrg.modifyProject(
      projectId: newProject.id, 
      name: "Updated Flutter Dev Project Name",
    );
    print("Updated project name: ${modifiedProj.name}");

    // 5. Archive a project
    final archivedProj = await openAI.projectAndOrg.archiveProject(projectId: newProject.id);
    print("Project archived status: ${archivedProj.status}");
  }

User Management

  void userManagementExample() async {
    // 1. List Organization Users
    final listUserRes = await openAI.projectAndOrg.listUsers(limit: 5);
    print("Users: ${listUserRes.data.map((u) => u.email).toList()}");

    // 2. Retrieve a specific user
    if (listUserRes.data.isNotEmpty) {
      final userId = listUserRes.data.first.id;
      final user = await openAI.projectAndOrg.retrieveUser(userId: userId);
      print("User Email: ${user.email}, Role: ${user.role}");

      // 3. Modify user role
      final modifiedUser = await openAI.projectAndOrg.modifyUserRole(
        userId: userId, 
        role: "admin", // "owner" | "admin" | "member"
      );
      print("New User Role: ${modifiedUser.role}");

      // 4. Remove/delete user from organization
      final deleteUserRes = await openAI.projectAndOrg.deleteUser(userId: userId);
      print("User deleted: ${deleteUserRes.deleted}");
    }
  }

Responses API

The Responses API (/v1/responses) is designed for advanced development, code generation, and complex unified reasoning workflows utilizing modern models (such as gpt-4o, gpt-4o-mini, o1, o3-mini, etc.). It lets you specify inputs, models, optional reasoning parameters, background tasks, and includes a flexible Polymorphic output structure.

Main Request Model: OpenAiResponseRequest

  • model: The model to use for this response (e.g., gpt-4o, o3-mini).
  • input: The input to the model. Can be a String (simple prompt) or a List of structured message objects (e.g. system, developer, user messages).
  • reasoning: Optional map defining reasoning configurations (e.g., {'effort': 'medium'}).
  • background: Run the model response in the background when set to true.
  • conversation: Optional unique conversation ID or object.
  • include: Optional list of additional data fields to return.
  • tools: A list of tools the model may call (e.g. [{"type": "web_search"}]).
  • toolChoice: Controls which (if any) tool is called by the model (e.g., 'auto').

Convenience Output Getter

The response model OpenAiResponseData has a convenience property outputText which automatically traverses nested output items and content parts to return the first generated text block (type == 'output_text').

Usage Example

void responsesApiExample() async {
  // 1. Simple Text Input
  final requestSimple = OpenAiResponseRequest(
    model: 'gpt-4o',
    input: 'Explain the theory of relativity in one simple sentence.',
    reasoning: {'effort': 'medium'},
  );

  final responseSimple = await openAI.onResponse(request: requestSimple);
  print("Response Output: ${responseSimple?.outputText}");

  // 2. Structured Messages Input (Developer instructions + User query)
  final requestMessages = OpenAiResponseRequest(
    model: 'gpt-4o',
    input: [
      {
        'role': 'developer',
        'content': 'You are a highly efficient software architect expert in Flutter and Dart.',
      },
      {
        'role': 'user',
        'content': 'Write a generic Repository interface in Dart.',
      }
    ],
  );

  final responseMessages = await openAI.onResponse(request: requestMessages);

  // Easily extract the main output text using the convenience getter:
  print("Generated Code:\n${responseMessages?.outputText}");

  // Access detailed usage metrics
  print("Total Tokens: ${responseMessages?.usage?.totalTokens}");
  print("Prompt Tokens: ${responseMessages?.usage?.promptTokens}");
  print("Completion Tokens: ${responseMessages?.usage?.completionTokens}");

  // 3. Unified Reasoning with Native Web Search
  final requestSearch = OpenAiResponseRequest(
    model: 'gpt-4o',
    input: 'Who won the UEFA Champions League this season?',
    tools: [
      {'type': 'web_search'}
    ],
    toolChoice: 'auto',
  );

  final responseSearch = await openAI.onResponse(request: requestSearch);
  print("Search Output:\n${responseSearch?.outputText}");
}

Model and Engine

final models = await openAI.listModel();

final engines = await openAI.listEngine();

Translate App

ChatGPT Demo App

Google Play

Video Tutorials

Docs (Support Thai)

ChatGPT Part 1 ChatGPT Part 2 ChatGPT Part 2