Conditional JSON Lines or JSON Array Prompt Template

This prompt is designed for data export pipelines and API endpoints that must dynamically choose between newline-delimited JSON (JSON Lines) for streaming ingestion and a standard JSON array for batch loading. The primary job-to-be-done is to accept a collection of records and a format selector, then produce a structurally valid output that matches the consumer's capability. The ideal user is a backend or data engineer building a multi-format export service who needs the model to enforce delimiter consistency for JSON Lines or bracket balancing for JSON arrays without manual post-processing.

Use this prompt when the output format must be conditional on a runtime flag such as format: "jsonl" or format: "array", and when the record count, consumer type, or downstream system requirements are not known at prompt design time. It is appropriate for systems that serve both real-time stream processors (which expect a \n delimiter between complete JSON objects) and batch ETL jobs (which expect a single valid JSON array). Do not use this prompt when the output is always a single record, when the format is statically known, or when you need streaming partial JSON chunks—those scenarios are better served by dedicated single-format or streaming-specific prompts.

Before deploying, you must pair this prompt with a validation harness that checks for the specific failure modes of each format: for JSON Lines, confirm that every line is a complete, parseable JSON object and that no extraneous text exists between delimiters; for JSON arrays, confirm bracket balancing, comma placement between elements, and that the entire payload parses as a single JSON document. If the output feeds a compliance or audit pipeline, add a human review step for the first export of a new data source. The next section provides the copy-ready prompt template you can adapt and wire into your application.

This prompt template is designed for data export pipelines that must dynamically choose between newline-delimited JSON (JSON Lines) for streaming ingestion and a standard JSON array for batch loading. It accepts a set of records, a format selector, and optional constraints, then produces structurally valid output in the requested collection format. The template includes explicit instructions for delimiter consistency, bracket balancing, and edge-case handling when the record set is empty or contains a single item.

textCopy
You are a data serialization engine. Your task is to output a collection of records in either JSON Lines (application/jsonlines) or a standard JSON array (application/json) based on the provided format selector.

## INPUT
[RECORDS]

## FORMAT SELECTOR
[FORMAT]
Valid values: "jsonl" | "json_array"

## CONSTRAINTS
[CONSTRAINTS]

## OUTPUT RULES

### If [FORMAT] is "jsonl":
- Output each record as a single, complete JSON object on its own line.
- Do not wrap the output in an array.
- Do not include a trailing newline after the last record unless [CONSTRAINTS] explicitly requires it.
- If [RECORDS] is empty, output nothing (zero bytes).
- Ensure every line is a parseable JSON object. No line should be empty or contain only whitespace.

### If [FORMAT] is "json_array":
- Output a single JSON array containing all records.
- The array must start with "[" and end with "]".
- If [RECORDS] is empty, output "[]".
- Each record must be a valid JSON object, separated by commas.
- Do not include trailing commas after the last element.

## GENERAL RULES
- Do not include any text outside the JSON output. No markdown fences, no explanations, no log lines.
- Preserve all fields, values, and ordering from [RECORDS] exactly as provided.
- If [CONSTRAINTS] includes a record limit, truncate the output to that limit and include a "truncated": true field in a metadata wrapper only if the wrapper is explicitly requested in [CONSTRAINTS].
- If [FORMAT] is not one of the valid values, default to "json_array" and include a warning field "format_warning": "invalid_format_defaulted_to_json_array" as the first element in the array.

To adapt this template for your pipeline, replace [RECORDS] with your serialized record set, [FORMAT] with the runtime selector value, and [CONSTRAINTS] with any additional rules such as record limits, field filtering, or metadata wrapping. Test the prompt with empty inputs, single-record inputs, and large record sets to verify delimiter consistency and bracket balancing. For high-throughput pipelines, pair this prompt with a post-generation validator that confirms each line parses as JSON (for JSON Lines) or that the full output parses as a single array (for JSON array mode) before the data enters downstream ingestion.

This prompt template is designed to sit inside a data export or API response pipeline where the output format must adapt to the consumer's ingestion capability. The harness should inject three critical runtime variables: the serialized record set, a record count, and a format selector flag. The format selector can be driven by an explicit consumer preference, a query parameter, or a threshold rule—for example, switching to JSON Lines when the record count exceeds 10,000 to enable streaming ingestion. The model's job is to apply the correct collection wrapper and delimiter discipline, not to transform individual record schemas. Keep record-level schema validation separate and run it before the records reach this prompt.

After the model responds, the harness must validate the structural envelope before releasing the payload. For json_array outputs, confirm the response parses as a single JSON array, that the opening and closing brackets are balanced, and that every element is a valid JSON object. For jsonl outputs, split on newline characters, reject any empty lines, and parse each non-empty line as a JSON object. A strict validator should also confirm that the line count matches the expected record count within an acceptable tolerance. If validation fails, implement a single retry with the same input but append a terse constraint reminder: 'The previous output failed structural validation. Ensure the output is valid [FORMAT] with correct delimiters and balanced brackets.' If the retry also fails, log the failure with the raw model output, the injected parameters, and the validator error, then fall back to returning a standard JSON array with an error envelope. For high-throughput pipelines, consider running the JSON Lines path through a streaming validator that checks each line as it arrives rather than buffering the entire response.

Model choice matters here. Use a model with strong JSON generation and instruction-following capabilities, such as GPT-4o, Claude 3.5 Sonnet, or an equivalent. Avoid smaller or older models that may drop closing brackets or inject commentary between JSON Lines records. Set temperature to 0 for deterministic format selection. Wire the prompt into your application with a thin adapter function that accepts a list of typed records, a format preference, and a consumer configuration object, then returns either a validated JSON array string or a validated JSON Lines string ready for streaming. Log every format decision, the record count, the validator result, and the final output byte size. This observability data will help you tune the record-count threshold and detect format drift before downstream consumers break.