[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] NOVEMBER ONE SEVEN XRAY XRAY NUMBER TWO FOLLOW THE ARCHER ON SHORT FINAL over

[Assistant] {"segments": [{"intent": "sequencing", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] November One Seven X-ray X-ray, San Carlos Tower, maintain pattern altitude one thousand, report midfield downwind.

[Assistant] {"segments": [{"intent": "altitude_instruction", "slots": {"altitude": "one thousand"}, "text": ""}, {"intent": "report_request", "slots": {"pattern_leg": "midfield downwind"}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] November One Seven X-ray X-ray, radar contact, climb and maintain three thousand, proceed direct SUNOL.

[Assistant] {"segments": [{"intent": "radar_identification", "slots": {}, "text": ""}, {"intent": "altitude_instruction", "slots": {"direction": "climb", "altitude": "3000"}, "text": ""}, {"intent": "direct_to", "slots": {"fix": "SUNOL"}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] November One Seven X-ray X-ray, make a left three sixty on downwind for spacing.

[Assistant] {"segments": [{"intent": "spacing_instruction", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] November One Seven Xray Xray Make A Left Three Sixty On Downwind For Spacing Traffic Piper On Extended Base You'll Follow After Your Three Hundred Sixty

[Assistant] {"segments": [{"intent": "spacing_instruction", "slots": {"direction": "left", "pattern_leg": "downwind"}, "text": ""}, {"intent": "traffic_advisory", "slots": {}, "text": ""}, {"intent": "sequencing", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] runway two eight cleared to land

[Assistant] {"segments": [{"intent": "other", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] Lafayette Ground Ground. Warrior 31862. At general aviation parking. Ready to taxi, with information Whiskey. VFR.

[Assistant] {"segments": [{"intent": "taxi_instruction", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] TOWER NOVEMBER ONE SEVEN XRAY XRAY TEN MILES NORTH OF LAFAYETTE TWO THOUSAND FIVE HUNDRED INBOUND FOR LANDING AT LAFAYETTE

[Assistant] {"segments": [{"intent": "comm_request", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] , you're number four, follow the Cherokee when he turns base

[Assistant] {"segments": [{"intent": "sequencing", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] , extend downwind, traffic turning base

[Assistant] {"segments": [{"intent": "extend_downwind", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] N17XX LAFIETT TOWER CAUTION WIND SHEER REPORTED MAKE RIGHT TRAFFIC RUNWAY FIVE CLEARED FOR TAKEOFF

[Assistant] {"segments": [{"intent": "weather_advisory", "slots": {}, "text": ""}, {"intent": "pattern_entry", "slots": {"pattern_leg": "right traffic"}, "text": ""}, {"intent": "takeoff_clearance", "slots": {"runway": "five"}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] TURN FINAL RUNWAY TWO EIGHT WIND THREE ZERO ZERO AT EIGHT CLEARED TO LAND ADS BE TRAFFIC CLEARED

[Assistant] {"segments": [{"intent": "other", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] REMAIN CLEAR TRAFFIC INBOUND OVER

[Assistant] {"segments": [{"intent": "other", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] 2. TRAFFIC TO FOLLOW STRAIGHT IN RUNWAY TWO THREE NOVEMBER ONE SEVEN XRAY XRAY over

[Assistant] {"segments": [{"intent": "sequencing", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] Chicago Center NOVEMBER ONE SEVEN XRAY XRAY ONE TWO MILES NORTHWEST OF LAFIETTE AT ONE THOUSAND TWO HUNDRED REQUEST FLIGHT FOLLOWING INTO INDIANAPOLIS EAGLE CREEK

[Assistant] {"segments": [{"intent": "comm_request", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] All Aircraft Six In The Pattern Sequencing In Progress

[Assistant] {"segments": [{"intent": "informational", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] N17XX SAN CARLOS TOWER MAINTAIN PATTERN ALTITUDE ONE THOUSAND REPORT MIDFIELD DOWNWIND

[Assistant] {"segments": [{"intent": "altitude_instruction", "slots": {"altitude": "one thousand"}, "text": ""}, {"intent": "report_request", "slots": {"pattern_leg": "midfield downwind"}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] ADIZ PENETRATION AHEAD MAINTAIN TWO WAY RADIO COMMUNICATION SQUAWK FOUR TWO THREE ONE MODE C REQUIRED

[Assistant] {"segments": [{"intent": "informational", "slots": {}, "text": ""}, {"intent": "squawk_code_set", "slots": {"transponder_code": "4231"}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] traffic advisory aircraft at your one o'clock two miles no factor

[Assistant] {"segments": [{"intent": "traffic_advisory", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] All aircraft, Flight Service Station, VFR conditions

[Assistant] {"segments": [{"intent": "informational", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] November One Seven X-ray X-ray, NorCal Departure, level two thousand five hundred, proceeding direct San Carlos

[Assistant] {"segments": [{"intent": "position_report", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] PALLO ALTO TRAFFIC N17XX SOUTHBOUND OFF PALLO ALTO ONE THOUSAND EIGHT HUNDRED ENGINE EMERGENCY REMAINING CLEARED OF THE PATTERN

[Assistant] {"segments": [{"intent": "ctaf_broadcast", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] November One Seven X-ray X-ray, turn right heading one five zero, descend to two thousand, maintain VFR.

[Assistant] {"segments": [{"intent": "heading_instruction", "slots": {"direction": "right", "heading": "150"}, "text": ""}, {"intent": "altitude_instruction", "slots": {"direction": "descend", "altitude": "2000"}, "text": ""}, {"intent": "vfr_instruction", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] REMAIN CLEAR AIRCRAFT ON DEPARTURE OVER

[Assistant] {"segments": [{"intent": "other", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] Continue Downwind Traffic Bonanza On Final

[Assistant] {"segments": [{"intent": "traffic_advisory", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] Transition approved. November One Seven X-ray X-ray.

[Assistant] {"segments": [{"intent": "acknowledgment", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] NUMBER TWO FOLLOW THE ARCHER ON SHORT FINAL

[Assistant] {"segments": [{"intent": "sequencing", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] November One Seven X-ray X-ray, resume normal speed.

[Assistant] {"segments": [{"intent": "speed_assignment", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] REMAIN CLEAR ADIS TRAFFIC INBOUND over

[Assistant] {"segments": [{"intent": "informational", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] TOWER NOVEMBER ONE SEVEN XRAY XRAY TEN MILES NORTH OF LAFAYETTE TWO THOUSAND FIVE HUNDRED REQUEST ENTRY TO CLASS B AIRSPACE

[Assistant] {"segments": [{"intent": "comm_request", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] NOVEMBER ONE SEVEN XRAY XRAY INDIANAPOLIS APPROACH ENTER LEFT DOWNWIND RUNWAY TWO THREE LEFT CONTACT INDIANAPOLIS TOWER ONE TWO ZERO DECIMAL NINER over

[Assistant] {"segments": [{"intent": "pattern_entry", "slots": {"pattern_leg": "left downwind", "runway": "two three left"}, "text": ""}, {"intent": "frequency_change", "slots": {"facility": "Indianapolis Tower", "frequency": "one two zero point niner"}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] NOVEMBER ONE SEVEN XRAY XRAY RUNWAY THREE ONE CLEARED FOR THE OPTION

[Assistant] {"segments": [{"intent": "cleared_option", "slots": {"runway": "three one"}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] NOVEMBER ONE SEVEN XRAY XRAY LAFIETT TOWER RUNWAY FIVE CLEARED FOR TAKEOFF MAKE RIGHT TRAFFIC FOR NORTH DEPARTURE OVER

[Assistant] {"segments": [{"intent": "takeoff_clearance", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] Reid-Hillview traffic. November One Seven X-ray X-ray. Departing Runway three one, north departure. Reid-Hillview.

[Assistant] {"segments": [{"intent": "ctaf_broadcast", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] November One Seven Xray Xray Fss Radar State Request

[Assistant] {"segments": [{"intent": "comm_request", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] , cleared to land runway three one, traffic Cessna on close base

[Assistant] {"segments": [{"intent": "landing_clearance", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] NOVEMBER ONE SEVEN XRAY XRAY NORCAL DEPARTURE MAINTAIN HEADING TWO SEVEN ZERO TRAFFIC CLEARED REPORT WHEN TRAFFIC PASSED

[Assistant] {"segments": [{"intent": "other", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] Exit Left Right At Alpha Contact Ground On One One Niner Decimal Three November One Seven Xray Xray

[Assistant] {"segments": [{"intent": "frequency_change", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] November One Seven X-ray X-ray, Indianapolis Approach, say airspeed.

[Assistant] {"segments": [{"intent": "verification_request", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] Taxi To Parking Via Bravo

[Assistant] {"segments": [{"intent": "taxi_instruction", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] REMAIN CLEAR TRAFFIC INBOUND

[Assistant] {"segments": [{"intent": "other", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] , SAN CARLO'S TOWER LEFT BASE RUNWAY THREE ZERO CLEARED TOUCH AND GO.

[Assistant] {"segments": [{"intent": "cleared_touch_and_go", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] N17XX SAN CARLOS TOWER SHORT FINAL RUNWAY THREE ZERO CLEARED TO LAND

[Assistant] {"segments": [{"intent": "position_report", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] READ HILL VIEW TRAFFIC NOVEMBER ONE SEVEN XRAY XRAY HOLDING SHORT RUNWAY THREE ONE READ HILL VIEW

[Assistant] {"segments": [{"intent": "ctaf_broadcast", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] EXIT RIGHT AT C2 CONTACT GROUND AT ONE HUNDRED TWENTY ONE POINT NINER WARRIOR THIRTY ONE THOUSAND EIGHT HUNDRED SIXTY TWO over

[Assistant] {"segments": [{"intent": "taxi_instruction", "slots": {}, "text": ""}], "abstain_reason": null}


[System]
You are an ATC parser. Parse the air traffic control transmission into a JSON object.

OUTPUT SCHEMA (always emit `segments` list, even single-intent turns):
{
  "segments": [
    {"intent": <one-of-enum>, "slots": {<lowercase_key>: <value>}, "text": <segment substring>}
  ],
  "abstain_reason": null | <short reason if unsure>
}

Intent enum (51 values, includes `unknown` for ambiguous/garbled):
acknowledgment, altimeter_setting, altitude_instruction, approach_clearance, cleared_option, cleared_touch_and_go, comm_request, correction, crossing_restriction, ctaf_broadcast, departure_instruction, direct_to, disregard, emergency_declaration, extend_downwind, frequency_change, go_around, ground_hold, heading_instruction, hold_for_release, hold_instruction, hold_short, ident, ifr_clearance, informational, landing_clearance, line_up_and_wait, missed_approach, other, pattern_entry, position_report, radar_identification, radar_status, release, report_request, route_amendment, route_clearance, runway_crossing, sequencing, short_approach, spacing_instruction, speed_assignment, squawk_code_set, takeoff_clearance, taxi_instruction, traffic_advisory, unable_response, verification_request, vfr_instruction, weather_advisory, unknown

Slot keys (lowercase only): altimeter_setting, altitude, approach_type, call_sign, clock_position, direction, distance, facility, fix, frequency, heading, pattern_leg, route, runway, speed, taxiway, time, transponder_code, turn_direction, sequence

Rules:
1. Compound transmissions get multiple segments — split by comma, period, or new clause.
2. Single-intent transmissions still emit one segment in the list.
3. Use `unknown` intent + `abstain_reason` when transcript is garbled, partial, or doesn't match any enum.
4. Slots is FMM-relevant subset only — do NOT include callsign or facility unless required for the action.
5. Output ONLY the JSON object.

[User] November One Seven Xray Xray Egle Creek Tower Runway Two Seven Left Cleared To Land

[Assistant] {"segments": [{"intent": "landing_clearance", "slots": {"runway": "two seven left"}, "text": ""}], "abstain_reason": null}