Typed Output

final result = await agent.send(
  'The windy city in the US of A',
  outputSchema: Schema.fromMap({
    'type': 'object',
    'properties': {
      'city': {'type': 'string'},
    },
    'required': ['city'],
  }),
);

print(result.output); // {"city":"Chicago"}

final result = await agent.sendFor<Map<String, dynamic>>(
  'Name 3 colors that make you happy',
  outputSchema: Schema.fromMap({
    'type': 'object',
    'properties': {
      'colors': {
        'type': 'array',
        'items': {'type': 'string'},
      },
    },
    'required': ['colors'],
  }),
);

print(result.output['colors']); // ['sunshine yellow', 'ocean blue', 'grass green']

class Weather {
  final String city;
  final int temp;
  
  Weather.fromJson(Map<String, dynamic> json)
    : city = json['city'],
      temp = json['temp'];
}

final result = await agent.sendFor<Weather>(
  'How hot is it in the Big Apple right now?',
  outputSchema: Schema.fromMap({
    'type': 'object',
    'properties': {
      'city': {'type': 'string'},
      'temp': {'type': 'integer'},
    },
    'required': ['city', 'temp'],
  }),
  outputFromJson: Weather.fromJson,
);

print('${result.output.city}: ${result.output.temp}°F');

// Generate JSON serialization and JSON Schema from the same model.
@JsonSerializable(createJsonSchema: true)
class TownAndCountry {
  final String town;
  final String country;
  
  TownAndCountry({required this.town, required this.country});
  
  factory TownAndCountry.fromJson(Map<String, dynamic> json) =>
      _$TownAndCountryFromJson(json);
  
  static const schemaMap = _$TownAndCountryJsonSchema;
}

// now we pass the schema and JSON serialization to the agent and magic happens
final result = await agent.sendFor<TownAndCountry>(
  'What is the capital of France?',
  outputSchema: Schema.fromMap(TownAndCountry.schemaMap),
  outputFromJson: TownAndCountry.fromJson,
);

print('${result.output.town}, ${result.output.country}');

// Stream structured JSON
await for (final chunk in agent.sendStream(
  'List 3 facts',
  outputSchema: factsSchema,
)) {
  stdout.write(chunk.output); // Streams JSON chunks
}

final weatherTool = Tool(
  name: 'get_weather',
  description: 'Get current weather',
  inputSchema: weatherInputSchema,
  onCall: (input) => getWeather(input['city']),
);

final agent = Agent('openai', tools: [weatherTool]);

final result = await agent.sendFor<WeatherReport>(
  'Get weather for Seattle and format as a report',
  outputSchema: WeatherReport.schema,
  outputFromJson: WeatherReport.fromJson,
);

print(result.output); // WeatherReport with structured data