Context-Preserving Resume Prompt Template

This prompt is for production engineers and API developers who need to recover from generation interruptions caused by timeouts, network errors, or token-limit cutoffs. Unlike simpler repair prompts that fix structural damage, this template reconstructs the full task context from a partial output and requests intelligent continuation that respects the original intent, schema, tone, and reasoning chain. Use this when you cannot afford to restart from scratch because the partial output contains valuable reasoning, computed values, or intermediate state that would be expensive or impossible to regenerate identically.

The ideal use case is a long-running generation—such as a multi-step analysis, a code review across several files, or a structured report—where the model has already produced significant work before the connection dropped. In these scenarios, discarding the partial output and restarting wastes tokens, loses non-deterministic reasoning, and risks producing a different result on the second attempt. The resume prompt works by packaging the original system instructions, the user task, and the truncated output into a single continuation request, with explicit instructions to pick up exactly where generation stopped without repeating, summarizing, or altering what came before. This approach is most reliable when the truncation point is clean (e.g., mid-sentence or mid-JSON value) rather than inside a partially emitted token.

Do not use this prompt when the partial output is corrupted, contains hallucinated content, or violates the output schema in ways that would propagate into the continuation. If the model has already drifted from the original task—producing off-topic content, switching languages, or ignoring constraints—resuming from that point will amplify the error. In those cases, a full restart with adjusted parameters or a repair-focused prompt is safer. Similarly, avoid resume prompts for tasks where non-determinism is unacceptable and exact reproducibility matters more than token savings; a fresh generation with temperature zero and a known seed is the better choice. Before wiring this into an automated recovery loop, test whether your model reliably respects continuation boundaries by running eval cases with known truncation points and measuring both boundary adherence and output completeness.

This prompt template reconstructs the full generation state from a partial output and requests a clean continuation. It is designed to be dropped into a retry handler or continuation workflow where the original task instructions, context, and partial output are available. The template uses square-bracket placeholders that your application must populate before sending the request. The goal is to produce a completion that is indistinguishable from what the model would have generated in a single uninterrupted run.

textCopy
You are continuing a generation that was interrupted mid-response. Your task is to complete the output exactly where it stopped, preserving the original intent, format, tone, and structure.

## ORIGINAL TASK INSTRUCTIONS
[ORIGINAL_SYSTEM_PROMPT]

## ORIGINAL USER REQUEST
[ORIGINAL_USER_MESSAGE]

## CONTEXT AND CONSTRAINTS
[ORIGINAL_CONTEXT]

## OUTPUT FORMAT SPECIFICATION
[OUTPUT_SCHEMA]

## PARTIAL OUTPUT (DO NOT REPEAT)
The following output was generated before interruption. Start your continuation immediately after the last character, without repeating any content:

[PARTIAL_OUTPUT]

## CONTINUATION INSTRUCTIONS
1. Begin generating from the exact point where the partial output ends.
2. Do not repeat, summarize, or reference the partial output.
3. Maintain the same tone, style, and formatting as the partial output.
4. Complete all remaining sections, fields, or content as specified in the output format.
5. If the partial output ends mid-word, complete that word naturally.
6. If the partial output ends mid-structure (e.g., inside a JSON object, code block, or list), close the structure correctly.
7. Do not add introductory phrases like "Continuing from where we left off" or "Here is the remainder."
8. If you cannot determine how to continue with high confidence, output only the token [UNABLE_TO_CONTINUE] and stop.

## FIDELITY CHECK
Before responding, verify:
- The continuation point matches the partial output's final content.
- The continuation format matches the output format specification.
- No content from the partial output is duplicated.

Adaptation guidance: Replace [ORIGINAL_SYSTEM_PROMPT] with the full system prompt from the original request. Replace [ORIGINAL_USER_MESSAGE] with the user message that initiated generation. Replace [ORIGINAL_CONTEXT] with any retrieved documents, tool outputs, or conversation history that informed the original generation. Replace [OUTPUT_SCHEMA] with the expected output format—this could be a JSON schema, a markdown template, or a natural language description of the required structure. Replace [PARTIAL_OUTPUT] with the exact truncated text, including any mid-word or mid-structure break. The fidelity check at the end acts as a self-verification step that reduces the risk of duplication or format drift.

