defineRemoteAction<I, O, S, Init> function

RemoteAction<I, O, S, Init> defineRemoteAction<I, O, S, Init>({
  1. required String url,
  2. Map<String, String>? defaultHeaders,
  3. Client? httpClient,
  4. O fromResponse(
    1. dynamic jsonData
    )?,
  5. S fromStreamChunk(
    1. dynamic jsonData
    )?,
  6. JsonExtensionType<I>? inputType,
  7. JsonExtensionType<O>? outputType,
  8. JsonExtensionType<S>? streamType,
})

Defines a remote Genkit action (flow) client.

This function returns a RemoteAction instance, which can be used to call or stream the specified Genkit flow. It simplifies the process of setting up a flow client by allowing direct specification of data conversion functions.

Type parameters:

  • O: The type of the output data from a non-streaming flow invocation, or the type of the final response from a streaming flow.
  • S: The type of the data chunks streamed from the flow.

Parameters:

  • url: The absolute URL of the Genkit flow.
  • defaultHeaders: Optional default HTTP headers to be sent with every request.
  • httpClient: Optional http.Client instance. If not provided, a new one will be created and managed by the RemoteAction. If provided, the caller is responsible for its lifecycle (e.g., closing it).
  • fromResponse: An optional function that converts the JSON-decoded response data (typically a Map<String, dynamic> or primitive type from jsonDecode) into the expected output type O. If not provided, the result is a dynamic object from jsonDecode.
  • fromStreamChunk: An optional function that converts the JSON-decoded stream chunk data into the expected stream type S. If not provided, chunks are dynamic objects from jsonDecode.

Returns a RemoteAction<O, S> instance.

Implementation

RemoteAction<I, O, S, Init> defineRemoteAction<I, O, S, Init>({
  required String url,
  Map<String, String>? defaultHeaders,
  http.Client? httpClient,
  O Function(dynamic jsonData)? fromResponse,
  S Function(dynamic jsonData)? fromStreamChunk,
  JsonExtensionType<I>? inputType,
  JsonExtensionType<O>? outputType,
  JsonExtensionType<S>? streamType,
}) {
  if (fromResponse != null && outputType != null) {
    throw ArgumentError(
      'Cannot provide both fromResponse and outputType. Please provide only one.',
    );
  }
  if (fromStreamChunk != null && streamType != null) {
    throw ArgumentError(
      'Cannot provide both fromStreamChunk and streamType. Please provide only one.',
    );
  }

  return RemoteAction<I, O, S, Init>(
    url: url,
    defaultHeaders: defaultHeaders,
    httpClient: httpClient,
    fromResponse:
        fromResponse ??
        (outputType != null ? (d) => outputType.parse(d) : (d) => d as O),
    fromStreamChunk:
        fromStreamChunk ??
        (streamType != null ? (d) => streamType.parse(d) : (d) => d as S),
  );
}