generate<C> function

Future<GenerateResponseHelper> generate<C>({
  1. String? prompt,
  2. List<Message>? messages,
  3. required Model<C> model,
  4. C? config,
  5. List<Tool>? tools,
  6. List<String>? toolNames,
  7. String? toolChoice,
  8. bool? returnToolRequests,
  9. int? maxTurns,
  10. SchemanticType? outputSchema,
  11. String? outputFormat,
  12. bool? outputConstrained,
  13. String? outputInstructions,
  14. bool? outputNoInstructions,
  15. String? outputContentType,
  16. Map<String, dynamic>? context,
  17. StreamingCallback<GenerateResponseChunk>? onChunk,
  18. List<GenerateMiddleware>? use,
  19. List<InterruptResponse>? interruptRespond,
  20. List<ToolRequestPart>? interruptRestart,
})

Implementation

Future<GenerateResponseHelper> generate<C>({
  String? prompt,
  List<Message>? messages,
  required Model<C> model,
  C? config,
  List<Tool>? tools,
  List<String>? toolNames,
  String? toolChoice,
  bool? returnToolRequests,
  int? maxTurns,
  SchemanticType? outputSchema,
  String? outputFormat,
  bool? outputConstrained,
  String? outputInstructions,
  bool? outputNoInstructions,
  String? outputContentType,
  Map<String, dynamic>? context,
  StreamingCallback<GenerateResponseChunk>? onChunk,
  List<GenerateMiddleware>? use,

  /// Optional data to resume an interrupted generation session.
  ///
  /// The list should contain [InterruptResponse]s for each interrupted tool request
  /// that is providing an explicit output reply.
  ///
  /// Example (providing a response):
  /// ```dart
  /// interruptRespond: [
  ///   InterruptResponse(interruptPart, 'User Answer')
  /// ]
  /// ```
  List<InterruptResponse>? interruptRespond,

  /// Optional list of tool requests to restart during an interrupted generation session.
  ///
  /// Restarts the execution of the specified tool part instead of providing a reply.
  /// Example:
  /// ```dart
  /// interruptRestart: [interruptPart]
  /// ```
  List<ToolRequestPart>? interruptRestart,
}) async {
  if (outputInstructions != null && outputNoInstructions == true) {
    throw ArgumentError(
      'Cannot set both outputInstructions and outputNoInstructions to true.',
    );
  }

  final registry = Registry();
  registry.register(model);
  tools?.forEach(registry.register);
  GenerateActionOutputConfig? outputConfig;
  if (outputSchema != null ||
      outputFormat != null ||
      outputConstrained != null ||
      outputInstructions != null ||
      outputNoInstructions != null ||
      outputContentType != null) {
    outputConfig = GenerateActionOutputConfig.fromJson({
      'format': ?outputFormat,
      if (outputSchema != null)
        'jsonSchema': outputSchema.jsonSchema as Map<String, dynamic>,
      'constrained': ?outputConstrained,
      'instructions': ?outputInstructions,
      'contentType': ?outputContentType,
      if (outputNoInstructions == true) 'instructions': false,
    });
  }
  return generateHelper(
    registry,
    prompt: prompt,
    messages: messages,
    model: model,
    config: config,
    tools: [...?tools?.map((t) => t.name), ...?toolNames],
    toolChoice: toolChoice,
    returnToolRequests: returnToolRequests,
    maxTurns: maxTurns,
    output: outputConfig,
    context: context,
    onChunk: onChunk,
    middleware: use
        ?.map((mw) => (middlewareInstance: mw, middlewareRef: null))
        .toList(),
    resume: interruptRespond,
    restart: interruptRestart,
  );
}