When to use this template: Use this when you have the full original request context and a partial output that was cut off by max_tokens, a timeout, or a streaming disconnection. Do not use this template if the original context is lost or if the partial output is corrupted beyond recognition—in those cases, restart generation from scratch. For production systems, always validate the stitched output against the expected schema and run a duplication check comparing the partial output with the continuation. If the model outputs [UNABLE_TO_CONTINUE], escalate to a full regeneration with the original request rather than retrying the continuation.

Eval integration: After receiving the continuation, concatenate the partial output with the continuation and run the full result through your standard validation pipeline. Key eval checks include: (1) the continuation does not repeat any content from the partial output, (2) the stitched output passes schema validation, (3) the tone and style are consistent across the boundary, and (4) no hallucinated content appears that wasn't implied by the original task. For high-risk workflows, route stitched outputs to a human review queue before they reach downstream systems.

The Context-Preserving Resume Prompt is not a standalone prompt; it is a recovery component inside a larger orchestration layer. Its job is to reconstruct the full task state from a partial output and request a clean continuation. This means the harness must capture the original prompt, the partial output, the exact truncation point, and any schema or format constraints before calling the resume prompt. Do not rely on the model to remember the original task from conversation history alone—always re-supply the full original prompt and the partial output as explicit inputs to the resume template.

Implement this as a retry middleware or a dedicated recovery step in your generation pipeline. When a generation call returns a finish_reason of length or a streaming connection drops mid-token, the harness should: (1) capture the complete partial output string, (2) identify the truncation boundary (the last complete token, line, or structural unit before the cut), (3) populate the resume prompt template with [ORIGINAL_PROMPT], [PARTIAL_OUTPUT], and [OUTPUT_SCHEMA], and (4) issue a new completion request with a sufficient max_tokens budget for the remaining work. For streaming interruptions, buffer the last N chunks and use the final complete chunk as the truncation point. Log every resume attempt with a unique resume_id, the original request_id, the truncation byte offset, and the model used for the continuation. This trace data is essential for debugging stitching failures and measuring resume success rates.

Validation after the resume is critical. The harness must run at least three checks on the combined output: a structural validity check (does the full output parse as valid JSON, XML, or the target format?), a continuity check (does the resumed portion start exactly where the partial output ended, without duplication or gaps?), and a schema compliance check (does the complete output satisfy the original [OUTPUT_SCHEMA]?). For high-stakes workflows, add a fourth check: a semantic fidelity eval where a separate model call or a deterministic heuristic confirms that the resumed output addresses all requirements from the original prompt. If any check fails, do not blindly retry the resume prompt—instead, escalate to a fallback path: re-generate from scratch with a higher token limit, split the task into smaller sub-tasks, or flag for human review.

Model choice matters for resume reliability. Use a model with strong instruction-following and long-context handling for the resume call—Claude 3.5 Sonnet or GPT-4o are good defaults. Avoid small or fast models for resume tasks because they are more likely to hallucinate content beyond the partial output or ignore the continuation boundary. Set the temperature to 0 or a very low value (0.0–0.1) to maximize deterministic continuation. If your primary generation used a high temperature for creativity, consider that the resumed portion may exhibit a style shift; document this trade-off and monitor for tone consistency in your eval harness.

When integrating this into an agent loop, treat the resume prompt as a tool call rather than a conversation turn. The agent should detect truncation from the tool output or the model response metadata, invoke the resume prompt with the captured state, and then merge the continuation into its working memory. Do not expose the resume prompt directly to end users—it is an infrastructure concern. Finally, set a maximum resume depth (we recommend 2 attempts) to prevent infinite recovery loops. After the limit, log the failure, surface the partial output with a truncation warning, and let the upstream application decide whether to accept partial results or request a fresh generation.