This prompt is for real-time application developers and streaming infrastructure engineers who need to recover from a mid-stream disconnection or timeout without losing the model's generated context. The core job-to-be-done is to request a clean continuation from the exact truncation point, preserving the original task's tone, reasoning chain, and output format. The ideal user is someone building a production system—such as a chat interface, a coding copilot, or a real-time data extraction pipeline—where a dropped connection should not force the end-user to restart the entire interaction from scratch.
Prompt
Streaming Interruption Continuation Prompt Template

When to Use This Prompt
Define the job, reader, and constraints for the Streaming Interruption Continuation Prompt Template.
Use this prompt when you have a partial, well-formed output that was interrupted by a network error, a server-side timeout, or a client-side cancellation, and you need to stitch the remaining content seamlessly. The prompt is designed to work with the raw truncated text and the original system instructions. It is not suitable for repairing malformed JSON, fixing token-limit cutoffs where the model stopped naturally, or reassembling multiple independently streamed chunks. For those cases, use the sibling playbooks for 'Truncated JSON Completion Repair' or 'Streaming Chunk Reassembly.' Do not use this prompt if the interruption point is ambiguous, if the partial output is corrupted, or if the original task context is no longer available—the model will hallucinate a continuation rather than recover the intended output.
Before implementing this prompt in your harness, ensure you have captured the exact last 50–100 characters of the streamed output to use as the [TRUNCATION_POINT] and that you can reconstruct the full [ORIGINAL_SYSTEM_PROMPT] and [ORIGINAL_USER_MESSAGE]. The primary failure mode is duplication: the model may repeat the last few tokens already sent to the user. Your application layer must implement a deduplication check by comparing the overlap between the end of the partial output and the beginning of the continuation. If the workflow involves regulated data, customer-facing financial advice, or clinical documentation, a human must review the stitched output before it is delivered. Proceed to the 'Prompt Template' section for the copy-ready instruction set.
Use Case Fit
Where the Streaming Interruption Continuation Prompt Template works well and where it introduces risk. Use these cards to decide if this prompt fits your production context before wiring it into a harness.
Good Fit: Real-Time Streaming Applications
Use when: Your application consumes SSE or WebSocket streams and a mid-stream disconnect leaves a partial payload. The prompt requests continuation from the exact truncation point while preserving tone and format. Guardrail: Always log the last received token index and pass it as [TRUNCATION_POINT] to prevent context drift.
Bad Fit: Stateless One-Shot API Calls
Avoid when: You are using a single request-response pattern with no streaming state. A truncated response here indicates a max_tokens limit, not a connection drop. Use the Token-Limit Cutoff Detection and Recovery Prompt Template instead. Guardrail: Check response finish_reason before choosing the recovery strategy.
Required Input: Exact Truncation Boundary
Risk: If you pass the entire partial output without marking the exact cut point, the model may repeat content or skip the broken segment. Guardrail: Always include [PARTIAL_OUTPUT] with a clear [TRUNCATION_MARKER] token inserted at the break. Validate that the continuation starts immediately after the marker without duplication.
Required Input: Original System Prompt and Context
Risk: The continuation model lacks the original task definition, leading to tone shift, format drift, or hallucinated intent. Guardrail: Replay the full [ORIGINAL_SYSTEM_PROMPT] and [ORIGINAL_USER_MESSAGE] alongside the partial output. This preserves the task contract across the recovery boundary.
Operational Risk: Duplicate Content at Stitch Point
Risk: The model repeats the last few tokens from the partial output before continuing, creating a visible seam. Guardrail: Post-process the assembled output with a deduplication check at the stitch boundary. Use a sliding window of 10-20 tokens to detect and remove overlap before delivering to the client.
Operational Risk: Format Corruption Across Chunks
Risk: If the original output was mid-JSON, mid-code-block, or mid-markdown-fence, the continuation may break structural validity. Guardrail: Run the assembled output through the same schema validator or parser used for non-streaming responses. If validation fails, fall back to the Truncated JSON Completion Repair or Broken Markdown Fence Recovery templates.
Copy-Ready Prompt Template
A reusable prompt template for requesting continuation of a streamed response that was interrupted mid-generation.
This template is designed for real-time application developers who need to recover from a streaming interruption without losing context, tone, or output format. It instructs the model to continue generating from the exact point of truncation, using the provided partial output and original task context. The prompt is structured to prevent duplication, maintain schema adherence, and preserve the original reasoning chain.
textSYSTEM: You are a continuation assistant. Your task is to complete a response that was interrupted mid-generation. You will receive the original task, the partial output that was generated before the interruption, and the exact last token where generation stopped. You must continue from that exact point without repeating any content, preserving the original tone, format, and structure. Do not add introductory phrases, summaries, or commentary about the continuation. Output only the completion text that should be appended directly to the partial output. USER: Original Task: [ORIGINAL_TASK] Partial Output (truncated): [PARTIAL_OUTPUT] Last Token Before Interruption: [LAST_TOKEN] Output Format Required: [OUTPUT_FORMAT] Context Preservation Notes: [CONTEXT_NOTES] Continue from the exact truncation point. Output only the completion.
To adapt this template, replace the square-bracket placeholders with your actual values. [ORIGINAL_TASK] should contain the full prompt or instruction that initiated the original generation. [PARTIAL_OUTPUT] is the complete text received before the stream disconnected. [LAST_TOKEN] should be the final few characters or tokens of the partial output to help the model align its continuation precisely. [OUTPUT_FORMAT] specifies the expected structure (e.g., JSON, markdown, code block). [CONTEXT_NOTES] can include any additional state such as conversation history, tool call results, or reasoning steps that must be preserved. Before deploying, validate that the continuation stitches cleanly without duplication by checking the boundary between the partial output and the new completion. For high-stakes applications, implement a post-generation check that compares the last 50 characters of the partial output against the first 50 characters of the completion to detect overlap.
Prompt Variables
Required inputs for the Streaming Interruption Continuation Prompt Template. Each variable must be populated before the continuation request is sent to the model to ensure seamless stitching without context loss or duplication.
| Placeholder | Purpose | Example | Validation Notes |
|---|---|---|---|
[TRUNCATION_POINT] | The exact last 50-100 characters of the interrupted output, including any partial token or punctuation | "...the quarterly revenue increased by 12% due to strong" | Must end mid-token or mid-sentence. Validate length is 50-100 chars. Reject if it contains a complete sentence ending with punctuation followed by whitespace. |
[ORIGINAL_PROMPT] | The full system and user prompt that generated the truncated output, including all instructions and context | System: You are a financial analyst... User: Summarize the Q3 earnings report... | Must be the complete prompt payload, not a summary. Validate that all original instructions, schema constraints, and context are present. Missing instructions cause format drift in continuation. |
[OUTPUT_FORMAT] | The expected output schema, format, or structure the model must adhere to in the continuation | JSON object with fields: summary, key_metrics, risks | Must be an explicit schema or format description. Validate that it matches the original output format. If original was free text, specify tone and paragraph structure. Ambiguous format leads to stitching mismatches. |
[STREAM_SESSION_ID] | Unique identifier for the streaming session to correlate continuation with the original request in logs and traces | sess_8a7b3c2d_2025-01-15 | Must be a non-empty string. Validate format matches your tracing system convention. Required for production observability and debugging stitching failures. |
[MAX_CONTINUATION_TOKENS] | Token budget allocated for the continuation to prevent another truncation | 2048 | Must be a positive integer. Validate it is less than the model's context window minus the prompt token count. Set conservatively to leave room for the full remaining output. |
[TEMPERATURE] | Sampling temperature to use for the continuation; should match the original request to preserve tone consistency | 0.3 | Must be a float between 0.0 and 2.0. Validate it matches the original generation temperature. Mismatched temperature causes tone and determinism drift in the stitched output. |
[STOP_SEQUENCES] | Stop sequences that signal the end of the continuation, aligned with the original output's natural boundaries | ["\n\n##", "END_OF_REPORT"] | Must be an array of strings or null. Validate that stop sequences match the original output's section or document boundaries. Missing stop sequences risk the continuation overshooting and generating unrelated content. |
Implementation Harness Notes
How to wire the streaming interruption continuation prompt into a production application with validation, retries, and safe stitching.
Integrating the streaming interruption continuation prompt into a real-time application requires treating the prompt as one component inside a larger recovery harness. The application must detect the interruption, capture the exact truncation point and surrounding context, invoke the continuation prompt, and then stitch the result onto the original partial output without duplication or context loss. This is not a fire-and-forget operation—the harness must validate the boundary between the original fragment and the continuation, handle cases where the model restates content, and fall back gracefully when continuation fails.
The harness should maintain a structured record of the original request parameters (model, temperature, system prompt, messages, tools) alongside the partial output. When an interruption is detected—via a streaming error, timeout, or token-limit signal—capture the last complete sentence or structural boundary as the anchor point. Pass the original system prompt, conversation history, and the partial output up to the anchor into the continuation prompt's [PARTIAL_OUTPUT] placeholder. Set [OUTPUT_FORMAT] to match the original expected schema. After receiving the continuation, the harness must strip any repeated content by comparing the last N tokens of the original fragment with the first N tokens of the continuation and removing overlaps. Validate the stitched output against the original schema or format contract before returning it downstream.
For high-reliability systems, implement a retry policy with exponential backoff when the continuation prompt fails or produces invalid output. Log every recovery attempt with the truncation position, anchor text, continuation response, and stitch result for debugging. If the continuation introduces hallucinated content beyond the original task scope, the harness should flag the output for human review rather than silently accepting it. Avoid using continuation prompts for security-sensitive or compliance-critical content without a human-in-the-loop review step, as the model may infer incorrect context from the partial output. The harness should also enforce a maximum continuation length to prevent runaway generation, and if the stitched output still fails validation after two retries, escalate to a fallback workflow rather than looping indefinitely.
Expected Output Contract
Defines the required fields, types, and validation rules for the continuation response generated by the Streaming Interruption Continuation Prompt Template. Use this contract to validate the model's output before stitching it to the original partial payload.
| Field or Element | Type or Format | Required | Validation Rule |
|---|---|---|---|
continuation_text | string | Must not be empty or whitespace-only. Must not duplicate the last 50 characters of [TRUNCATED_OUTPUT]. | |
start_boundary_match | string | Must exactly match the final 20-30 characters of [TRUNCATED_OUTPUT] provided in [CONTINUATION_POINT]. Used for alignment verification. | |
output_format | string (enum) | Must match the format specified in [OUTPUT_SCHEMA] (e.g., 'json', 'markdown', 'code'). If unspecified, must match the detected format of [TRUNCATED_OUTPUT]. | |
tone_style_consistency | string (enum) | Must be classified as 'consistent' by a secondary LLM judge comparing the continuation to the [TRUNCATED_OUTPUT] preamble. Fail if 'shifted' or 'contradictory'. | |
completion_status | string (enum) | Must be one of: 'complete', 'incomplete'. If 'incomplete', the output must end with a valid structural breakpoint (e.g., end of a sentence, closing a function block). | |
hallucinated_content_flag | boolean | If true, the continuation introduces new entities, claims, or code logic not derivable from [TRUNCATED_OUTPUT] or [ORIGINAL_PROMPT]. Triggers a human review or retry. | |
stitching_instruction | string | If provided, must be a single, actionable instruction for the application layer on how to merge the payloads (e.g., 'remove_last_3_chars', 'append_directly'). Null if direct concatenation is safe. |
Common Failure Modes
Streaming interruption continuations fail in predictable ways. These are the most common production failure modes and the guardrails that catch them before users see broken output.
Duplicate Content at Stitch Boundary
What to watch: The continuation prompt repeats the last sentence, phrase, or token from the truncated output, creating visible duplication at the seam. This happens when the model over-anchors on the provided truncation point and restates it before continuing. Guardrail: Include an explicit instruction in the continuation prompt: 'Do not repeat or restate the final sentence shown above. Begin from the exact next word.' Validate with a boundary-overlap detector that checks the last N tokens of the original against the first N tokens of the continuation.
Context Drift from Lost Mid-Stream State
What to watch: The model loses the original task context, tone, persona, or output format during continuation because the truncated output alone does not carry enough signal. The continuation veers into a different style, switches voice, or forgets the output schema. Guardrail: Replay the full system prompt, task instruction, and output schema in the continuation request alongside the truncated output. Do not rely on the partial output alone to convey the task. Include a format-anchoring instruction: 'Continue in the exact same JSON schema and tone as the partial output above.'
Mid-Token Truncation Corruption
What to watch: The stream disconnects mid-token (e.g., inside a word, a JSON string value, or an escape sequence). The continuation prompt receives a broken token fragment that the model cannot interpret correctly, leading to garbled output or hallucinated completion of the fragment. Guardrail: Detect mid-token truncation before constructing the continuation prompt. If the final characters are not at a natural token boundary (whitespace, punctuation, closing bracket), trim back to the last safe boundary. Include the trimmed fragment as context but instruct the model to restart from that boundary, not from the broken fragment.
Schema Structure Breakage on Resume
What to watch: The original output was mid-way through a JSON object, array, or nested structure when truncated. The continuation prompt produces valid content but fails to maintain the structural nesting, resulting in unclosed braces, orphaned array elements, or broken parent-child relationships. Guardrail: Parse the truncated output to determine the structural state (open objects, array depth, unclosed quotes). Include a structural hint in the continuation prompt: 'You are continuing inside a JSON array. Continue adding elements to the array and close it properly.' Validate the stitched output with a full schema validator before returning to the caller.
Infinite Continuation Without Termination
What to watch: The continuation prompt succeeds but the model does not know when to stop. It continues generating beyond the natural endpoint, adding hallucinated content, repeating patterns, or appending unrelated material because the original stop condition was lost. Guardrail: Include an explicit stop condition in the continuation prompt: 'Stop when you reach the natural conclusion of the response. Do not add new topics, summaries, or closing statements that were not part of the original intent.' Set a max_tokens limit on the continuation request that is proportional to the expected remaining output length.
Stitching Artifacts in Streaming Consumers
What to watch: Even when the continuation is correct, the client-side stitching logic introduces artifacts—extra newlines, missing separators, broken SSE framing, or out-of-order chunk delivery that corrupts the assembled output for the end user. Guardrail: Implement a stitch validator that compares the assembled output against the expected format before delivering to the user. Test with a harness that simulates disconnection at random byte offsets and verifies the final assembled payload is byte-identical to a non-interrupted generation of the same content. Log stitch-boundary metadata for debugging.
Evaluation Rubric
Use these criteria to test whether the continuation prompt produces a seamless, non-duplicative, and context-preserving stitch before deploying to production.
| Criterion | Pass Standard | Failure Signal | Test Method |
|---|---|---|---|
Boundary Stitch Accuracy | Continuation starts from the exact character or token where [TRUNCATED_OUTPUT] ended, with no repeated words or missing characters. | Output repeats the last 1-3 words of [TRUNCATED_OUTPUT] or starts mid-sentence with a gap. | Automated diff check: concatenate [TRUNCATED_OUTPUT] + [CONTINUATION_OUTPUT] and verify no duplicate n-gram overlap at the boundary. |
Context Preservation | Continuation respects all constraints from [ORIGINAL_SYSTEM_PROMPT] and [ORIGINAL_USER_PROMPT] without re-explaining the task. | Continuation restates the original task, re-introduces context, or shifts tone/formality from the truncated portion. | LLM-as-judge evaluation: compare tone, task adherence, and constraint compliance between [TRUNCATED_OUTPUT] and [CONTINUATION_OUTPUT]. |
Format Consistency | Continuation maintains the exact output format (JSON structure, markdown, code fence, etc.) specified in [OUTPUT_SCHEMA]. | Continuation switches format mid-stream, drops a required field, or adds an unrequested wrapper. | Schema validator check: parse the full stitched output against [OUTPUT_SCHEMA] and confirm zero validation errors. |
No Hallucinated Closure | Continuation does not invent a summary, conclusion, or closing statement unless the original task explicitly required one. | Continuation adds 'In summary...', 'I hope this helps!', or similar unsolicited closing language. | Pattern match check: scan [CONTINUATION_OUTPUT] for common closure phrases; flag any match as failure. |
Token Budget Adherence | Continuation request fits within the remaining token budget and does not itself get truncated. | Continuation ends mid-word or mid-structure, requiring another repair cycle. | Token counter check: verify [CONTINUATION_OUTPUT] finish_reason is 'stop', not 'length' or 'max_tokens'. |
Idempotency | Running the continuation prompt twice with identical inputs produces semantically equivalent outputs. | Two runs produce materially different continuations (different facts, structure, or length). | Pairwise comparison: run twice, embed both outputs, and verify cosine similarity > 0.95. |
Error Surface | If [TRUNCATED_OUTPUT] is irrecoverable (e.g., cut mid-token in a critical field), the continuation prompt returns a structured error instead of guessing. | Continuation hallucinates plausible content to fill an unrecoverable gap. | Trigger test: provide a deliberately unrecoverable truncation and assert [CONTINUATION_OUTPUT] matches the error contract in [ERROR_SCHEMA]. |
Latency Budget | Continuation request completes within the application's streaming timeout window. | Continuation takes longer than the original generation, causing a second timeout. | Load test: measure p95 latency of continuation prompt under production-like load and assert it is below [MAX_CONTINUATION_LATENCY_MS]. |
Enabling Efficiency, Speed & Accuracy
Intelligent Analysis, Decision & Execution
We build AI systems for teams that need search across company data, workflow automation across tools, or AI features inside products and internal software.
Talk to Us
Search across company data
Give teams answers from docs, tickets, runbooks, and product data with sources and permissions.
Useful when people spend too long searching or get different answers from different systems.

Automate internal workflows
Use AI to route work, draft outputs, trigger actions, and keep approvals and logs in place.
Useful when repetitive work moves across multiple tools and teams.

Add AI to products and internal tools
Build assistants, guided actions, or decision support into the software your team or customers already use.
Useful when AI needs to be part of the product, not a separate tool.
Adapt This Prompt
How to adapt
Start with the base continuation prompt and a simple boundary-detection heuristic. Use the last 100–200 characters of the truncated output as [PARTIAL_OUTPUT] and the original task as [ORIGINAL_TASK]. Skip schema validation initially—focus on whether the model produces a coherent stitch without duplicating the boundary text.
codeYou were generating output for: [ORIGINAL_TASK] The output was cut off at: [PARTIAL_OUTPUT] Continue from exactly where it stopped. Do not repeat any text already present in [PARTIAL_OUTPUT]. Maintain the same tone, format, and structure.
Watch for
- Boundary duplication where the model repeats the last few words before continuing
- Format drift when the continuation switches from structured output to prose
- Missing context from earlier in the generation that the model needs to resume correctly

About the author
Prasad Kumkar
CEO & MD, Inference Systems
Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.
His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.
Partnered with leading AI, data, and software stack.
How We Work
Custom AI workflows for your Business
One-fit-all AI don't work for modern businesses. At Inferensys, we aim to understand your business & custom requirements; which we use to define most efficient agentic workflows, the data, and the tools for your business.
01
Review the use case
We understand the task, the users, and where AI can actually help.
Read more02
Pick the right approach
We define what needs search, automation, or product integration.
Read more03
Build the first useful version
We implement the part that proves the value first.
Read more04
Improve from there
We add the checks and visibility needed to keep it useful.
Read moreThe first call is a practical review of your use case and the right next step.
Talk to Us